@petradb/lucid 1.2.0

package/dist/dialect.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PetraDB dialect for AdonisJS Lucid.
+ *
+ * Modeled after PgDialect since PetraDB is PostgreSQL-compatible,
+ * but uses PetraDB-specific SQL (SHOW TABLES, SHOW VIEWS, etc.).
+ */
+export declare class PetraDBDialect {
+    client: any;
+    config: any;
+    name: string;
+    supportsAdvisoryLocks: boolean;
+    supportsViews: boolean;
+    supportsTypes: boolean;
+    supportsDomains: boolean;
+    supportsReturningStatement: boolean;
+    version: string | undefined;
+    dateTimeFormat: string;
+    constructor(client: any, config: any);
+    getAllTables(_schemas?: string[]): Promise<string[]>;
+    getAllViews(_schemas?: string[]): Promise<string[]>;
+    getAllTypes(_schemas?: string[]): Promise<string[]>;
+    getAllDomains(_schemas?: string[]): Promise<string[]>;
+    truncate(table: string, _cascade?: boolean): Promise<void>;
+    truncateAllTables(excludeTables?: string[], _schemas?: string[]): Promise<void>;
+    dropAllTables(_schemas?: string[]): Promise<void>;
+    dropAllViews(_schemas?: string[]): Promise<void>;
+    dropAllTypes(_schemas?: string[]): Promise<void>;
+    dropAllDomains(_schemas?: string[]): Promise<void>;
+    getAdvisoryLock(_key: number): Promise<boolean>;
+    releaseAdvisoryLock(_key: number): Promise<boolean>;
+}

package/dist/dialect.js

@@ -0,0 +1,83 @@
+// @ts-nocheck — Lucid internals are untyped; we implement DialectContract at runtime.
+/**
+ * PetraDB dialect for AdonisJS Lucid.
+ *
+ * Modeled after PgDialect since PetraDB is PostgreSQL-compatible,
+ * but uses PetraDB-specific SQL (SHOW TABLES, SHOW VIEWS, etc.).
+ */
+export class PetraDBDialect {
+    client;
+    config;
+    name = "petradb";
+    supportsAdvisoryLocks = false;
+    supportsViews = true;
+    supportsTypes = true;
+    supportsDomains = false;
+    supportsReturningStatement = true;
+    version;
+    dateTimeFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZZ";
+    constructor(client, config) {
+        this.client = client;
+        this.config = config;
+    }
+    async getAllTables(_schemas) {
+        const result = await this.client.rawQuery("SHOW TABLES");
+        const rows = result.rows || result;
+        return rows.map((r) => r.table_name || r.name);
+    }
+    async getAllViews(_schemas) {
+        const result = await this.client.rawQuery("SHOW VIEWS");
+        const rows = result.rows || result;
+        return rows.map((r) => r.view_name || r.name);
+    }
+    async getAllTypes(_schemas) {
+        const result = await this.client.rawQuery("SHOW TYPES");
+        const rows = result.rows || result;
+        return rows.map((r) => r.type_name || r.name);
+    }
+    async getAllDomains(_schemas) {
+        return [];
+    }
+    async truncate(table, _cascade) {
+        await this.client.rawQuery(`TRUNCATE TABLE "${table}"`);
+    }
+    async truncateAllTables(excludeTables, _schemas) {
+        const tables = await this.getAllTables();
+        const exclude = new Set(excludeTables || []);
+        for (const table of tables) {
+            if (!exclude.has(table)) {
+                await this.truncate(table);
+            }
+        }
+    }
+    async dropAllTables(_schemas) {
+        const tables = await this.getAllTables();
+        const ignore = this.config.wipe?.ignoreTables || [];
+        for (const table of tables) {
+            if (!ignore.includes(table)) {
+                await this.client.rawQuery(`DROP TABLE "${table}" CASCADE`);
+            }
+        }
+    }
+    async dropAllViews(_schemas) {
+        const views = await this.getAllViews();
+        for (const view of views) {
+            await this.client.rawQuery(`DROP VIEW "${view}"`);
+        }
+    }
+    async dropAllTypes(_schemas) {
+        const types = await this.getAllTypes();
+        for (const type of types) {
+            await this.client.rawQuery(`DROP TYPE "${type}"`);
+        }
+    }
+    async dropAllDomains(_schemas) {
+        // PetraDB doesn't support domains
+    }
+    async getAdvisoryLock(_key) {
+        return false;
+    }
+    async releaseAdvisoryLock(_key) {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { PetraDBDialect } from "./dialect.js";
+export { PetraDBDialect };

package/dist/index.js

@@ -0,0 +1,70 @@
+// @ts-nocheck — Monkey-patches Lucid internals which are untyped.
+import { createRequire } from "node:module";
+import path from "node:path";
+import { PetraDBDialect } from "./dialect.js";
+const _require = createRequire(import.meta.url);
+/**
+ * Resolve the actual filesystem path of @adonisjs/lucid's build directory.
+ * We use absolute paths to bypass the package's exports map, which doesn't
+ * expose internal modules we need to patch.
+ */
+function lucidBuildDir() {
+    // require.resolve('@adonisjs/lucid') returns .../build/index.js
+    return path.dirname(_require.resolve("@adonisjs/lucid"));
+}
+/**
+ * Patch Lucid's client allowlist to accept 'petradb' as a valid client name.
+ *
+ * This must run before any Lucid connections are created. Import this module
+ * as a side-effect import in your AdonisJS app:
+ *
+ *   import '@petradb/lucid'
+ */
+function patch() {
+    const buildDir = lucidBuildDir();
+    // 1. Add PetraDBDialect to the dialect mapping
+    const dialects = _require(path.join(buildDir, "src/dialects/index.js"));
+    dialects.clientsToDialectsMapping["petradb"] = PetraDBDialect;
+    // 2. Update the clientsNames array (used for validation in Connection constructor)
+    if (!dialects.clientsNames.includes("petradb")) {
+        dialects.clientsNames.push("petradb");
+    }
+    // 3. Patch Connection to swap 'petradb' string for PetraDBClient class
+    //    and skip knex-dynamic-connection patching (PetraDB is in-process like SQLite)
+    const connectionMod = _require(path.join(buildDir, "src/connection/index.js"));
+    const Connection = connectionMod.Connection;
+    const originalGetWriteConfig = Connection.prototype.getWriteConfig;
+    Connection.prototype.getWriteConfig = function () {
+        const config = originalGetWriteConfig.call(this);
+        if (config.client === "petradb") {
+            const PetraDBClient = _require("@petradb/knex").default;
+            return { ...config, client: PetraDBClient };
+        }
+        return config;
+    };
+    // PetraDB is an in-process engine — no read/write replicas, no dynamic
+    // connection patching needed. Skip patchKnex for petradb connections.
+    const originalSetupWriteConnection = Connection.prototype.setupWriteConnection;
+    Connection.prototype.setupWriteConnection = function () {
+        if (this.clientName === "petradb") {
+            const knexMod = _require("knex");
+            const { Logger: ConnectionLogger } = _require(path.join(buildDir, "src/connection/logger.js"));
+            this.client = knexMod.knex(Object.assign({ log: new ConnectionLogger(this.name, this.logger) }, this.getWriteConfig(), { debug: false }));
+            // Skip patchKnex — not needed for in-process engines
+            return;
+        }
+        originalSetupWriteConnection.call(this);
+    };
+    const originalSetupReadConnection = Connection.prototype.setupReadConnection;
+    Connection.prototype.setupReadConnection = function () {
+        if (this.clientName === "petradb") {
+            // In-process engine — read client is same as write client
+            this.readClient = this.client;
+            return;
+        }
+        originalSetupReadConnection.call(this);
+    };
+}
+// Run the patch immediately on import
+patch();
+export { PetraDBDialect };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@petradb/lucid",
+  "version": "1.2.0",
+  "description": "AdonisJS Lucid ORM driver for PetraDB",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "@adonisjs/lucid": ">=22.0.0",
+    "@petradb/engine": ">=1.2.0",
+    "@petradb/knex": ">=1.2.0"
+  },
+  "devDependencies": {
+    "@adonisjs/lucid": "^22.0.0",
+    "@petradb/engine": "file:../engine/npm",
+    "@petradb/knex": "file:../knex",
+    "knex": "^3.1.0",
+    "luxon": "^3.7.2",
+    "typescript": "^5.9.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/edadma/petradb.git"
+  },
+  "keywords": [
+    "adonisjs",
+    "lucid",
+    "petradb",
+    "SQL",
+    "database",
+    "orm"
+  ],
+  "author": "Edward A. Maxedon, Sr.",
+  "license": "ISC",
+  "homepage": "https://petradb.dev"
+}