Lucid ORM

PetraDB fournit un pilote AdonisJS Lucid via le package @petradb/lucid. Cela vous permet d’utiliser l’ORM, les migrations, les seeders et le constructeur de requêtes de Lucid avec le moteur SQL embarquable de PetraDB.

Installation

npm install @petradb/lucid @petradb/knex knex

Configuration

Importez @petradb/lucid avant de créer toute connexion Lucid. L’import modifie les composants internes de Lucid pour accepter petradb comme client de base de données valide.

Application AdonisJS

Dans votre projet AdonisJS, ajoutez un import à effet de bord en haut de votre configuration de base de données :

config/database.ts

import '@petradb/lucid'
import { defineConfig } from '@adonisjs/lucid'

export default defineConfig({
  connection: 'petradb',
  connections: {
    petradb: {
      client: 'petradb',
      connection: {
        storage: 'persistent',
        path: './data/app.petra',
      },
      useNullAsDefault: true,
    },
  },
})

Utilisation autonome

Vous pouvez utiliser la classe Database de Lucid directement sans AdonisJS :

import '@petradb/lucid'
import { Database } from '@adonisjs/lucid/database'

const db = new Database({
  connection: 'petradb',
  connections: {
    petradb: {
      client: 'petradb' as any,
      connection: {
        storage: 'memory',
      },
      useNullAsDefault: true,
    },
  },
}, logger, emitter)

Modes de stockage

Configuration via connection :

// En mémoire (par défaut)
{ storage: "memory" }

// Stockage persistant sur fichier
{ storage: "persistent", path: "./mydb.petra" }

Constructeur de schémas

// Créer une table
await db.schema.createTable("users", (t) => {
  t.increments("id")
  t.string("name").notNullable()
  t.string("email").unique()
  t.integer("age")
  t.boolean("active").defaultTo(true)
  t.timestamps(true, true)
})

// Vérifier si une table/colonne existe
await db.schema.hasTable("users")
await db.schema.hasColumn("users", "email")

// Ajouter une colonne
await db.schema.alterTable("users", (t) => {
  t.string("bio")
})

// Supprimer une table
await db.schema.dropTableIfExists("users")

Constructeur de requêtes

// Insertion
await db.table("users").insert({ name: "Alice", age: 30 })

// Insertion avec returning
const [user] = await db.table("users")
  .insert({ name: "Bob", age: 25 })
  .returning("*")

// Sélection
const users = await db.from("users").where("age", ">", 25)
const first = await db.from("users").where("name", "Alice").first()

// Mise à jour
await db.from("users").where("name", "Alice").update({ age: 31 })

// Suppression
await db.from("users").where("active", false).delete()

// Agrégats
const [{ count }] = await db.from("users").count("* as count")

Requêtes brutes

const result = await db.rawQuery("SELECT * FROM users WHERE age > ?", [25])

Transactions

await db.transaction(async (trx) => {
  await trx.table("users").insert({ name: "Eve", age: 22 })
  await trx.from("users").where("name", "Bob").update({ age: 26 })
})

Modèles ORM

Définissez des modèles en utilisant le BaseModel de Lucid :

import { BaseModel, column } from '@adonisjs/lucid/orm'

class User extends BaseModel {
  @column({ isPrimary: true })
  declare id: number

  @column()
  declare name: string

  @column()
  declare email: string
}

// Créer
const user = await User.create({ name: "Alice", email: "alice@example.com" })

// Trouver
const found = await User.find(user.id)
const all = await User.all()

// Mettre à jour
found.name = "Alicia"
await found.save()

// Supprimer
await found.delete()

// Portées de requête
const active = await User.query().where("active", true)

Migrations

Créez des fichiers de migration et exécutez-les avec le migrateur Lucid :

import { BaseSchema } from '@adonisjs/lucid/schema'

export default class CreateUsersTable extends BaseSchema {
  async up() {
    this.schema.createTable("users", (t) => {
      t.increments("id")
      t.string("name").notNullable()
      t.string("email").unique()
      t.timestamps(true, true)
    })
  }

  async down() {
    this.schema.dropTable("users")
  }
}

Fonctionnalités du dialecte

Le dialecte PetraDB supporte :

• Introspection de schéma (getAllTables, getAllViews, getAllTypes)
• Instructions RETURNING
• Troncature de tables
• Suppression de toutes les tables/vues/types
• DDL dans les transactions (entièrement atomique avec rollback DML)

Non supporté :

• Verrous consultatifs (non nécessaires pour un moteur embarquable)
• Domaines

Nettoyage

await db.manager.closeAll()