@b9g/zen 0.1.0

package/src/sqlite.js

@@ -0,0 +1,447 @@
+/// <reference types="./sqlite.d.ts" />
+import {
+  quoteIdent,
+  renderDDL
+} from "../chunk-2IEEEMRN.js";
+import {
+  generateColumnDDL,
+  generateDDL
+} from "../chunk-QXGEP5PB.js";
+import {
+  ConstraintPreflightError,
+  EnsureError,
+  SchemaDriftError,
+  getTableMeta,
+  resolveSQLBuiltin
+} from "../chunk-56M5Z3A6.js";
+
+// src/sqlite.ts
+import {
+  ConstraintViolationError,
+  isSQLBuiltin,
+  isSQLIdentifier
+} from "./zen.js";
+import Database from "better-sqlite3";
+var DIALECT = "sqlite";
+function quoteIdent2(name) {
+  return quoteIdent(name, DIALECT);
+}
+function buildSQL(strings, values) {
+  let sql = strings[0];
+  const params = [];
+  for (let i = 0; i < values.length; i++) {
+    let value = values[i];
+    if (isSQLBuiltin(value)) {
+      sql += resolveSQLBuiltin(value) + strings[i + 1];
+    } else if (isSQLIdentifier(value)) {
+      sql += quoteIdent2(value.name) + strings[i + 1];
+    } else {
+      sql += "?" + strings[i + 1];
+      if (typeof value === "boolean") {
+        value = value ? 1 : 0;
+      }
+      params.push(value);
+    }
+  }
+  return { sql, params };
+}
+var SQLiteDriver = class {
+  supportsReturning = true;
+  #db;
+  constructor(url) {
+    const path = url.startsWith("file:") ? url.slice(5) : url;
+    this.#db = new Database(path);
+    this.#db.pragma("journal_mode = WAL");
+    this.#db.pragma("foreign_keys = ON");
+  }
+  /**
+   * Convert SQLite errors to Zealot errors.
+   */
+  #handleError(error) {
+    if (error && typeof error === "object" && "code" in error) {
+      const code = error.code;
+      const message = error.message || String(error);
+      if (code === "SQLITE_CONSTRAINT" || code === "SQLITE_CONSTRAINT_UNIQUE") {
+        const match = message.match(/constraint failed: (\w+)\.(\w+)/i);
+        const table = match ? match[1] : void 0;
+        const column = match ? match[2] : void 0;
+        const constraint = match ? `${table}.${column}` : void 0;
+        let kind = "unknown";
+        if (code === "SQLITE_CONSTRAINT_UNIQUE")
+          kind = "unique";
+        else if (message.includes("UNIQUE"))
+          kind = "unique";
+        else if (message.includes("FOREIGN KEY"))
+          kind = "foreign_key";
+        else if (message.includes("NOT NULL"))
+          kind = "not_null";
+        else if (message.includes("CHECK"))
+          kind = "check";
+        throw new ConstraintViolationError(
+          message,
+          {
+            kind,
+            constraint,
+            table,
+            column
+          },
+          {
+            cause: error
+          }
+        );
+      }
+    }
+    throw error;
+  }
+  async all(strings, values) {
+    try {
+      const { sql, params } = buildSQL(strings, values);
+      return this.#db.prepare(sql).all(...params);
+    } catch (error) {
+      return this.#handleError(error);
+    }
+  }
+  async get(strings, values) {
+    try {
+      const { sql, params } = buildSQL(strings, values);
+      return this.#db.prepare(sql).get(...params) ?? null;
+    } catch (error) {
+      return this.#handleError(error);
+    }
+  }
+  async run(strings, values) {
+    try {
+      const { sql, params } = buildSQL(strings, values);
+      const result = this.#db.prepare(sql).run(...params);
+      return result.changes;
+    } catch (error) {
+      return this.#handleError(error);
+    }
+  }
+  async val(strings, values) {
+    try {
+      const { sql, params } = buildSQL(strings, values);
+      return this.#db.prepare(sql).pluck().get(...params);
+    } catch (error) {
+      return this.#handleError(error);
+    }
+  }
+  async close() {
+    this.#db.close();
+  }
+  async transaction(fn) {
+    this.#db.exec("BEGIN");
+    try {
+      const result = await fn(this);
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async withMigrationLock(fn) {
+    this.#db.exec("BEGIN EXCLUSIVE");
+    try {
+      const result = await fn();
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  // ==========================================================================
+  // Schema Management
+  // ==========================================================================
+  async ensureTable(table) {
+    const tableName = table.name;
+    let step = 0;
+    let applied = false;
+    try {
+      const exists = await this.#tableExists(tableName);
+      if (!exists) {
+        step = 1;
+        const ddlTemplate = generateDDL(table, { dialect: DIALECT });
+        const ddlSQL = renderDDL(ddlTemplate[0], ddlTemplate.slice(1), DIALECT);
+        for (const stmt of ddlSQL.split(";").filter((s) => s.trim())) {
+          this.#db.exec(stmt.trim());
+        }
+        applied = true;
+      } else {
+        step = 2;
+        const columnsApplied = await this.#ensureMissingColumns(table);
+        applied = applied || columnsApplied;
+        step = 3;
+        const indexesApplied = await this.#ensureMissingIndexes(table);
+        applied = applied || indexesApplied;
+        step = 4;
+        await this.#checkMissingConstraints(table);
+      }
+      return { applied };
+    } catch (error) {
+      if (error instanceof SchemaDriftError || error instanceof EnsureError) {
+        throw error;
+      }
+      throw new EnsureError(
+        `ensureTable failed at step ${step}: ${error instanceof Error ? error.message : String(error)}`,
+        { operation: "ensureTable", table: tableName, step },
+        { cause: error }
+      );
+    }
+  }
+  async ensureConstraints(table) {
+    const tableName = table.name;
+    let step = 0;
+    let applied = false;
+    try {
+      const exists = await this.#tableExists(tableName);
+      if (!exists) {
+        throw new Error(
+          `Table "${tableName}" does not exist. Run ensureTable() first.`
+        );
+      }
+      step = 1;
+      const existingConstraints = await this.#getConstraints(tableName);
+      step = 2;
+      const uniquesApplied = await this.#ensureUniqueConstraints(
+        table,
+        existingConstraints
+      );
+      applied = applied || uniquesApplied;
+      step = 3;
+      const fksApplied = await this.#ensureForeignKeys(
+        table,
+        existingConstraints
+      );
+      applied = applied || fksApplied;
+      return { applied };
+    } catch (error) {
+      if (error instanceof ConstraintPreflightError || error instanceof EnsureError) {
+        throw error;
+      }
+      throw new EnsureError(
+        `ensureConstraints failed at step ${step}: ${error instanceof Error ? error.message : String(error)}`,
+        { operation: "ensureConstraints", table: tableName, step },
+        { cause: error }
+      );
+    }
+  }
+  // ==========================================================================
+  // Introspection Helpers (private)
+  // ==========================================================================
+  async #tableExists(tableName) {
+    const result = this.#db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`).all(tableName);
+    return result.length > 0;
+  }
+  async #getColumns(tableName) {
+    const result = this.#db.prepare(`PRAGMA table_info(${quoteIdent2(tableName)})`).all();
+    return result.map((row) => ({
+      name: row.name,
+      type: row.type,
+      notnull: row.notnull === 1
+    }));
+  }
+  async #getIndexes(tableName) {
+    const indexList = this.#db.prepare(`PRAGMA index_list(${quoteIdent2(tableName)})`).all();
+    const indexes = [];
+    for (const idx of indexList) {
+      if (idx.origin === "pk")
+        continue;
+      const indexInfo = this.#db.prepare(`PRAGMA index_info(${quoteIdent2(idx.name)})`).all();
+      indexes.push({
+        name: idx.name,
+        columns: indexInfo.map((col) => col.name),
+        unique: idx.unique === 1
+      });
+    }
+    return indexes;
+  }
+  async #getConstraints(tableName) {
+    const constraints = [];
+    const indexes = await this.#getIndexes(tableName);
+    for (const idx of indexes) {
+      if (idx.unique) {
+        constraints.push({
+          name: idx.name,
+          type: "unique",
+          columns: idx.columns
+        });
+      }
+    }
+    const fks = this.#db.prepare(`PRAGMA foreign_key_list(${quoteIdent2(tableName)})`).all();
+    const fkMap = /* @__PURE__ */ new Map();
+    for (const fk of fks) {
+      if (!fkMap.has(fk.id)) {
+        fkMap.set(fk.id, { table: fk.table, from: [], to: [] });
+      }
+      const entry = fkMap.get(fk.id);
+      entry.from.push(fk.from);
+      entry.to.push(fk.to);
+    }
+    for (const [id, fk] of fkMap) {
+      constraints.push({
+        name: `fk_${tableName}_${id}`,
+        type: "foreign_key",
+        columns: fk.from,
+        referencedTable: fk.table,
+        referencedColumns: fk.to
+      });
+    }
+    return constraints;
+  }
+  // ==========================================================================
+  // Schema Ensure Helpers (private)
+  // ==========================================================================
+  async #ensureMissingColumns(table) {
+    const existingCols = await this.#getColumns(table.name);
+    const existingColNames = new Set(existingCols.map((c) => c.name));
+    const schemaFields = Object.keys(table.schema.shape);
+    let applied = false;
+    for (const fieldName of schemaFields) {
+      if (!existingColNames.has(fieldName)) {
+        await this.#addColumn(table, fieldName);
+        applied = true;
+      }
+    }
+    return applied;
+  }
+  async #addColumn(table, fieldName) {
+    const zodType = table.schema.shape[fieldName];
+    const fieldMeta = getTableMeta(table).fields[fieldName] || {};
+    const colTemplate = generateColumnDDL(
+      fieldName,
+      zodType,
+      fieldMeta,
+      DIALECT
+    );
+    const colSQL = renderDDL(colTemplate[0], colTemplate.slice(1), DIALECT);
+    const sql = `ALTER TABLE ${quoteIdent2(table.name)} ADD COLUMN ${colSQL}`;
+    this.#db.exec(sql);
+  }
+  async #ensureMissingIndexes(table) {
+    const existingIndexes = await this.#getIndexes(table.name);
+    const existingIndexNames = new Set(existingIndexes.map((i) => i.name));
+    const meta = getTableMeta(table);
+    let applied = false;
+    for (const fieldName of meta.indexed) {
+      const indexName = `idx_${table.name}_${fieldName}`;
+      if (!existingIndexNames.has(indexName)) {
+        await this.#createIndex(table.name, [fieldName], false);
+        applied = true;
+      }
+    }
+    for (const indexCols of table.indexes) {
+      const indexName = `idx_${table.name}_${indexCols.join("_")}`;
+      if (!existingIndexNames.has(indexName)) {
+        await this.#createIndex(table.name, indexCols, false);
+        applied = true;
+      }
+    }
+    return applied;
+  }
+  async #createIndex(tableName, columns, unique) {
+    const prefix = unique ? "uniq" : "idx";
+    const indexName = `${prefix}_${tableName}_${columns.join("_")}`;
+    const uniqueClause = unique ? "UNIQUE " : "";
+    const columnList = columns.map(quoteIdent2).join(", ");
+    const sql = `CREATE ${uniqueClause}INDEX IF NOT EXISTS ${quoteIdent2(indexName)} ON ${quoteIdent2(tableName)} (${columnList})`;
+    this.#db.exec(sql);
+    return indexName;
+  }
+  async #checkMissingConstraints(table) {
+    const existingConstraints = await this.#getConstraints(table.name);
+    const meta = getTableMeta(table);
+    for (const fieldName of Object.keys(meta.fields)) {
+      const fieldMeta = meta.fields[fieldName];
+      if (fieldMeta.unique) {
+        const hasUnique = existingConstraints.some(
+          (c) => c.type === "unique" && c.columns.length === 1 && c.columns[0] === fieldName
+        );
+        if (!hasUnique) {
+          throw new SchemaDriftError(
+            `Table "${table.name}" is missing UNIQUE constraint on column "${fieldName}"`,
+            {
+              table: table.name,
+              drift: `missing unique:${fieldName}`,
+              suggestion: `Run ensureConstraints() to apply constraints`
+            }
+          );
+        }
+      }
+    }
+    for (const ref of meta.references) {
+      const hasFk = existingConstraints.some(
+        (c) => c.type === "foreign_key" && c.columns.length === 1 && c.columns[0] === ref.fieldName && c.referencedTable === ref.table.name && c.referencedColumns?.[0] === ref.referencedField
+      );
+      if (!hasFk) {
+        throw new SchemaDriftError(
+          `Table "${table.name}" is missing FOREIGN KEY on column "${ref.fieldName}" -> "${ref.table.name}"."${ref.referencedField}"`,
+          {
+            table: table.name,
+            drift: `missing fk:${ref.fieldName}`,
+            suggestion: `Run ensureConstraints() to apply constraints`
+          }
+        );
+      }
+    }
+  }
+  // ==========================================================================
+  // Constraint Application Helpers (private)
+  // ==========================================================================
+  async #ensureUniqueConstraints(table, existingConstraints) {
+    const meta = getTableMeta(table);
+    let applied = false;
+    for (const fieldName of Object.keys(meta.fields)) {
+      const fieldMeta = meta.fields[fieldName];
+      if (fieldMeta.unique) {
+        const hasUnique = existingConstraints.some(
+          (c) => c.type === "unique" && c.columns.length === 1 && c.columns[0] === fieldName
+        );
+        if (!hasUnique) {
+          await this.#preflightUnique(table.name, [fieldName]);
+          await this.#createIndex(table.name, [fieldName], true);
+          applied = true;
+        }
+      }
+    }
+    return applied;
+  }
+  async #ensureForeignKeys(table, existingConstraints) {
+    const meta = getTableMeta(table);
+    for (const ref of meta.references) {
+      const hasFk = existingConstraints.some(
+        (c) => c.type === "foreign_key" && c.columns.length === 1 && c.columns[0] === ref.fieldName && c.referencedTable === ref.table.name && c.referencedColumns?.[0] === ref.referencedField
+      );
+      if (!hasFk) {
+        throw new Error(
+          `Adding foreign key constraints to existing SQLite tables requires table rebuild. Table "${table.name}" column "${ref.fieldName}" -> "${ref.table.name}"."${ref.referencedField}". Please use a manual migration.`
+        );
+      }
+    }
+    return false;
+  }
+  async #preflightUnique(tableName, columns) {
+    const columnList = columns.map(quoteIdent2).join(", ");
+    const sql = `SELECT ${columnList}, COUNT(*) as cnt FROM ${quoteIdent2(tableName)} GROUP BY ${columnList} HAVING COUNT(*) > 1 LIMIT 1`;
+    const result = this.#db.prepare(sql).all();
+    if (result.length > 0) {
+      const diagQuery = `SELECT ${columns.join(", ")}, COUNT(*) as cnt FROM ${tableName} GROUP BY ${columns.join(", ")} HAVING COUNT(*) > 1`;
+      const countSql = `SELECT COUNT(*) as total FROM (${sql.replace(" LIMIT 1", "")}) t`;
+      const countResult = this.#db.prepare(countSql).all();
+      const violationCount = countResult[0]?.total ?? 1;
+      throw new ConstraintPreflightError(
+        `Cannot add UNIQUE constraint on "${tableName}"(${columns.join(", ")}): duplicate values exist`,
+        {
+          table: tableName,
+          constraint: `unique:${columns.join(",")}`,
+          violationCount,
+          query: diagQuery
+        }
+      );
+    }
+  }
+};
+export {
+  SQLiteDriver as default
+};

package/src/zen.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @b9g/zen - The simple database client
+ *
+ * Define tables. Write SQL. Get objects.
+ */
+import { z as zod } from "zod";
+export { zod as z };
+export { table, type Table, type TableOptions, type Row, type Insert, type Update, type FieldMeta, type FieldType, type Relation, type InferRefs, } from "./impl/table.js";
+export { Database, Transaction, DatabaseUpgradeEvent, type Driver, } from "./impl/database.js";
+export { CURRENT_TIMESTAMP, CURRENT_DATE, CURRENT_TIME, NOW, TODAY, isSQLBuiltin, } from "./impl/database.js";
+export { ident, isSQLIdentifier, } from "./impl/template.js";
+export { type SQLTemplate, isSQLTemplate, } from "./impl/template.js";
+export { type EnsureResult, } from "./impl/database.js";
+export { DatabaseError, ValidationError, TableDefinitionError, MigrationError, MigrationLockError, QueryError, NotFoundError, AlreadyExistsError, ConstraintViolationError, ConnectionError, TransactionError, EnsureError, SchemaDriftError, ConstraintPreflightError, isDatabaseError, hasErrorCode, type DatabaseErrorCode, type EnsureOperation, } from "./impl/errors.js";