@happyvertical/smrt-core 0.30.0

package/dist/schema/ddl/index.js

@@ -0,0 +1,80 @@
+import { BaseDDLStrategy } from "./base-strategy.js";
+import { DuckDBStrategy } from "./duckdb-strategy.js";
+import { JsonDuckDBStrategy } from "./json-duckdb-strategy.js";
+import { PostgresStrategy } from "./postgres-strategy.js";
+import { SQLiteStrategy } from "./sqlite-strategy.js";
+const strategies = {
+  sqlite: new SQLiteStrategy(),
+  duckdb: new DuckDBStrategy(),
+  json: new JsonDuckDBStrategy(),
+  postgres: new PostgresStrategy()
+};
+function getDDLStrategy(engine) {
+  const strategy = strategies[engine];
+  if (!strategy) {
+    throw new Error(`Unknown database engine: ${engine}`);
+  }
+  return strategy;
+}
+function getAllStrategies() {
+  return Object.values(strategies);
+}
+function generateDDLForEngine(schema, engine) {
+  const strategy = getDDLStrategy(engine);
+  return {
+    createTable: strategy.generateCreateTable(schema),
+    indexes: strategy.generateIndexes(schema),
+    triggers: strategy.generateTriggers(schema)
+  };
+}
+function generateMultiEngineDDL(schema) {
+  return {
+    sqlite: generateDDLForEngine(schema, "sqlite"),
+    duckdb: generateDDLForEngine(schema, "duckdb"),
+    json: generateDDLForEngine(schema, "json"),
+    postgres: generateDDLForEngine(schema, "postgres")
+  };
+}
+function detectEngine(url, type) {
+  if (type) {
+    switch (type.toLowerCase()) {
+      case "sqlite":
+      case "libsql":
+        return "sqlite";
+      case "duckdb":
+      case "json":
+        return "duckdb";
+      case "postgres":
+      case "postgresql":
+      case "pg":
+        return "postgres";
+    }
+  }
+  const urlLower = url.toLowerCase();
+  if (urlLower.startsWith("postgres://") || urlLower.startsWith("postgresql://")) {
+    return "postgres";
+  }
+  if (urlLower.endsWith(".duckdb") || urlLower.includes("duckdb")) {
+    return "duckdb";
+  }
+  if (urlLower.endsWith(".json") || urlLower.includes("/json/") || urlLower.includes("-json")) {
+    return "duckdb";
+  }
+  if (urlLower.endsWith(".db") || urlLower.endsWith(".sqlite") || urlLower.endsWith(".sqlite3") || urlLower === ":memory:") {
+    return "sqlite";
+  }
+  return "sqlite";
+}
+export {
+  BaseDDLStrategy,
+  DuckDBStrategy,
+  JsonDuckDBStrategy,
+  PostgresStrategy,
+  SQLiteStrategy,
+  detectEngine,
+  generateDDLForEngine,
+  generateMultiEngineDDL,
+  getAllStrategies,
+  getDDLStrategy
+};
+//# sourceMappingURL=index.js.map

package/dist/schema/ddl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/schema/ddl/index.ts"],"sourcesContent":["/**\n * DDL Generator Module\n *\n * Per-engine DDL generation for SMRT schema management.\n * SMRT handles ALL database maintenance directly - SDK SQL remains a pure query/CRUD layer.\n */\n\nexport { BaseDDLStrategy } from './base-strategy.js';\nexport { DuckDBStrategy } from './duckdb-strategy.js';\nexport { JsonDuckDBStrategy } from './json-duckdb-strategy.js';\nexport { PostgresStrategy } from './postgres-strategy.js';\nexport { SQLiteStrategy } from './sqlite-strategy.js';\nexport * from './types.js';\n\nimport type { SchemaDefinition } from '../types.js';\nimport { DuckDBStrategy } from './duckdb-strategy.js';\nimport { JsonDuckDBStrategy } from './json-duckdb-strategy.js';\nimport { PostgresStrategy } from './postgres-strategy.js';\nimport { SQLiteStrategy } from './sqlite-strategy.js';\nimport type {\n  DatabaseEngine,\n  DDLStrategy,\n  EngineSpecificDDL,\n  MultiEngineDDL,\n} from './types.js';\n\n// Singleton instances for each strategy\nconst strategies: Record<DatabaseEngine, DDLStrategy> = {\n  sqlite: new SQLiteStrategy(),\n  duckdb: new DuckDBStrategy(),\n  json: new JsonDuckDBStrategy(),\n  postgres: new PostgresStrategy(),\n};\n\n/**\n * Get the DDL strategy for a specific database engine\n *\n * @param engine - The database engine type\n * @returns The DDL strategy for that engine\n */\nexport function getDDLStrategy(engine: DatabaseEngine): DDLStrategy {\n  const strategy = strategies[engine];\n  if (!strategy) {\n    throw new Error(`Unknown database engine: ${engine}`);\n  }\n  return strategy;\n}\n\n/**\n * Get all available DDL strategies\n *\n * @returns Array of all DDL strategies\n */\nexport function getAllStrategies(): DDLStrategy[] {\n  return Object.values(strategies);\n}\n\n/**\n * Generate DDL for a specific engine\n *\n * @param schema - The schema definition\n * @param engine - The target database engine\n * @returns Engine-specific DDL (createTable, indexes, triggers)\n */\nexport function generateDDLForEngine(\n  schema: SchemaDefinition,\n  engine: DatabaseEngine,\n): EngineSpecificDDL {\n  const strategy = getDDLStrategy(engine);\n\n  return {\n    createTable: strategy.generateCreateTable(schema),\n    indexes: strategy.generateIndexes(schema),\n    triggers: strategy.generateTriggers(schema),\n  };\n}\n\n/**\n * Generate DDL for all supported engines\n *\n * Useful for storing pre-generated DDL in manifest at build time.\n *\n * @param schema - The schema definition\n * @returns DDL for all engines\n */\nexport function generateMultiEngineDDL(\n  schema: SchemaDefinition,\n): MultiEngineDDL {\n  return {\n    sqlite: generateDDLForEngine(schema, 'sqlite'),\n    duckdb: generateDDLForEngine(schema, 'duckdb'),\n    json: generateDDLForEngine(schema, 'json'),\n    postgres: generateDDLForEngine(schema, 'postgres'),\n  };\n}\n\n/**\n * Detect database engine from URL or connection type\n *\n * @param url - Database URL or path\n * @param type - Optional explicit type hint\n * @returns Detected database engine\n */\nexport function detectEngine(url: string, type?: string): DatabaseEngine {\n  // Explicit type takes precedence\n  if (type) {\n    switch (type.toLowerCase()) {\n      case 'sqlite':\n      case 'libsql':\n        return 'sqlite';\n      case 'duckdb':\n      case 'json':\n        // Query-level compatibility treats JSON as DuckDB. DDL callers that\n        // need JSON's UUID-as-TEXT behavior should detect the adapter\n        // structurally (exportTable) or request the `json` strategy directly.\n        return 'duckdb';\n      case 'postgres':\n      case 'postgresql':\n      case 'pg':\n        return 'postgres';\n      default:\n        // Fall through to URL detection\n        break;\n    }\n  }\n\n  // Detect from URL\n  const urlLower = url.toLowerCase();\n\n  if (\n    urlLower.startsWith('postgres://') ||\n    urlLower.startsWith('postgresql://')\n  ) {\n    return 'postgres';\n  }\n\n  if (urlLower.endsWith('.duckdb') || urlLower.includes('duckdb')) {\n    return 'duckdb';\n  }\n\n  // JSON adapter detection - matches .json extension, /json/ path, or -json- in name\n  // This is needed because JSON adapter uses DuckDB internally and requires\n  // inline UNIQUE constraints for UPSERT to work\n  if (\n    urlLower.endsWith('.json') ||\n    urlLower.includes('/json/') ||\n    urlLower.includes('-json')\n  ) {\n    // Query-level compatibility treats JSON as DuckDB. DDL callers that need\n    // JSON's UUID-as-TEXT behavior should detect the adapter structurally\n    // (exportTable) or request the `json` strategy directly.\n    return 'duckdb';\n  }\n\n  // Default to SQLite for file-based databases\n  if (\n    urlLower.endsWith('.db') ||\n    urlLower.endsWith('.sqlite') ||\n    urlLower.endsWith('.sqlite3') ||\n    urlLower === ':memory:'\n  ) {\n    return 'sqlite';\n  }\n\n  // Default fallback\n  return 'sqlite';\n}\n"],"names":["SQLiteStrategy","DuckDBStrategy","JsonDuckDBStrategy","PostgresStrategy"],"mappings":";;;;;AA2BA,MAAM,aAAkD;AAAA,EACtD,QAAQ,IAAIA,eAAAA;AAAAA,EACZ,QAAQ,IAAIC,eAAAA;AAAAA,EACZ,MAAM,IAAIC,mBAAAA;AAAAA,EACV,UAAU,IAAIC,iBAAAA;AAChB;AAQO,SAAS,eAAe,QAAqC;AAClE,QAAM,WAAW,WAAW,MAAM;AAClC,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,4BAA4B,MAAM,EAAE;AAAA,EACtD;AACA,SAAO;AACT;AAOO,SAAS,mBAAkC;AAChD,SAAO,OAAO,OAAO,UAAU;AACjC;AASO,SAAS,qBACd,QACA,QACmB;AACnB,QAAM,WAAW,eAAe,MAAM;AAEtC,SAAO;AAAA,IACL,aAAa,SAAS,oBAAoB,MAAM;AAAA,IAChD,SAAS,SAAS,gBAAgB,MAAM;AAAA,IACxC,UAAU,SAAS,iBAAiB,MAAM;AAAA,EAAA;AAE9C;AAUO,SAAS,uBACd,QACgB;AAChB,SAAO;AAAA,IACL,QAAQ,qBAAqB,QAAQ,QAAQ;AAAA,IAC7C,QAAQ,qBAAqB,QAAQ,QAAQ;AAAA,IAC7C,MAAM,qBAAqB,QAAQ,MAAM;AAAA,IACzC,UAAU,qBAAqB,QAAQ,UAAU;AAAA,EAAA;AAErD;AASO,SAAS,aAAa,KAAa,MAA+B;AAEvE,MAAI,MAAM;AACR,YAAQ,KAAK,eAAY;AAAA,MACvB,KAAK;AAAA,MACL,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AAAA,MACL,KAAK;AAIH,eAAO;AAAA,MACT,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AACH,eAAO;AAAA,IAGP;AAAA,EAEN;AAGA,QAAM,WAAW,IAAI,YAAA;AAErB,MACE,SAAS,WAAW,aAAa,KACjC,SAAS,WAAW,eAAe,GACnC;AACA,WAAO;AAAA,EACT;AAEA,MAAI,SAAS,SAAS,SAAS,KAAK,SAAS,SAAS,QAAQ,GAAG;AAC/D,WAAO;AAAA,EACT;AAKA,MACE,SAAS,SAAS,OAAO,KACzB,SAAS,SAAS,QAAQ,KAC1B,SAAS,SAAS,OAAO,GACzB;AAIA,WAAO;AAAA,EACT;AAGA,MACE,SAAS,SAAS,KAAK,KACvB,SAAS,SAAS,SAAS,KAC3B,SAAS,SAAS,UAAU,KAC5B,aAAa,YACb;AACA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;"}

package/dist/schema/ddl/json-duckdb-strategy.d.ts

@@ -0,0 +1,8 @@
+import { SQLDataType } from '../types.js';
+import { DuckDBStrategy } from './duckdb-strategy.js';
+import { DatabaseEngine } from './types.js';
+export declare class JsonDuckDBStrategy extends DuckDBStrategy {
+    readonly engine: DatabaseEngine;
+    mapType(type: SQLDataType): string;
+}
+//# sourceMappingURL=json-duckdb-strategy.d.ts.map

package/dist/schema/ddl/json-duckdb-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-duckdb-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/json-duckdb-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,kBAAmB,SAAQ,cAAc;IACpD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAU;IAEzC,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;CAOnC"}

package/dist/schema/ddl/json-duckdb-strategy.js

@@ -0,0 +1,14 @@
+import { DuckDBStrategy } from "./duckdb-strategy.js";
+class JsonDuckDBStrategy extends DuckDBStrategy {
+  engine = "json";
+  mapType(type) {
+    if (type === "UUID") {
+      return "TEXT";
+    }
+    return super.mapType(type);
+  }
+}
+export {
+  JsonDuckDBStrategy
+};
+//# sourceMappingURL=json-duckdb-strategy.js.map

package/dist/schema/ddl/json-duckdb-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-duckdb-strategy.js","sources":["../../../src/schema/ddl/json-duckdb-strategy.ts"],"sourcesContent":["/**\n * JSON Adapter DDL Strategy\n *\n * The JSON adapter is backed by DuckDB, so it needs DuckDB's inline UNIQUE\n * constraints for UPSERT. However, DuckDB's Node API currently round-trips\n * native UUID values as their 128-bit numeric representation, so SMRT stores\n * UUID columns as TEXT for JSON-backed databases.\n */\n\nimport type { SQLDataType } from '../types.js';\nimport { DuckDBStrategy } from './duckdb-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class JsonDuckDBStrategy extends DuckDBStrategy {\n  readonly engine: DatabaseEngine = 'json';\n\n  mapType(type: SQLDataType): string {\n    if (type === 'UUID') {\n      return 'TEXT';\n    }\n\n    return super.mapType(type);\n  }\n}\n"],"names":[],"mappings":";AAaO,MAAM,2BAA2B,eAAe;AAAA,EAC5C,SAAyB;AAAA,EAElC,QAAQ,MAA2B;AACjC,QAAI,SAAS,QAAQ;AACnB,aAAO;AAAA,IACT;AAEA,WAAO,MAAM,QAAQ,IAAI;AAAA,EAC3B;AACF;"}

package/dist/schema/ddl/postgres-strategy.d.ts

@@ -0,0 +1,29 @@
+import { SQLDataType, TriggerDefinition } from '../types.js';
+import { BaseDDLStrategy } from './base-strategy.js';
+import { DatabaseEngine } from './types.js';
+export declare class PostgresStrategy extends BaseDDLStrategy {
+    readonly engine: DatabaseEngine;
+    /**
+     * Map types for PostgreSQL
+     * - JSON → JSONB (more efficient, supports indexing)
+     * - TIMESTAMP → TIMESTAMP WITH TIME ZONE (best practice)
+     */
+    mapType(type: SQLDataType): string;
+    /**
+     * Generate trigger for PostgreSQL
+     *
+     * PostgreSQL triggers require a separate function, then the trigger.
+     * For updated_at timestamps, we generate both.
+     */
+    protected generateTriggerStatement(tableName: string, trigger: TriggerDefinition): string;
+    /**
+     * PostgreSQL supports triggers
+     */
+    supportsTriggers(): boolean;
+    /**
+     * PostgreSQL doesn't require inline UNIQUE for UPSERT
+     * Both inline and separate indexes work with ON CONFLICT
+     */
+    requiresInlineUnique(): boolean;
+}
+//# sourceMappingURL=postgres-strategy.d.ts.map

package/dist/schema/ddl/postgres-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/postgres-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAc;IAE7C;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAelC;;;;;OAKG;IACH,SAAS,CAAC,wBAAwB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,iBAAiB,GACzB,MAAM;IAkDT;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;OAGG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

package/dist/schema/ddl/postgres-strategy.js

@@ -0,0 +1,102 @@
+import { BaseDDLStrategy } from "./base-strategy.js";
+class PostgresStrategy extends BaseDDLStrategy {
+  engine = "postgres";
+  /**
+   * Map types for PostgreSQL
+   * - JSON → JSONB (more efficient, supports indexing)
+   * - TIMESTAMP → TIMESTAMP WITH TIME ZONE (best practice)
+   */
+  mapType(type) {
+    switch (type) {
+      case "JSON":
+        return "JSONB";
+      // PostgreSQL JSONB is more efficient
+      case "TIMESTAMP":
+        return "TIMESTAMP";
+      // Could use TIMESTAMPTZ for timezone-aware
+      case "REAL":
+        return "DOUBLE PRECISION";
+      // PostgreSQL convention
+      case "UUID":
+        return "uuid";
+      // Native 16-byte uuid (R11) — vs 37-byte text
+      default:
+        return super.mapType(type);
+    }
+  }
+  /**
+   * Generate trigger for PostgreSQL
+   *
+   * PostgreSQL triggers require a separate function, then the trigger.
+   * For updated_at timestamps, we generate both.
+   */
+  generateTriggerStatement(tableName, trigger) {
+    if (trigger.name.includes("updated_at")) {
+      const functionName = `update_${tableName}_updated_at`;
+      let sql2 = `-- Function for ${trigger.name}
+`;
+      sql2 += `CREATE OR REPLACE FUNCTION ${functionName}()
+`;
+      sql2 += `RETURNS TRIGGER AS $$
+`;
+      sql2 += `BEGIN
+`;
+      sql2 += `  NEW.updated_at = CURRENT_TIMESTAMP;
+`;
+      sql2 += `  RETURN NEW;
+`;
+      sql2 += `END;
+`;
+      sql2 += `$$ LANGUAGE plpgsql;
+
+`;
+      sql2 += `-- Trigger
+`;
+      sql2 += `DROP TRIGGER IF EXISTS "${trigger.name}" ON "${tableName}";
+`;
+      sql2 += `CREATE TRIGGER "${trigger.name}"
+`;
+      sql2 += `${trigger.when} ${trigger.event} ON "${tableName}"
+`;
+      sql2 += `FOR EACH ROW
+`;
+      sql2 += `EXECUTE FUNCTION ${functionName}();`;
+      return sql2;
+    }
+    let sql = `DROP TRIGGER IF EXISTS "${trigger.name}" ON "${tableName}";
+`;
+    sql += `CREATE TRIGGER "${trigger.name}"
+`;
+    sql += `${trigger.when} ${trigger.event} ON "${tableName}"
+`;
+    sql += `FOR EACH ROW
+`;
+    if (trigger.condition) {
+      sql += `WHEN (${trigger.condition})
+`;
+    }
+    if (trigger.body.includes("EXECUTE")) {
+      sql += trigger.body;
+    } else {
+      sql += `EXECUTE FUNCTION ${trigger.body}`;
+    }
+    return `${sql};`;
+  }
+  /**
+   * PostgreSQL supports triggers
+   */
+  supportsTriggers() {
+    return true;
+  }
+  /**
+   * PostgreSQL doesn't require inline UNIQUE for UPSERT
+   * Both inline and separate indexes work with ON CONFLICT
+   */
+  requiresInlineUnique() {
+    return false;
+  }
+}
+export {
+  PostgresStrategy
+};
+//# sourceMappingURL=postgres-strategy.js.map

package/dist/schema/ddl/postgres-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-strategy.js","sources":["../../../src/schema/ddl/postgres-strategy.ts"],"sourcesContent":["/**\n * PostgreSQL DDL Strategy\n *\n * PostgreSQL-specific DDL generation with the following characteristics:\n * - JSONB type for JSON columns (more efficient than JSON)\n * - Native BOOLEAN type\n * - Full trigger support with PL/pgSQL functions\n * - UNIQUE can be inline or separate indexes\n * - Supports CAST in DEFAULT values\n */\n\nimport type { SQLDataType, TriggerDefinition } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class PostgresStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'postgres';\n\n  /**\n   * Map types for PostgreSQL\n   * - JSON → JSONB (more efficient, supports indexing)\n   * - TIMESTAMP → TIMESTAMP WITH TIME ZONE (best practice)\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'JSON':\n        return 'JSONB'; // PostgreSQL JSONB is more efficient\n      case 'TIMESTAMP':\n        return 'TIMESTAMP'; // Could use TIMESTAMPTZ for timezone-aware\n      case 'REAL':\n        return 'DOUBLE PRECISION'; // PostgreSQL convention\n      case 'UUID':\n        return 'uuid'; // Native 16-byte uuid (R11) — vs 37-byte text\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate trigger for PostgreSQL\n   *\n   * PostgreSQL triggers require a separate function, then the trigger.\n   * For updated_at timestamps, we generate both.\n   */\n  protected generateTriggerStatement(\n    tableName: string,\n    trigger: TriggerDefinition,\n  ): string {\n    // For simple triggers, we need to create a function first\n    // This is PostgreSQL's two-step trigger process\n\n    // Check if this is an updated_at trigger\n    if (trigger.name.includes('updated_at')) {\n      // Generate the function and trigger for updated_at\n      const functionName = `update_${tableName}_updated_at`;\n\n      let sql = `-- Function for ${trigger.name}\\n`;\n      sql += `CREATE OR REPLACE FUNCTION ${functionName}()\\n`;\n      sql += `RETURNS TRIGGER AS $$\\n`;\n      sql += `BEGIN\\n`;\n      sql += `  NEW.updated_at = CURRENT_TIMESTAMP;\\n`;\n      sql += `  RETURN NEW;\\n`;\n      sql += `END;\\n`;\n      sql += `$$ LANGUAGE plpgsql;\\n\\n`;\n\n      sql += `-- Trigger\\n`;\n      sql += `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n      sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n      sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n      sql += `FOR EACH ROW\\n`;\n      sql += `EXECUTE FUNCTION ${functionName}();`;\n\n      return sql;\n    }\n\n    // For custom triggers, use the provided body\n    let sql = `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n    sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n    sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n    sql += `FOR EACH ROW\\n`;\n\n    if (trigger.condition) {\n      sql += `WHEN (${trigger.condition})\\n`;\n    }\n\n    // PostgreSQL triggers need EXECUTE FUNCTION or EXECUTE PROCEDURE\n    // If body contains a function call, use it directly\n    if (trigger.body.includes('EXECUTE')) {\n      sql += trigger.body;\n    } else {\n      // Wrap in anonymous DO block or assume it's a function name\n      sql += `EXECUTE FUNCTION ${trigger.body}`;\n    }\n\n    return `${sql};`;\n  }\n\n  /**\n   * PostgreSQL supports triggers\n   */\n  supportsTriggers(): boolean {\n    return true;\n  }\n\n  /**\n   * PostgreSQL doesn't require inline UNIQUE for UPSERT\n   * Both inline and separate indexes work with ON CONFLICT\n   */\n  requiresInlineUnique(): boolean {\n    return false;\n  }\n}\n"],"names":["sql"],"mappings":";AAeO,MAAM,yBAAyB,gBAAgB;AAAA,EAC3C,SAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOlC,QAAQ,MAA2B;AACjC,YAAQ,MAAA;AAAA,MACN,KAAK;AACH,eAAO;AAAA;AAAA,MACT,KAAK;AACH,eAAO;AAAA;AAAA,MACT,KAAK;AACH,eAAO;AAAA;AAAA,MACT,KAAK;AACH,eAAO;AAAA;AAAA,MACT;AACE,eAAO,MAAM,QAAQ,IAAI;AAAA,IAAA;AAAA,EAE/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,yBACR,WACA,SACQ;AAKR,QAAI,QAAQ,KAAK,SAAS,YAAY,GAAG;AAEvC,YAAM,eAAe,UAAU,SAAS;AAExC,UAAIA,OAAM,mBAAmB,QAAQ,IAAI;AAAA;AACzCA,cAAO,8BAA8B,YAAY;AAAA;AACjDA,cAAO;AAAA;AACPA,cAAO;AAAA;AACPA,cAAO;AAAA;AACPA,cAAO;AAAA;AACPA,cAAO;AAAA;AACPA,cAAO;AAAA;AAAA;AAEPA,cAAO;AAAA;AACPA,cAAO,2BAA2B,QAAQ,IAAI,SAAS,SAAS;AAAA;AAChEA,cAAO,mBAAmB,QAAQ,IAAI;AAAA;AACtCA,cAAO,GAAG,QAAQ,IAAI,IAAI,QAAQ,KAAK,QAAQ,SAAS;AAAA;AACxDA,cAAO;AAAA;AACPA,cAAO,oBAAoB,YAAY;AAEvC,aAAOA;AAAAA,IACT;AAGA,QAAI,MAAM,2BAA2B,QAAQ,IAAI,SAAS,SAAS;AAAA;AACnE,WAAO,mBAAmB,QAAQ,IAAI;AAAA;AACtC,WAAO,GAAG,QAAQ,IAAI,IAAI,QAAQ,KAAK,QAAQ,SAAS;AAAA;AACxD,WAAO;AAAA;AAEP,QAAI,QAAQ,WAAW;AACrB,aAAO,SAAS,QAAQ,SAAS;AAAA;AAAA,IACnC;AAIA,QAAI,QAAQ,KAAK,SAAS,SAAS,GAAG;AACpC,aAAO,QAAQ;AAAA,IACjB,OAAO;AAEL,aAAO,oBAAoB,QAAQ,IAAI;AAAA,IACzC;AAEA,WAAO,GAAG,GAAG;AAAA,EACf;AAAA;AAAA;AAAA;AAAA,EAKA,mBAA4B;AAC1B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,uBAAgC;AAC9B,WAAO;AAAA,EACT;AACF;"}

package/dist/schema/ddl/sqlite-strategy.d.ts

@@ -0,0 +1,38 @@
+import { SQLDataType } from '../types.js';
+import { BaseDDLStrategy } from './base-strategy.js';
+import { DatabaseEngine } from './types.js';
+export declare class SQLiteStrategy extends BaseDDLStrategy {
+    readonly engine: DatabaseEngine;
+    /**
+     * SQLite JSON-path index expression — uses the JSON1 `json_extract` function
+     * since SQLite has no native `->>` operator pre-3.38 and we want broad
+     * compatibility with hosted SQLite/libSQL variants.
+     */
+    protected formatJsonPathIndexExpression(jsonColumn: string, path: string): string;
+    /**
+     * Map types for SQLite
+     * - BOOLEAN → INTEGER (SQLite uses 0/1)
+     * - JSON → TEXT (SQLite stores JSON as text, uses JSON1 functions)
+     * - TIMESTAMP → DATETIME (SQLite convention)
+     */
+    mapType(type: SQLDataType): string;
+    /**
+     * Format boolean as 0/1 for SQLite.
+     *
+     * `formatDefaultValue` is inherited from BaseDDLStrategy, which delegates to
+     * the shared safe formatter and bridges this override in as the boolean
+     * literals — so SQLite booleans render as 0/1 and no CAST expression is ever
+     * emitted in a DEFAULT clause.
+     */
+    protected formatBooleanDefault(value: any): string;
+    /**
+     * SQLite supports triggers
+     */
+    supportsTriggers(): boolean;
+    /**
+     * SQLite doesn't require inline UNIQUE for UPSERT
+     * Both inline and separate indexes work
+     */
+    requiresInlineUnique(): boolean;
+}
+//# sourceMappingURL=sqlite-strategy.d.ts.map

package/dist/schema/ddl/sqlite-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/sqlite-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAY;IAE3C;;;;OAIG;IACH,SAAS,CAAC,6BAA6B,CACrC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,MAAM;IAoBT;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAalC;;;;;;;OAOG;IACH,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM;IAIlD;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;OAGG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

package/dist/schema/ddl/sqlite-strategy.js

@@ -0,0 +1,74 @@
+import { isSafeIdentifier, isSafeIdentifierPath, quoteIdentifier, quoteStringLiteral } from "../sql-identifiers.js";
+import { BaseDDLStrategy } from "./base-strategy.js";
+class SQLiteStrategy extends BaseDDLStrategy {
+  engine = "sqlite";
+  /**
+   * SQLite JSON-path index expression — uses the JSON1 `json_extract` function
+   * since SQLite has no native `->>` operator pre-3.38 and we want broad
+   * compatibility with hosted SQLite/libSQL variants.
+   */
+  formatJsonPathIndexExpression(jsonColumn, path) {
+    if (!isSafeIdentifier(jsonColumn)) {
+      throw new Error(
+        `[DDL] Unsafe JSON-path index column "${jsonColumn}": must be a simple identifier`
+      );
+    }
+    if (!isSafeIdentifierPath(path)) {
+      throw new Error(
+        `[DDL] Unsafe JSON-path index path "${path}": must be a simple (dotted) identifier`
+      );
+    }
+    return `json_extract(${quoteIdentifier(jsonColumn)}, ${quoteStringLiteral(
+      `$.${path}`
+    )})`;
+  }
+  /**
+   * Map types for SQLite
+   * - BOOLEAN → INTEGER (SQLite uses 0/1)
+   * - JSON → TEXT (SQLite stores JSON as text, uses JSON1 functions)
+   * - TIMESTAMP → DATETIME (SQLite convention)
+   */
+  mapType(type) {
+    switch (type) {
+      case "BOOLEAN":
+        return "INTEGER";
+      // SQLite uses 0/1 for booleans
+      case "JSON":
+        return "TEXT";
+      // SQLite stores JSON as TEXT
+      case "TIMESTAMP":
+        return "DATETIME";
+      // SQLite convention
+      default:
+        return super.mapType(type);
+    }
+  }
+  /**
+   * Format boolean as 0/1 for SQLite.
+   *
+   * `formatDefaultValue` is inherited from BaseDDLStrategy, which delegates to
+   * the shared safe formatter and bridges this override in as the boolean
+   * literals — so SQLite booleans render as 0/1 and no CAST expression is ever
+   * emitted in a DEFAULT clause.
+   */
+  formatBooleanDefault(value) {
+    return value ? "1" : "0";
+  }
+  /**
+   * SQLite supports triggers
+   */
+  supportsTriggers() {
+    return true;
+  }
+  /**
+   * SQLite doesn't require inline UNIQUE for UPSERT
+   * Both inline and separate indexes work
+   */
+  requiresInlineUnique() {
+    return false;
+  }
+}
+export {
+  SQLiteStrategy
+};
+//# sourceMappingURL=sqlite-strategy.js.map

package/dist/schema/ddl/sqlite-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-strategy.js","sources":["../../../src/schema/ddl/sqlite-strategy.ts"],"sourcesContent":["/**\n * SQLite DDL Strategy\n *\n * SQLite-specific DDL generation with the following characteristics:\n * - No CAST expressions in DEFAULT values\n * - BOOLEAN stored as INTEGER (0/1)\n * - JSON stored as TEXT (with JSON1 extension functions)\n * - Supports triggers with SQLite syntax\n * - UNIQUE can be inline or separate indexes\n */\n\nimport {\n  isSafeIdentifier,\n  isSafeIdentifierPath,\n  quoteIdentifier,\n  quoteStringLiteral,\n} from '../sql-identifiers.js';\nimport type { SQLDataType } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class SQLiteStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'sqlite';\n\n  /**\n   * SQLite JSON-path index expression — uses the JSON1 `json_extract` function\n   * since SQLite has no native `->>` operator pre-3.38 and we want broad\n   * compatibility with hosted SQLite/libSQL variants.\n   */\n  protected formatJsonPathIndexExpression(\n    jsonColumn: string,\n    path: string,\n  ): string {\n    // Column must be a simple identifier (no dots); only the path may be dotted.\n    // Mirrors the `assertSafeJsonPathTarget` file-level helper in\n    // base-strategy.ts so this SQLite override doesn't silently accept dotted\n    // columns that PG/DuckDB (and renderIndexTarget) reject.\n    if (!isSafeIdentifier(jsonColumn)) {\n      throw new Error(\n        `[DDL] Unsafe JSON-path index column \"${jsonColumn}\": must be a simple identifier`,\n      );\n    }\n    if (!isSafeIdentifierPath(path)) {\n      throw new Error(\n        `[DDL] Unsafe JSON-path index path \"${path}\": must be a simple (dotted) identifier`,\n      );\n    }\n    return `json_extract(${quoteIdentifier(jsonColumn)}, ${quoteStringLiteral(\n      `$.${path}`,\n    )})`;\n  }\n\n  /**\n   * Map types for SQLite\n   * - BOOLEAN → INTEGER (SQLite uses 0/1)\n   * - JSON → TEXT (SQLite stores JSON as text, uses JSON1 functions)\n   * - TIMESTAMP → DATETIME (SQLite convention)\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'BOOLEAN':\n        return 'INTEGER'; // SQLite uses 0/1 for booleans\n      case 'JSON':\n        return 'TEXT'; // SQLite stores JSON as TEXT\n      case 'TIMESTAMP':\n        return 'DATETIME'; // SQLite convention\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Format boolean as 0/1 for SQLite.\n   *\n   * `formatDefaultValue` is inherited from BaseDDLStrategy, which delegates to\n   * the shared safe formatter and bridges this override in as the boolean\n   * literals — so SQLite booleans render as 0/1 and no CAST expression is ever\n   * emitted in a DEFAULT clause.\n   */\n  protected formatBooleanDefault(value: any): string {\n    return value ? '1' : '0';\n  }\n\n  /**\n   * SQLite supports triggers\n   */\n  supportsTriggers(): boolean {\n    return true;\n  }\n\n  /**\n   * SQLite doesn't require inline UNIQUE for UPSERT\n   * Both inline and separate indexes work\n   */\n  requiresInlineUnique(): boolean {\n    return false;\n  }\n}\n"],"names":[],"mappings":";;AAqBO,MAAM,uBAAuB,gBAAgB;AAAA,EACzC,SAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOxB,8BACR,YACA,MACQ;AAKR,QAAI,CAAC,iBAAiB,UAAU,GAAG;AACjC,YAAM,IAAI;AAAA,QACR,wCAAwC,UAAU;AAAA,MAAA;AAAA,IAEtD;AACA,QAAI,CAAC,qBAAqB,IAAI,GAAG;AAC/B,YAAM,IAAI;AAAA,QACR,sCAAsC,IAAI;AAAA,MAAA;AAAA,IAE9C;AACA,WAAO,gBAAgB,gBAAgB,UAAU,CAAC,KAAK;AAAA,MACrD,KAAK,IAAI;AAAA,IAAA,CACV;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,QAAQ,MAA2B;AACjC,YAAQ,MAAA;AAAA,MACN,KAAK;AACH,eAAO;AAAA;AAAA,MACT,KAAK;AACH,eAAO;AAAA;AAAA,MACT,KAAK;AACH,eAAO;AAAA;AAAA,MACT;AACE,eAAO,MAAM,QAAQ,IAAI;AAAA,IAAA;AAAA,EAE/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,qBAAqB,OAAoB;AACjD,WAAO,QAAQ,MAAM;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,mBAA4B;AAC1B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,uBAAgC;AAC9B,WAAO;AAAA,EACT;AACF;"}

package/dist/schema/ddl/types.d.ts

@@ -0,0 +1,114 @@
+import { SchemaDefinition, SQLDataType } from '../types.js';
+/**
+ * Supported database engines
+ * - sqlite: SQLite/LibSQL databases
+ * - duckdb: DuckDB databases
+ * - json: JSON adapter backed by DuckDB, with UUID stored as TEXT for stable
+ *   JS round-tripping
+ * - postgres: PostgreSQL databases
+ */
+export type DatabaseEngine = 'sqlite' | 'duckdb' | 'json' | 'postgres';
+/**
+ * Engine-specific DDL output
+ */
+export interface EngineSpecificDDL {
+    /** CREATE TABLE statement */
+    createTable: string;
+    /** CREATE INDEX statements (separate from table for SQLite/Postgres) */
+    indexes: string[];
+    /** CREATE TRIGGER statements (not supported by DuckDB) */
+    triggers: string[];
+}
+/**
+ * Multi-engine DDL for manifest storage
+ */
+export interface MultiEngineDDL {
+    sqlite: EngineSpecificDDL;
+    duckdb: EngineSpecificDDL;
+    json: EngineSpecificDDL;
+    postgres: EngineSpecificDDL;
+}
+/**
+ * DDL Generator Strategy Interface
+ *
+ * Each database engine implements this interface to generate
+ * engine-specific DDL from a SchemaDefinition.
+ */
+export interface DDLStrategy {
+    /** The database engine this strategy generates DDL for */
+    readonly engine: DatabaseEngine;
+    /**
+     * Generate CREATE TABLE statement
+     * @param schema - The schema definition to generate DDL for
+     * @returns CREATE TABLE SQL statement
+     */
+    generateCreateTable(schema: SchemaDefinition): string;
+    /**
+     * Generate CREATE INDEX statements
+     * For DuckDB, UNIQUE indexes should be inline constraints, not separate indexes
+     * @param schema - The schema definition
+     * @returns Array of CREATE INDEX SQL statements
+     */
+    generateIndexes(schema: SchemaDefinition): string[];
+    /**
+     * Generate CREATE TRIGGER statements
+     * DuckDB does not support triggers - returns empty array
+     * @param schema - The schema definition
+     * @returns Array of CREATE TRIGGER SQL statements
+     */
+    generateTriggers(schema: SchemaDefinition): string[];
+    /**
+     * Map abstract SQL type to engine-specific type
+     * @param type - Abstract SQL data type
+     * @returns Engine-specific SQL type string
+     */
+    mapType(type: SQLDataType): string;
+    /**
+     * Format a default value for the engine
+     * SQLite: No CAST expressions
+     * DuckDB/Postgres: Can use CAST
+     * @param value - The default value
+     * @param type - The column type
+     * @returns Formatted default value SQL
+     */
+    formatDefaultValue(value: any, type: SQLDataType): string;
+    /**
+     * Whether this engine supports database triggers
+     * @returns true if triggers are supported
+     */
+    supportsTriggers(): boolean;
+    /**
+     * Whether this engine requires inline UNIQUE constraints for UPSERT
+     * DuckDB requires this due to issue #12684
+     * @returns true if UNIQUE must be inline
+     */
+    requiresInlineUnique(): boolean;
+    /**
+     * Generate a single column definition for use in ALTER TABLE ADD COLUMN
+     * @param columnName - The column name
+     * @param columnDef - The column definition
+     * @returns Column definition SQL fragment (e.g. '"name" TEXT DEFAULT '')
+     */
+    generateColumnDefinition(columnName: string, columnDef: import('../types').ColumnDefinition): string;
+}
+/**
+ * Column generation options
+ */
+export interface ColumnGenerationOptions {
+    /** Include NOT NULL constraint */
+    includeNotNull?: boolean;
+    /** Include DEFAULT clause */
+    includeDefault?: boolean;
+    /** Include PRIMARY KEY constraint */
+    includePrimaryKey?: boolean;
+}
+/**
+ * Table generation options
+ */
+export interface TableGenerationOptions {
+    /** Whether to use IF NOT EXISTS */
+    ifNotExists?: boolean;
+    /** Additional table constraints to append */
+    additionalConstraints?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/schema/ddl/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAEhC;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAAC;IAEtD;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAAC;IAEpD;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAAC;IAErD;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAEnC;;;;;;;OAOG;IACH,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAE1D;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC;IAE5B;;;;OAIG;IACH,oBAAoB,IAAI,OAAO,CAAC;IAEhC;;;;;OAKG;IACH,wBAAwB,CACtB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,OAAO,UAAU,EAAE,gBAAgB,GAC7C,MAAM,CAAC;CACX;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6BAA6B;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,mCAAmC;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6CAA6C;IAC7C,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC"}