@molecule/api-database-duckdb 0.0.0-stage → 1.1.1

package/dist/utilities.js

@@ -0,0 +1,246 @@
+/**
+ * Utility functions for DuckDB operations.
+ *
+ * @module
+ */
+import { blobValue } from '@duckdb/node-api';
+import { sqlCapabilities } from './capabilities.js';
+import { parseCreateIndexStatement, referentialActionsIn, splitSqlColumns, splitSqlStatements, } from './sql-dialect.js';
+/**
+ * The error this bond's translator throws when a migration needs a construct
+ * DuckDB cannot honour. Named and typed so a caller can tell a genuine dialect
+ * limit apart from malformed SQL, and report it without a migration run.
+ *
+ * The diagnostic itself is described by the core TYPE contract
+ * ({@link SqlCompatibilityIssue}); this class is the bond's own error
+ * construction, next to the translation that raises it.
+ */
+export class UnsupportedSqlFeatureError extends Error {
+    /** The construct's feature. */
+    feature;
+    /** The exact construct found in the migration. */
+    detail;
+    /** Where the statement came from, when known. */
+    source;
+    /**
+     * Build the error from a compatibility diagnostic, copying its message and fields.
+     *
+     * @param issue - The diagnostic being refused.
+     */
+    constructor(issue) {
+        super(issue.message);
+        this.name = 'UnsupportedSqlFeatureError';
+        this.feature = issue.feature;
+        this.detail = issue.detail;
+        this.source = issue.source;
+    }
+}
+/**
+ * The first referential action this bond cannot reproduce, as a diagnostic.
+ *
+ * Absence is never support: the bond refuses unless its own declaration says the
+ * construct is `native` or `translated`. The note is the same text the
+ * generator's preflight prints, so a boot-time refusal and a scaffold-time one
+ * say the same thing.
+ *
+ * @param sql - The migration SQL.
+ * @param source - The file the SQL came from, when known.
+ * @returns The diagnostic, or null when no unsupported action is present.
+ */
+const firstRefusedReferentialAction = (sql, source) => {
+    const capability = sqlCapabilities['fk-referential-action'];
+    if (capability && capability.support !== 'unsupported')
+        return null;
+    for (const statement of splitSqlStatements(sql)) {
+        const detail = referentialActionsIn(statement.text)[0];
+        if (!detail)
+            continue;
+        return {
+            kind: 'unsupported',
+            feature: 'fk-referential-action',
+            detail,
+            statement: statement.text.trim(),
+            source,
+            message: `DuckDB cannot apply ${detail}${source ? ` in ${source}` : ''}` +
+                `${capability?.note ? ` — ${capability.note}` : '.'}`,
+        };
+    }
+    return null;
+};
+/**
+ * Translate PostgreSQL-dialect DDL to DuckDB-compatible DDL at migration time.
+ *
+ * Resource/template setup migrations are authored in PostgreSQL dialect. DuckDB
+ * 2.0 already speaks most of it natively — `uuid`/`timestamptz`/`bytea`/`text[]`
+ * type names, `gen_random_uuid()`, `now()`, `CURRENT_TIMESTAMP`, `::` casts,
+ * `ADD COLUMN IF NOT EXISTS`, `DROP COLUMN IF EXISTS`, `ON CONFLICT`, `ILIKE` —
+ * all verified against 2.0.0-r.1. The constructs it rejects are rewritten here,
+ * and only where the rewrite preserves behaviour:
+ *
+ * - `jsonb` → `json`, in both the column-type position and the `::jsonb` cast
+ *   (DuckDB has a `JSON` type, stored as VARCHAR; there is no `jsonb`).
+ * - `USING <method>` on a `CREATE INDEX` (`gin`/`btree`/`hash`/`gist`) →
+ *   removed: DuckDB indexes have no access method.
+ * - A partial index gets no `WHERE` support in DuckDB. A non-unique partial
+ *   index becomes a full index on the same columns — the predicate only narrows
+ *   which rows the index covers, never a query's result. A UNIQUE partial index
+ *   becomes a UNIQUE index over `CASE WHEN <predicate> THEN <column> END` per
+ *   column: rows outside the predicate get NULL keys (distinct in DuckDB), so
+ *   uniqueness applies to exactly the rows PostgreSQL would constrain.
+ *
+ * What it does NOT rewrite is an `ON DELETE`/`ON UPDATE` referential action
+ * (`CASCADE`, `SET NULL`, `SET DEFAULT`): DuckDB rejects the clause at parse
+ * time and has no triggers, so dropping it would turn a cascading delete into a
+ * refusing one. Such SQL throws {@link UnsupportedSqlFeatureError}, naming the
+ * construct — see {@link sqlCapabilities}. The compatibility preflight in the
+ * generator rejects those resource/provider combinations before an app exists;
+ * this throw is the last line of defence for SQL that reaches the runner another
+ * way.
+ *
+ * Everything else passes through untouched — unlike the sqlite bond, no
+ * placeholder conversion or timestamp-default rewriting happens here.
+ *
+ * @param sql - Raw migration SQL, possibly in Postgres dialect.
+ * @param options - The source file name used in an unsupported-construct error.
+ * @returns DuckDB-compatible SQL.
+ * @throws {UnsupportedSqlFeatureError} When the SQL needs a construct DuckDB
+ *   cannot reproduce without changing its behaviour.
+ */
+export const translateDdlToDuckdb = (sql, options = {}) => {
+    const refused = firstRefusedReferentialAction(sql, options.source);
+    if (refused)
+        throw new UnsupportedSqlFeatureError(refused);
+    const chunks = [];
+    let cursor = 0;
+    for (const statement of splitSqlStatements(sql)) {
+        chunks.push(sql.slice(cursor, statement.start));
+        chunks.push(rewriteIndexStatement(statement.text));
+        cursor = statement.end;
+    }
+    chunks.push(sql.slice(cursor));
+    return chunks.join('').replace(/\bjsonb\b/gi, 'json');
+};
+/**
+ * Rewrite one statement's DuckDB-incompatible index constructs.
+ *
+ * Every statement that is not a `CREATE INDEX` is returned unchanged, so this
+ * touches only index text. Index options (`WITH (...)`, `INCLUDE (...)`) are not
+ * translated: DuckDB has no equivalent, and guessing would hide a real
+ * difference, so the statement throws instead.
+ *
+ * @param statement - One statement from `splitSqlStatements`.
+ * @returns The statement in DuckDB dialect.
+ */
+const rewriteIndexStatement = (statement) => {
+    const index = parseCreateIndexStatement(statement);
+    if (!index)
+        return statement;
+    if (index.optionsBeforeWhere) {
+        throw new Error(`DuckDB: index options are not supported ("${index.optionsBeforeWhere}") — ` +
+            'remove them from the index or use a database that supports them.');
+    }
+    if (!index.predicate) {
+        // The parser already removed `USING <method>`; the rest is DuckDB-valid.
+        return `${index.prefix}${index.columns})${index.afterClose}`;
+    }
+    if (!index.unique) {
+        // Non-unique: the predicate only decides which rows the index covers.
+        return `${index.prefix}${index.columns})${index.afterPredicate ?? ''}`;
+    }
+    const predicate = index.predicate;
+    const columns = splitSqlColumns(index.columns)
+        .map((column) => `(CASE WHEN (${predicate}) THEN (${column}) END)`)
+        .join(', ');
+    return `${index.prefix}${columns})${index.afterPredicate ?? ''}`;
+};
+/**
+ * Coerce a JS value into something `@duckdb/node-api` can bind. The client
+ * infers a parameter's type from the VALUE and only understands `null`,
+ * booleans, numbers, bigints and strings — anything else fails at bind time
+ * with `Cannot create values of type ANY. Specify a specific type.`, which
+ * would crash every `create()`/`update()` that passes a `Date`, a boolean-ish
+ * object or a jsonb value. Strings cast on the way in: DuckDB implicitly casts
+ * a bound VARCHAR to UUID/TIMESTAMPTZ/DECIMAL/JSON/LIST parameters, verified
+ * against 2.0.0-r.1.
+ *
+ * @param value - The value to bind.
+ * @returns A `@duckdb/node-api`-bindable value.
+ */
+export const coerceDuckdbParam = (value) => {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'boolean' ||
+        typeof value === 'number' ||
+        typeof value === 'bigint' ||
+        typeof value === 'string') {
+        return value;
+    }
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Uint8Array)
+        return blobValue(value);
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    throw new Error(`DuckDB: cannot bind a value of type ${typeof value} — pass a string, number, boolean, ` +
+        'bigint, Date, Uint8Array, plain object or array.');
+};
+/**
+ * Normalize DuckDB result rows to the JS shapes the other database bonds hand
+ * back. DuckDB's JS conversion returns a `bigint` for every 64+-bit integer —
+ * `COUNT(*)`, `BIGINT` and `HUGEINT` columns — and `JSON.stringify` THROWS on a
+ * bigint, so a handler that serializes a row with `COUNT(*)` in it would 500.
+ * A bigint within `Number.MAX_SAFE_INTEGER` becomes a JS number (matching the
+ * sqlite bond); a larger one becomes its decimal string (matching node-postgres
+ * `int8AsString`). Mutates rows in place for speed.
+ *
+ * @param rows - Row objects from `result.getRowObjectsJS()`.
+ * @returns The normalized rows.
+ */
+export const normalizeDuckdbRows = (rows) => {
+    for (const row of rows) {
+        for (const key of Object.keys(row)) {
+            const value = row[key];
+            if (typeof value === 'bigint') {
+                row[key] =
+                    value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)
+                        ? Number(value)
+                        : value.toString();
+            }
+        }
+    }
+    return rows;
+};
+/**
+ * Parse the JSON-typed columns of a table's rows into values, matching what
+ * the postgresql/sqlite bonds hand back from a `json`/`jsonb` column. DuckDB's
+ * `JSON` type is an alias over VARCHAR, so a JSON column always READS as its
+ * JSON text — the column's type is only visible in
+ * `information_schema.columns.data_type`, never in the result metadata, which
+ * is why this runs in the DataStore (it knows the table) and not in the pool.
+ * A value that is not valid JSON text is left as the raw string.
+ *
+ * @param rows - Row objects.
+ * @param jsonColumns - The table's JSON-typed column names, lower-cased.
+ * @returns The rows with JSON columns parsed.
+ */
+export const parseJsonColumns = (rows, jsonColumns) => {
+    if (jsonColumns.size === 0)
+        return rows;
+    for (const row of rows) {
+        for (const key of Object.keys(row)) {
+            if (!jsonColumns.has(key.toLowerCase()))
+                continue;
+            if (typeof row[key] === 'string') {
+                try {
+                    row[key] = JSON.parse(row[key]);
+                }
+                catch (_error) {
+                    // A non-JSON string in a JSON-typed column: DuckDB allows it (the
+                    // type is VARCHAR underneath), so leave the caller's value alone.
+                }
+            }
+        }
+    }
+    return rows;
+};
+//# sourceMappingURL=utilities.js.map

package/dist/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@molecule/api-database-duckdb",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "description": "DuckDB database provider for molecule.dev",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./lifecycle.js": {
+      "types": "./dist/lifecycle.d.ts",
+      "import": "./dist/lifecycle.js"
+    },
+    "./migrator.js": {
+      "types": "./dist/migrator.d.ts",
+      "import": "./dist/migrator.js"
+    },
+    "./pool.js": {
+      "types": "./dist/pool.d.ts",
+      "import": "./dist/pool.js"
+    },
+    "./queue.js": {
+      "types": "./dist/queue.d.ts",
+      "import": "./dist/queue.js"
+    },
+    "./store.js": {
+      "types": "./dist/store.d.ts",
+      "import": "./dist/store.js"
+    },
+    "./utilities.js": {
+      "types": "./dist/utilities.d.ts",
+      "import": "./dist/utilities.js"
+    },
+    "./capabilities.js": {
+      "types": "./dist/capabilities.d.ts",
+      "import": "./dist/capabilities.js"
+    }
+  },
+  "keywords": [
+    "molecule",
+    "database",
+    "duckdb"
+  ],
+  "author": "Molecule Dev, Inc. (https://molecule.dev)",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@duckdb/node-api": "2.0.0-r.1"
+  },
+  "devDependencies": {
+    "@molecule/api-bond": "1.0.3",
+    "@molecule/api-database": "1.2.0",
+    "@molecule/api-process-lifecycle": "1.2.1",
+    "@molecule/api-process-lifecycle-express": "1.3.1",
+    "@molecule/api-secrets": "1.0.2",
+    "@types/node": "26.6.5",
+    "typescript": "6.0.3",
+    "vitest": "4.1.12"
+  },
+  "peerDependencies": {
+    "@molecule/api-bond": "^1.0.1",
+    "@molecule/api-database": "^1.2.0",
+    "@molecule/api-secrets": "^1.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/molecule-dev/molecule.git",
+    "directory": "packages/api/bonds/database/duckdb"
+  },
+  "homepage": "https://www.molecule.dev/packages/api-database-duckdb",
+  "bugs": "https://github.com/molecule-dev/molecule/issues",
+  "publishConfig": {
+    "access": "public"
+  }
+}