@happyvertical/smrt-core 0.30.0

package/dist/scanner/types.d.ts.map

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

package/dist/scanner/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/scanner/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/scanner.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Scanner module - AST scanning and manifest generation
+ * Re-exports from scanner/index.ts
+ */
+export * from './scanner/index.js';
+//# sourceMappingURL=scanner.d.ts.map

package/dist/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../src/scanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,oBAAoB,CAAC"}

package/dist/scanner.js

@@ -0,0 +1,6 @@
+import { ManifestGenerator, generateManifest } from "./scanner/manifest-generator.js";
+export {
+  ManifestGenerator,
+  generateManifest
+};
+//# sourceMappingURL=scanner.js.map

package/dist/scanner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/schema/code-generator.d.ts

@@ -0,0 +1,53 @@
+import { SmartObjectDefinition } from '../scanner/types.js';
+import { SchemaDefinition } from './types.js';
+export declare class SchemaCodeGenerator {
+    /**
+     * Generate getSchema() method source code
+     */
+    generateSchemaMethod(_objectDef: SmartObjectDefinition, schema: SchemaDefinition): string;
+    /**
+     * Generate complete schema file with all methods
+     */
+    generateSchemaFile(schemas: Record<string, SchemaDefinition>): string;
+    /**
+     * Generate import statements
+     */
+    private generateImports;
+    /**
+     * Generate getSchema method for a specific class
+     */
+    private generateClassMethod;
+    /**
+     * Generate standalone getSchema method
+     */
+    private generateMethod;
+    /**
+     * Generate schema object definition
+     */
+    private generateSchemaObject;
+    /**
+     * Generate columns object
+     */
+    private generateColumns;
+    /**
+     * Generate indexes array
+     */
+    private generateIndexes;
+    /**
+     * Generate triggers array
+     */
+    private generateTriggers;
+    /**
+     * Generate foreign keys array
+     */
+    private generateForeignKeys;
+    /**
+     * Generate TypeScript type definition file
+     */
+    generateTypeDefinitions(schemas: Record<string, SchemaDefinition>): string;
+    /**
+     * Generate schema manifest file
+     */
+    generateManifest(packageName: string, schemas: Record<string, SchemaDefinition>): string;
+}
+//# sourceMappingURL=code-generator.d.ts.map

package/dist/schema/code-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/schema/code-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,oBAAoB,CAClB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,gBAAgB,GACvB,MAAM;IAOT;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,MAAM;IASrE;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAWvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,uBAAuB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,MAAM;IAe1E;;OAEG;IACH,gBAAgB,CACd,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GACxC,MAAM;CAuBV"}

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

@@ -0,0 +1,80 @@
+import { ColumnDefinition, IndexDefinition, SchemaDefinition, SQLDataType, TriggerDefinition } from '../types.js';
+import { DatabaseEngine, DDLStrategy } from './types.js';
+/**
+ * Abstract base class for DDL strategies
+ *
+ * Implements common DDL generation patterns. Engine-specific strategies
+ * extend this class and override methods as needed.
+ */
+export declare abstract class BaseDDLStrategy implements DDLStrategy {
+    abstract readonly engine: DatabaseEngine;
+    /**
+     * Generate CREATE TABLE statement
+     */
+    generateCreateTable(schema: SchemaDefinition): string;
+    /**
+     * Generate a single column definition
+     *
+     * Public so SchemaManager can reuse it for ALTER TABLE ADD COLUMN.
+     */
+    generateColumnDefinition(columnName: string, columnDef: ColumnDefinition): string;
+    /**
+     * Generate inline UNIQUE constraints for composite indexes
+     * Used by engines that require inline UNIQUE for UPSERT to work (DuckDB)
+     */
+    protected generateInlineUniqueConstraints(indexes: IndexDefinition[]): string[];
+    /**
+     * Generate CREATE INDEX statements
+     * Override in engine-specific strategies if needed
+     */
+    generateIndexes(schema: SchemaDefinition): string[];
+    /**
+     * Render the SQL expression used to index a JSON path inside a JSONB column.
+     * Subclasses override for dialect-specific syntax.
+     *
+     * Default (ANSI-ish): `<jsonColumn>->>'<path>'` — works on Postgres.
+     */
+    protected formatJsonPathIndexExpression(jsonColumn: string, path: string): string;
+    /**
+     * Generate CREATE TRIGGER statements
+     * Override in engine-specific strategies - DuckDB returns empty
+     */
+    generateTriggers(schema: SchemaDefinition): string[];
+    /**
+     * Generate a single trigger statement
+     * Can be overridden for engine-specific trigger syntax
+     */
+    protected generateTriggerStatement(tableName: string, trigger: TriggerDefinition): string;
+    /**
+     * Map abstract SQL type to engine-specific type
+     * Default implementation - override for engine-specific types
+     */
+    mapType(type: SQLDataType): string;
+    /**
+     * Format default value for SQL.
+     *
+     * Delegates to the shared, injection-safe `formatDefaultValue`
+     * (`schema/sql-identifiers.ts`) so every DDL path uses one set of rules:
+     * an allowlist of SQL keyword/function defaults (not "contains `(`"),
+     * type-driven literal quoting, and no folding of the string `"null"` into
+     * the SQL NULL keyword. Boolean rendering is bridged through
+     * `formatBooleanDefault` so engine overrides (SQLite → 0/1) still apply.
+     */
+    formatDefaultValue(value: any, type: SQLDataType): string;
+    /**
+     * Format boolean default
+     * Override for engines that use INTEGER (SQLite)
+     */
+    protected formatBooleanDefault(value: any): string;
+    /**
+     * Whether this engine supports triggers
+     * Override in DuckDB strategy to return false
+     */
+    supportsTriggers(): boolean;
+    /**
+     * Whether UNIQUE constraints must be inline for UPSERT
+     * Override in DuckDB strategy to return true
+     */
+    requiresInlineUnique(): boolean;
+}
+//# sourceMappingURL=base-strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/base-strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA4B9D;;;;;GAKG;AACH,8BAAsB,eAAgB,YAAW,WAAW;IAC1D,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAEzC;;OAEG;IACH,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM;IAuBrD;;;;OAIG;IACH,wBAAwB,CACtB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,gBAAgB,GAC1B,MAAM;IAuCT;;;OAGG;IACH,SAAS,CAAC,+BAA+B,CACvC,OAAO,EAAE,eAAe,EAAE,GACzB,MAAM,EAAE;IAsBX;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAwDnD;;;;;OAKG;IACH,SAAS,CAAC,6BAA6B,CACrC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,MAAM;IAKT;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAsBpD;;;OAGG;IACH,SAAS,CAAC,wBAAwB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,iBAAiB,GACzB,MAAM;IAcT;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IA2BlC;;;;;;;;;OASG;IACH,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM;IASzD;;;OAGG;IACH,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM;IAIlD;;;OAGG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;OAGG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

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

@@ -0,0 +1,240 @@
+import { createLogger } from "@happyvertical/logger";
+import { quoteIdentifier, quoteStringLiteral, formatDefaultValue, isSafeIdentifier, isSafeIdentifierPath } from "../sql-identifiers.js";
+const logger = createLogger({ level: "info" });
+function assertSafeJsonPathTarget(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`
+    );
+  }
+}
+class BaseDDLStrategy {
+  /**
+   * Generate CREATE TABLE statement
+   */
+  generateCreateTable(schema) {
+    const { tableName, columns, indexes = [] } = schema;
+    let sql = `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(tableName)} (
+`;
+    const columnDefs = [];
+    for (const [columnName, columnDef] of Object.entries(columns)) {
+      columnDefs.push(this.generateColumnDefinition(columnName, columnDef));
+    }
+    if (this.requiresInlineUnique() && indexes.length > 0) {
+      const uniqueConstraints = this.generateInlineUniqueConstraints(indexes);
+      columnDefs.push(...uniqueConstraints);
+    }
+    sql += columnDefs.map((def) => `  ${def}`).join(",\n");
+    sql += "\n);";
+    return sql;
+  }
+  /**
+   * Generate a single column definition
+   *
+   * Public so SchemaManager can reuse it for ALTER TABLE ADD COLUMN.
+   */
+  generateColumnDefinition(columnName, columnDef) {
+    const parts = [
+      quoteIdentifier(columnName),
+      this.mapType(columnDef.type)
+    ];
+    if (columnDef.primaryKey) {
+      parts.push("PRIMARY KEY");
+    }
+    if (columnDef.notNull && !columnDef.primaryKey) {
+      parts.push("NOT NULL");
+    }
+    if (columnDef.unique && !this.requiresInlineUnique()) {
+      parts.push("UNIQUE");
+    }
+    if (columnDef.defaultValue !== void 0) {
+      const formatted = this.formatDefaultValue(
+        columnDef.defaultValue,
+        columnDef.type
+      );
+      parts.push(`DEFAULT ${formatted}`);
+    }
+    if (columnDef.check) {
+      parts.push(`CHECK (${columnDef.check})`);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Generate inline UNIQUE constraints for composite indexes
+   * Used by engines that require inline UNIQUE for UPSERT to work (DuckDB)
+   */
+  generateInlineUniqueConstraints(indexes) {
+    const constraints = [];
+    if (!indexes || !Array.isArray(indexes)) {
+      return constraints;
+    }
+    for (const index of indexes) {
+      if (!index || !index.columns || !Array.isArray(index.columns)) {
+        continue;
+      }
+      if (index.unique && index.columns.length > 0) {
+        const columns = index.columns.map((c) => quoteIdentifier(c)).join(", ");
+        constraints.push(`UNIQUE(${columns})`);
+      }
+    }
+    return constraints;
+  }
+  /**
+   * Generate CREATE INDEX statements
+   * Override in engine-specific strategies if needed
+   */
+  generateIndexes(schema) {
+    const { tableName, indexes = [] } = schema;
+    const statements = [];
+    if (!indexes || indexes.length === 0) {
+      return statements;
+    }
+    for (const index of indexes) {
+      const jsonPath = index?.jsonPath?.column && index.jsonPath.path ? index.jsonPath : null;
+      if (!index || !jsonPath && (!index.columns || !Array.isArray(index.columns) || index.columns.length === 0)) {
+        logger.warn(`[DDL] Skipping malformed index: ${JSON.stringify(index)}`);
+        continue;
+      }
+      if (index.unique && this.requiresInlineUnique()) {
+        continue;
+      }
+      const indexType = index.unique ? "UNIQUE INDEX" : "INDEX";
+      const target = jsonPath ? `(${this.formatJsonPathIndexExpression(
+        jsonPath.column,
+        jsonPath.path
+      )})` : index.columns.map((c) => quoteIdentifier(c)).join(", ");
+      let sql = `CREATE ${indexType} IF NOT EXISTS ${quoteIdentifier(
+        index.name
+      )} ON ${quoteIdentifier(tableName)} (${target})`;
+      if (index.where) {
+        sql += ` WHERE ${index.where}`;
+      }
+      sql += ";";
+      statements.push(sql);
+    }
+    return statements;
+  }
+  /**
+   * Render the SQL expression used to index a JSON path inside a JSONB column.
+   * Subclasses override for dialect-specific syntax.
+   *
+   * Default (ANSI-ish): `<jsonColumn>->>'<path>'` — works on Postgres.
+   */
+  formatJsonPathIndexExpression(jsonColumn, path) {
+    assertSafeJsonPathTarget(jsonColumn, path);
+    return `${quoteIdentifier(jsonColumn)}->>${quoteStringLiteral(path)}`;
+  }
+  /**
+   * Generate CREATE TRIGGER statements
+   * Override in engine-specific strategies - DuckDB returns empty
+   */
+  generateTriggers(schema) {
+    if (!this.supportsTriggers()) {
+      return [];
+    }
+    const { tableName, triggers = [] } = schema;
+    const statements = [];
+    if (!triggers || triggers.length === 0) {
+      return statements;
+    }
+    for (const trigger of triggers) {
+      const sql = this.generateTriggerStatement(tableName, trigger);
+      if (sql) {
+        statements.push(sql);
+      }
+    }
+    return statements;
+  }
+  /**
+   * Generate a single trigger statement
+   * Can be overridden for engine-specific trigger syntax
+   */
+  generateTriggerStatement(tableName, trigger) {
+    let sql = `CREATE TRIGGER IF NOT EXISTS ${quoteIdentifier(trigger.name)}
+`;
+    sql += `${trigger.when} ${trigger.event} ON ${quoteIdentifier(tableName)}
+`;
+    if (trigger.condition) {
+      sql += `WHEN ${trigger.condition}
+`;
+    }
+    sql += `BEGIN
+${trigger.body}
+END;`;
+    return sql;
+  }
+  /**
+   * Map abstract SQL type to engine-specific type
+   * Default implementation - override for engine-specific types
+   */
+  mapType(type) {
+    switch (type) {
+      case "TEXT":
+        return "TEXT";
+      case "INTEGER":
+        return "INTEGER";
+      case "REAL":
+        return "REAL";
+      case "BLOB":
+        return "BLOB";
+      case "BOOLEAN":
+        return "BOOLEAN";
+      case "JSON":
+        return "JSON";
+      case "TIMESTAMP":
+        return "TIMESTAMP";
+      case "UUID":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  /**
+   * Format default value for SQL.
+   *
+   * Delegates to the shared, injection-safe `formatDefaultValue`
+   * (`schema/sql-identifiers.ts`) so every DDL path uses one set of rules:
+   * an allowlist of SQL keyword/function defaults (not "contains `(`"),
+   * type-driven literal quoting, and no folding of the string `"null"` into
+   * the SQL NULL keyword. Boolean rendering is bridged through
+   * `formatBooleanDefault` so engine overrides (SQLite → 0/1) still apply.
+   */
+  formatDefaultValue(value, type) {
+    return formatDefaultValue(value, type, {
+      booleanLiterals: [
+        this.formatBooleanDefault(true),
+        this.formatBooleanDefault(false)
+      ]
+    });
+  }
+  /**
+   * Format boolean default
+   * Override for engines that use INTEGER (SQLite)
+   */
+  formatBooleanDefault(value) {
+    return value ? "TRUE" : "FALSE";
+  }
+  /**
+   * Whether this engine supports triggers
+   * Override in DuckDB strategy to return false
+   */
+  supportsTriggers() {
+    return true;
+  }
+  /**
+   * Whether UNIQUE constraints must be inline for UPSERT
+   * Override in DuckDB strategy to return true
+   */
+  requiresInlineUnique() {
+    return false;
+  }
+}
+export {
+  BaseDDLStrategy
+};
+//# sourceMappingURL=base-strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.js","sources":["../../../src/schema/ddl/base-strategy.ts"],"sourcesContent":["/**\n * Base DDL Strategy - Shared logic for all database engines\n *\n * Provides common DDL generation logic that engine-specific strategies\n * can override for their particular requirements.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport {\n  formatDefaultValue as formatDefaultValueShared,\n  isSafeIdentifier,\n  isSafeIdentifierPath,\n  quoteIdentifier,\n  quoteStringLiteral,\n} from '../sql-identifiers.js';\nimport type {\n  ColumnDefinition,\n  IndexDefinition,\n  SchemaDefinition,\n  SQLDataType,\n  TriggerDefinition,\n} from '../types.js';\nimport type { DatabaseEngine, DDLStrategy } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Validate the column + JSON path used to build a JSON-path index expression.\n *\n * The path segment is embedded as a SQL string literal inside a dialect\n * function/operator (`json_extract(\"col\", '$.path')` / `\"col\"->>'path'`), and\n * the column as a delimited identifier. We escape both, but also reject paths\n * or columns that aren't simple (dotted) identifiers so a malformed `@meta`\n * field name can't smuggle structure into the expression even after escaping.\n * These names are developer-controlled build-time inputs, so an invalid one is\n * a programming error and throwing is the safest, loudest outcome.\n */\nfunction assertSafeJsonPathTarget(jsonColumn: string, path: string): void {\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}\n\n/**\n * Abstract base class for DDL strategies\n *\n * Implements common DDL generation patterns. Engine-specific strategies\n * extend this class and override methods as needed.\n */\nexport abstract class BaseDDLStrategy implements DDLStrategy {\n  abstract readonly engine: DatabaseEngine;\n\n  /**\n   * Generate CREATE TABLE statement\n   */\n  generateCreateTable(schema: SchemaDefinition): string {\n    const { tableName, columns, indexes = [] } = schema;\n\n    let sql = `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(tableName)} (\\n`;\n\n    // Generate column definitions\n    const columnDefs: string[] = [];\n    for (const [columnName, columnDef] of Object.entries(columns)) {\n      columnDefs.push(this.generateColumnDefinition(columnName, columnDef));\n    }\n\n    // Add inline UNIQUE constraints for engines that require them\n    if (this.requiresInlineUnique() && indexes.length > 0) {\n      const uniqueConstraints = this.generateInlineUniqueConstraints(indexes);\n      columnDefs.push(...uniqueConstraints);\n    }\n\n    sql += columnDefs.map((def) => `  ${def}`).join(',\\n');\n    sql += '\\n);';\n\n    return sql;\n  }\n\n  /**\n   * Generate a single column definition\n   *\n   * Public so SchemaManager can reuse it for ALTER TABLE ADD COLUMN.\n   */\n  generateColumnDefinition(\n    columnName: string,\n    columnDef: ColumnDefinition,\n  ): string {\n    const parts: string[] = [\n      quoteIdentifier(columnName),\n      this.mapType(columnDef.type),\n    ];\n\n    // Primary key\n    if (columnDef.primaryKey) {\n      parts.push('PRIMARY KEY');\n    }\n\n    // NOT NULL (skip for primary key - it's implicit)\n    if (columnDef.notNull && !columnDef.primaryKey) {\n      parts.push('NOT NULL');\n    }\n\n    // UNIQUE (for single-column unique, not composite)\n    // Skip if engine requires inline unique - those are handled separately\n    if (columnDef.unique && !this.requiresInlineUnique()) {\n      parts.push('UNIQUE');\n    }\n\n    // DEFAULT value\n    if (columnDef.defaultValue !== undefined) {\n      const formatted = this.formatDefaultValue(\n        columnDef.defaultValue,\n        columnDef.type,\n      );\n      parts.push(`DEFAULT ${formatted}`);\n    }\n\n    // CHECK constraint\n    if (columnDef.check) {\n      parts.push(`CHECK (${columnDef.check})`);\n    }\n\n    return parts.join(' ');\n  }\n\n  /**\n   * Generate inline UNIQUE constraints for composite indexes\n   * Used by engines that require inline UNIQUE for UPSERT to work (DuckDB)\n   */\n  protected generateInlineUniqueConstraints(\n    indexes: IndexDefinition[],\n  ): string[] {\n    const constraints: string[] = [];\n\n    if (!indexes || !Array.isArray(indexes)) {\n      return constraints;\n    }\n\n    for (const index of indexes) {\n      // Skip malformed index entries\n      if (!index || !index.columns || !Array.isArray(index.columns)) {\n        continue;\n      }\n\n      if (index.unique && index.columns.length > 0) {\n        const columns = index.columns.map((c) => quoteIdentifier(c)).join(', ');\n        constraints.push(`UNIQUE(${columns})`);\n      }\n    }\n\n    return constraints;\n  }\n\n  /**\n   * Generate CREATE INDEX statements\n   * Override in engine-specific strategies if needed\n   */\n  generateIndexes(schema: SchemaDefinition): string[] {\n    const { tableName, indexes = [] } = schema;\n    const statements: string[] = [];\n\n    if (!indexes || indexes.length === 0) {\n      return statements;\n    }\n\n    for (const index of indexes) {\n      // Narrow the jsonPath target up-front so the formatter call doesn't\n      // need optional-chained args (and so the malformed-entry check has a\n      // single source of truth).\n      const jsonPath =\n        index?.jsonPath?.column && index.jsonPath.path ? index.jsonPath : null;\n      if (\n        !index ||\n        (!jsonPath &&\n          (!index.columns ||\n            !Array.isArray(index.columns) ||\n            index.columns.length === 0))\n      ) {\n        logger.warn(`[DDL] Skipping malformed index: ${JSON.stringify(index)}`);\n        continue;\n      }\n\n      // Skip UNIQUE indexes if engine requires them inline\n      if (index.unique && this.requiresInlineUnique()) {\n        continue;\n      }\n\n      const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';\n\n      // JSON-path indexes use a dialect-specific expression\n      const target = jsonPath\n        ? `(${this.formatJsonPathIndexExpression(\n            jsonPath.column,\n            jsonPath.path,\n          )})`\n        : index.columns.map((c) => quoteIdentifier(c)).join(', ');\n\n      let sql = `CREATE ${indexType} IF NOT EXISTS ${quoteIdentifier(\n        index.name,\n      )} ON ${quoteIdentifier(tableName)} (${target})`;\n\n      // Partial index condition\n      if (index.where) {\n        sql += ` WHERE ${index.where}`;\n      }\n\n      sql += ';';\n      statements.push(sql);\n    }\n\n    return statements;\n  }\n\n  /**\n   * Render the SQL expression used to index a JSON path inside a JSONB column.\n   * Subclasses override for dialect-specific syntax.\n   *\n   * Default (ANSI-ish): `<jsonColumn>->>'<path>'` — works on Postgres.\n   */\n  protected formatJsonPathIndexExpression(\n    jsonColumn: string,\n    path: string,\n  ): string {\n    assertSafeJsonPathTarget(jsonColumn, path);\n    return `${quoteIdentifier(jsonColumn)}->>${quoteStringLiteral(path)}`;\n  }\n\n  /**\n   * Generate CREATE TRIGGER statements\n   * Override in engine-specific strategies - DuckDB returns empty\n   */\n  generateTriggers(schema: SchemaDefinition): string[] {\n    if (!this.supportsTriggers()) {\n      return [];\n    }\n\n    const { tableName, triggers = [] } = schema;\n    const statements: string[] = [];\n\n    if (!triggers || triggers.length === 0) {\n      return statements;\n    }\n\n    for (const trigger of triggers) {\n      const sql = this.generateTriggerStatement(tableName, trigger);\n      if (sql) {\n        statements.push(sql);\n      }\n    }\n\n    return statements;\n  }\n\n  /**\n   * Generate a single trigger statement\n   * Can be overridden for engine-specific trigger syntax\n   */\n  protected generateTriggerStatement(\n    tableName: string,\n    trigger: TriggerDefinition,\n  ): string {\n    // Default SQLite-style trigger syntax\n    let sql = `CREATE TRIGGER IF NOT EXISTS ${quoteIdentifier(trigger.name)}\\n`;\n    sql += `${trigger.when} ${trigger.event} ON ${quoteIdentifier(tableName)}\\n`;\n\n    if (trigger.condition) {\n      sql += `WHEN ${trigger.condition}\\n`;\n    }\n\n    sql += `BEGIN\\n${trigger.body}\\nEND;`;\n\n    return sql;\n  }\n\n  /**\n   * Map abstract SQL type to engine-specific type\n   * Default implementation - override for engine-specific types\n   */\n  mapType(type: SQLDataType): string {\n    // Default mapping works for most engines\n    switch (type) {\n      case 'TEXT':\n        return 'TEXT';\n      case 'INTEGER':\n        return 'INTEGER';\n      case 'REAL':\n        return 'REAL';\n      case 'BLOB':\n        return 'BLOB';\n      case 'BOOLEAN':\n        return 'BOOLEAN';\n      case 'JSON':\n        return 'JSON';\n      case 'TIMESTAMP':\n        return 'TIMESTAMP';\n      case 'UUID':\n        // Fallback for engines without a native uuid type (e.g. SQLite):\n        // store as TEXT. PostgreSQL/DuckDB override this with their native\n        // uuid type. (R11)\n        return 'TEXT';\n      default:\n        return 'TEXT';\n    }\n  }\n\n  /**\n   * Format default value for SQL.\n   *\n   * Delegates to the shared, injection-safe `formatDefaultValue`\n   * (`schema/sql-identifiers.ts`) so every DDL path uses one set of rules:\n   * an allowlist of SQL keyword/function defaults (not \"contains `(`\"),\n   * type-driven literal quoting, and no folding of the string `\"null\"` into\n   * the SQL NULL keyword. Boolean rendering is bridged through\n   * `formatBooleanDefault` so engine overrides (SQLite → 0/1) still apply.\n   */\n  formatDefaultValue(value: any, type: SQLDataType): string {\n    return formatDefaultValueShared(value, type, {\n      booleanLiterals: [\n        this.formatBooleanDefault(true),\n        this.formatBooleanDefault(false),\n      ],\n    });\n  }\n\n  /**\n   * Format boolean default\n   * Override for engines that use INTEGER (SQLite)\n   */\n  protected formatBooleanDefault(value: any): string {\n    return value ? 'TRUE' : 'FALSE';\n  }\n\n  /**\n   * Whether this engine supports triggers\n   * Override in DuckDB strategy to return false\n   */\n  supportsTriggers(): boolean {\n    return true;\n  }\n\n  /**\n   * Whether UNIQUE constraints must be inline for UPSERT\n   * Override in DuckDB strategy to return true\n   */\n  requiresInlineUnique(): boolean {\n    return false;\n  }\n}\n"],"names":["formatDefaultValueShared"],"mappings":"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"}

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

@@ -0,0 +1,33 @@
+import { SchemaDefinition, SQLDataType } from '../types.js';
+import { BaseDDLStrategy } from './base-strategy.js';
+import { DatabaseEngine } from './types.js';
+export declare class DuckDBStrategy extends BaseDDLStrategy {
+    readonly engine: DatabaseEngine;
+    /**
+     * Map types for DuckDB
+     * DuckDB has native support for most types
+     */
+    mapType(type: SQLDataType): string;
+    /**
+     * Generate CREATE INDEX statements
+     *
+     * CRITICAL: Skip UNIQUE indexes - they must be inline constraints for UPSERT
+     */
+    generateIndexes(schema: SchemaDefinition): string[];
+    /**
+     * DuckDB does NOT support triggers
+     */
+    generateTriggers(_schema: SchemaDefinition): string[];
+    /**
+     * DuckDB does NOT support triggers
+     */
+    supportsTriggers(): boolean;
+    /**
+     * CRITICAL: DuckDB requires inline UNIQUE for UPSERT
+     *
+     * DuckDB issue #12684: ON CONFLICT only works with inline UNIQUE constraints,
+     * not with separate CREATE UNIQUE INDEX statements.
+     */
+    requiresInlineUnique(): boolean;
+}
+//# sourceMappingURL=duckdb-strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,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;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAalC;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE;IA2BnD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAIrD;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;;;OAKG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

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

@@ -0,0 +1,74 @@
+import { renderIndexTarget } from "../index-utils.js";
+import { BaseDDLStrategy } from "./base-strategy.js";
+class DuckDBStrategy extends BaseDDLStrategy {
+  engine = "duckdb";
+  /**
+   * Map types for DuckDB
+   * DuckDB has native support for most types
+   */
+  mapType(type) {
+    switch (type) {
+      case "TIMESTAMP":
+        return "TIMESTAMP";
+      // DuckDB supports TIMESTAMP natively
+      case "JSON":
+        return "JSON";
+      // DuckDB has native JSON type
+      case "UUID":
+        return "UUID";
+      // DuckDB has a native UUID type (R11)
+      default:
+        return super.mapType(type);
+    }
+  }
+  /**
+   * Generate CREATE INDEX statements
+   *
+   * CRITICAL: Skip UNIQUE indexes - they must be inline constraints for UPSERT
+   */
+  generateIndexes(schema) {
+    const { tableName, indexes } = schema;
+    const statements = [];
+    for (const index of indexes) {
+      if (index.unique) {
+        continue;
+      }
+      const target = renderIndexTarget(index, this.engine);
+      if (!target) {
+        continue;
+      }
+      let sql = `CREATE INDEX IF NOT EXISTS "${index.name}" ON "${tableName}" (${target})`;
+      if (index.where) {
+        sql += ` WHERE ${index.where}`;
+      }
+      sql += ";";
+      statements.push(sql);
+    }
+    return statements;
+  }
+  /**
+   * DuckDB does NOT support triggers
+   */
+  generateTriggers(_schema) {
+    return [];
+  }
+  /**
+   * DuckDB does NOT support triggers
+   */
+  supportsTriggers() {
+    return false;
+  }
+  /**
+   * CRITICAL: DuckDB requires inline UNIQUE for UPSERT
+   *
+   * DuckDB issue #12684: ON CONFLICT only works with inline UNIQUE constraints,
+   * not with separate CREATE UNIQUE INDEX statements.
+   */
+  requiresInlineUnique() {
+    return true;
+  }
+}
+export {
+  DuckDBStrategy
+};
+//# sourceMappingURL=duckdb-strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-strategy.js","sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"sourcesContent":["/**\n * DuckDB DDL Strategy\n *\n * DuckDB-specific DDL generation with the following characteristics:\n * - UNIQUE constraints MUST be inline for UPSERT to work (DuckDB issue #12684)\n * - Supports CAST in DEFAULT values\n * - Native BOOLEAN, JSON types\n * - Does NOT support triggers\n *\n * CRITICAL: DuckDB's ON CONFLICT clause only works with inline UNIQUE constraints,\n * not with separate UNIQUE indexes. This is a known DuckDB limitation.\n */\n\nimport { renderIndexTarget } from '../index-utils.js';\nimport type { SchemaDefinition, SQLDataType } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class DuckDBStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'duckdb';\n\n  /**\n   * Map types for DuckDB\n   * DuckDB has native support for most types\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'TIMESTAMP':\n        return 'TIMESTAMP'; // DuckDB supports TIMESTAMP natively\n      case 'JSON':\n        return 'JSON'; // DuckDB has native JSON type\n      case 'UUID':\n        return 'UUID'; // DuckDB has a native UUID type (R11)\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate CREATE INDEX statements\n   *\n   * CRITICAL: Skip UNIQUE indexes - they must be inline constraints for UPSERT\n   */\n  generateIndexes(schema: SchemaDefinition): string[] {\n    const { tableName, indexes } = schema;\n    const statements: string[] = [];\n\n    for (const index of indexes) {\n      // Skip UNIQUE indexes - they're inline constraints\n      if (index.unique) {\n        continue;\n      }\n\n      const target = renderIndexTarget(index, this.engine);\n      if (!target) {\n        continue;\n      }\n      let sql = `CREATE INDEX IF NOT EXISTS \"${index.name}\" ON \"${tableName}\" (${target})`;\n\n      if (index.where) {\n        sql += ` WHERE ${index.where}`;\n      }\n\n      sql += ';';\n      statements.push(sql);\n    }\n\n    return statements;\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  generateTriggers(_schema: SchemaDefinition): string[] {\n    return []; // DuckDB doesn't support triggers\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  supportsTriggers(): boolean {\n    return false;\n  }\n\n  /**\n   * CRITICAL: DuckDB requires inline UNIQUE for UPSERT\n   *\n   * DuckDB issue #12684: ON CONFLICT only works with inline UNIQUE constraints,\n   * not with separate CREATE UNIQUE INDEX statements.\n   */\n  requiresInlineUnique(): boolean {\n    return true;\n  }\n}\n"],"names":[],"mappings":";;AAkBO,MAAM,uBAAuB,gBAAgB;AAAA,EACzC,SAAyB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMlC,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,EAOA,gBAAgB,QAAoC;AAClD,UAAM,EAAE,WAAW,QAAA,IAAY;AAC/B,UAAM,aAAuB,CAAA;AAE7B,eAAW,SAAS,SAAS;AAE3B,UAAI,MAAM,QAAQ;AAChB;AAAA,MACF;AAEA,YAAM,SAAS,kBAAkB,OAAO,KAAK,MAAM;AACnD,UAAI,CAAC,QAAQ;AACX;AAAA,MACF;AACA,UAAI,MAAM,+BAA+B,MAAM,IAAI,SAAS,SAAS,MAAM,MAAM;AAEjF,UAAI,MAAM,OAAO;AACf,eAAO,UAAU,MAAM,KAAK;AAAA,MAC9B;AAEA,aAAO;AACP,iBAAW,KAAK,GAAG;AAAA,IACrB;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiB,SAAqC;AACpD,WAAO,CAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,mBAA4B;AAC1B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,uBAAgC;AAC9B,WAAO;AAAA,EACT;AACF;"}

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

@@ -0,0 +1,53 @@
+import { SchemaDefinition } from '../types.js';
+import { DatabaseEngine, DDLStrategy, EngineSpecificDDL, MultiEngineDDL } from './types.js';
+/**
+ * DDL Generator Module
+ *
+ * Per-engine DDL generation for SMRT schema management.
+ * SMRT handles ALL database maintenance directly - SDK SQL remains a pure query/CRUD layer.
+ */
+export { BaseDDLStrategy } from './base-strategy.js';
+export { DuckDBStrategy } from './duckdb-strategy.js';
+export { JsonDuckDBStrategy } from './json-duckdb-strategy.js';
+export { PostgresStrategy } from './postgres-strategy.js';
+export { SQLiteStrategy } from './sqlite-strategy.js';
+export * from './types.js';
+/**
+ * Get the DDL strategy for a specific database engine
+ *
+ * @param engine - The database engine type
+ * @returns The DDL strategy for that engine
+ */
+export declare function getDDLStrategy(engine: DatabaseEngine): DDLStrategy;
+/**
+ * Get all available DDL strategies
+ *
+ * @returns Array of all DDL strategies
+ */
+export declare function getAllStrategies(): DDLStrategy[];
+/**
+ * Generate DDL for a specific engine
+ *
+ * @param schema - The schema definition
+ * @param engine - The target database engine
+ * @returns Engine-specific DDL (createTable, indexes, triggers)
+ */
+export declare function generateDDLForEngine(schema: SchemaDefinition, engine: DatabaseEngine): EngineSpecificDDL;
+/**
+ * Generate DDL for all supported engines
+ *
+ * Useful for storing pre-generated DDL in manifest at build time.
+ *
+ * @param schema - The schema definition
+ * @returns DDL for all engines
+ */
+export declare function generateMultiEngineDDL(schema: SchemaDefinition): MultiEngineDDL;
+/**
+ * Detect database engine from URL or connection type
+ *
+ * @param url - Database URL or path
+ * @param type - Optional explicit type hint
+ * @returns Detected database engine
+ */
+export declare function detectEngine(url: string, type?: string): DatabaseEngine;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,cAAc,YAAY,CAAC;AAE3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAUpB;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAMlE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,cAAc,GACrB,iBAAiB,CAQnB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,gBAAgB,GACvB,cAAc,CAOhB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc,CA+DvE"}