@happyvertical/smrt-core 0.30.0

package/dist/schema/generator.js

@@ -0,0 +1,1076 @@
+import { createHash } from "node:crypto";
+import { classnameToTablename } from "../utils/naming.js";
+import { getDDLStrategy } from "./ddl/index.js";
+import { quoteIdentifier, quoteStringLiteral, formatDefaultValue } from "./sql-identifiers.js";
+class SchemaGenerator {
+  /**
+   * Generate schema definition from SMRT object definition
+   */
+  generateSchema(objectDef) {
+    const tableName = this.getTableName(objectDef);
+    const columns = this.generateColumns(
+      objectDef.fields,
+      objectDef.decoratorConfig
+    );
+    const indexes = this.generateIndexes(objectDef, columns);
+    const triggers = this.generateTriggers(objectDef, tableName);
+    const foreignKeys = this.extractForeignKeys(columns);
+    const dependencies = this.extractDependencies(objectDef, foreignKeys);
+    const version = this.generateVersion(objectDef);
+    return {
+      tableName,
+      columns,
+      indexes,
+      triggers,
+      foreignKeys,
+      dependencies,
+      version,
+      packageName: this.extractPackageName(objectDef.filePath),
+      baseClass: objectDef.extends
+    };
+  }
+  /**
+   * Convert field type to SQL data type
+   */
+  mapFieldTypeToSQL(fieldType) {
+    switch (fieldType) {
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "decimal":
+        return "REAL";
+      case "boolean":
+        return "BOOLEAN";
+      case "datetime":
+        return "TIMESTAMP";
+      case "json":
+        return "JSON";
+      case "foreignKey":
+        return "UUID";
+      // Foreign keys default to UUID, then same-package refs can be reconciled to target idType
+      case "crossPackageRef":
+        return "UUID";
+      // Cross-package refs are UUID ids with no DDL FK constraint
+      default:
+        return "TEXT";
+    }
+  }
+  getIdColumnType(config) {
+    return config?.idType === "text" ? "TEXT" : "UUID";
+  }
+  getRelationshipColumnType(field) {
+    if (field?._meta?.sqlType) {
+      return String(field._meta.sqlType).toUpperCase();
+    }
+    if (field?.type === "crossPackageRef" && (field._meta?.idType === "text" || field.idType === "text")) {
+      return "TEXT";
+    }
+    return this.mapFieldTypeToSQL(field?.type || "text");
+  }
+  getReferenceKind(field) {
+    if (field?.__tenancy?.isTenantIdField || field?._meta?.__tenancy?.isTenantIdField) {
+      return "tenantId";
+    }
+    if (field?.type === "foreignKey") {
+      return "foreignKey";
+    }
+    if (field?.type === "crossPackageRef") {
+      return "crossPackageRef";
+    }
+    return void 0;
+  }
+  shouldEmitDefault(field, defaultValue) {
+    return !(this.getReferenceKind(field) === "tenantId" && this.getRelationshipColumnType(field) === "UUID" && defaultValue === "");
+  }
+  getRegistryTargetIdColumnType(relatedName, registry) {
+    if (!relatedName || !registry?.getConfig) {
+      return void 0;
+    }
+    const targetName = relatedName.split(".")[0];
+    const targetNames = [targetName];
+    const stiBase = registry.getSTIBase?.(targetName);
+    if (stiBase && !targetNames.includes(stiBase)) {
+      targetNames.push(stiBase);
+    }
+    for (const name of targetNames) {
+      const idType = registry.getConfig(name)?.idType;
+      if (idType === "text") {
+        return "TEXT";
+      }
+      if (idType === "uuid") {
+        return "UUID";
+      }
+    }
+    return void 0;
+  }
+  reconcileRegistryForeignKeyColumnTypes(columns, fields, registry) {
+    if (!registry?.getConfig) {
+      return;
+    }
+    for (const [fieldName, field] of fields.entries()) {
+      if (field.type !== "foreignKey" || field._meta?.sqlType) {
+        continue;
+      }
+      const targetIdType = this.getRegistryTargetIdColumnType(
+        field.related,
+        registry
+      );
+      if (!targetIdType) {
+        continue;
+      }
+      const columnName = this.toSnakeCase(fieldName);
+      if (columns[columnName]) {
+        columns[columnName] = {
+          ...columns[columnName],
+          type: targetIdType
+        };
+      }
+    }
+  }
+  /**
+   * Generate column definitions
+   */
+  generateColumns(fields, config) {
+    const columns = {};
+    columns.id = {
+      type: this.getIdColumnType(config),
+      primaryKey: true,
+      referenceKind: "id",
+      notNull: true,
+      description: "Primary identifier"
+    };
+    columns.created_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      defaultValue: "current_timestamp",
+      description: "Creation timestamp"
+    };
+    columns.updated_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      defaultValue: "current_timestamp",
+      description: "Last update timestamp"
+    };
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      if (fieldName === "id" || fieldName === "created_at" || fieldName === "updated_at") {
+        continue;
+      }
+      if (fieldDef.transient || fieldDef._meta?.transient) {
+        continue;
+      }
+      if (fieldDef.type === "oneToMany" || fieldDef.type === "manyToMany") {
+        continue;
+      }
+      if (fieldDef.type === "meta") {
+        continue;
+      }
+      const column = {
+        type: this.getRelationshipColumnType(fieldDef),
+        referenceKind: this.getReferenceKind(fieldDef),
+        // If _meta.nullable is true, the field can be null regardless of required
+        // This handles field helpers like text({ required: true, nullable: true })
+        notNull: fieldDef._meta?.nullable ? false : fieldDef.required || false,
+        unique: fieldDef._meta?.unique || false,
+        description: fieldDef.description
+      };
+      if (fieldDef.default !== void 0 && this.shouldEmitDefault(fieldDef, fieldDef.default)) {
+        column.defaultValue = fieldDef.default;
+      }
+      if (fieldDef.type === "foreignKey" && fieldDef.related) {
+        const [table, columnName = "id"] = fieldDef.related.split(".");
+        column.foreignKey = {
+          table,
+          column: columnName,
+          onDelete: "CASCADE",
+          // Default behavior
+          onUpdate: "CASCADE"
+        };
+      }
+      if (fieldName === "slug" || fieldName === "email") {
+        column.unique = true;
+      }
+      columns[fieldName] = column;
+    }
+    return columns;
+  }
+  /**
+   * Generate index definitions
+   */
+  generateIndexes(objectDef, columns) {
+    const indexes = [];
+    const tableName = this.getTableName(objectDef);
+    for (const [columnName, columnDef] of Object.entries(columns)) {
+      if (columnDef.foreignKey) {
+        indexes.push({
+          name: `idx_${tableName}_${columnName}`,
+          columns: [columnName],
+          description: `Index for foreign key ${columnName}`
+        });
+      }
+    }
+    indexes.push({
+      name: `idx_${tableName}_updated_at`,
+      columns: ["updated_at"],
+      description: "Index for timestamp queries"
+    });
+    for (const [columnName, columnDef] of Object.entries(columns)) {
+      if (columnDef.unique && !columnDef.primaryKey) {
+        indexes.push({
+          name: `idx_${tableName}_${columnName}_unique`,
+          columns: [columnName],
+          unique: true,
+          description: `Unique index for ${columnName}`
+        });
+      }
+    }
+    return indexes;
+  }
+  /**
+   * Generate trigger definitions for automatic timestamp updates
+   */
+  generateTriggers(_objectDef, tableName) {
+    return [
+      {
+        name: `trg_${tableName}_updated_at`,
+        when: "BEFORE",
+        event: "UPDATE",
+        body: `UPDATE ${quoteIdentifier(tableName)} SET "updated_at" = current_timestamp WHERE "id" = NEW."id";`,
+        description: "Automatically update updated_at timestamp"
+      }
+    ];
+  }
+  /**
+   * Extract foreign key definitions
+   */
+  extractForeignKeys(columns) {
+    const foreignKeys = [];
+    for (const [columnName, columnDef] of Object.entries(columns)) {
+      if (columnDef.foreignKey) {
+        foreignKeys.push({
+          column: columnName,
+          referencesTable: columnDef.foreignKey.table,
+          referencesColumn: columnDef.foreignKey.column,
+          onDelete: columnDef.foreignKey.onDelete,
+          onUpdate: columnDef.foreignKey.onUpdate
+        });
+      }
+    }
+    return foreignKeys;
+  }
+  /**
+   * Extract schema dependencies from foreign keys and inheritance
+   */
+  extractDependencies(objectDef, foreignKeys) {
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const fk of foreignKeys) {
+      dependencies.add(fk.referencesTable);
+    }
+    if (objectDef.extends && objectDef.extends !== "SmrtObject" && objectDef.extends !== "SmrtCollection") {
+      dependencies.add(this.classNameToTableName(objectDef.extends));
+    }
+    return Array.from(dependencies);
+  }
+  /**
+   * Generate version hash for schema
+   */
+  generateVersion(objectDef) {
+    const content = JSON.stringify({
+      className: objectDef.className,
+      fields: objectDef.fields,
+      extends: objectDef.extends
+    });
+    return createHash("sha256").update(content).digest("hex").substring(0, 8);
+  }
+  /**
+   * Get table name from object definition
+   */
+  getTableName(objectDef) {
+    return this.classNameToTableName(objectDef.className);
+  }
+  /**
+   * Convert class name to table name (camelCase to snake_case, pluralized)
+   */
+  classNameToTableName(className) {
+    return classnameToTablename(className);
+  }
+  /**
+   * Extract package name from file path
+   */
+  extractPackageName(filePath) {
+    const match = filePath.match(/packages\/([^/]+)/);
+    return match ? match[1] : "unknown";
+  }
+  /**
+   * Generate schema definition from ObjectRegistry fields (runtime)
+   *
+   * This method builds a SchemaDefinition from ObjectRegistry cached fields,
+   * enabling schema generation from decorated classes at runtime.
+   *
+   * @param className - Class name to look up in ObjectRegistry
+   * @param tableName - Table name (from SMRT_TABLE_NAME or derived)
+   * @param fields - Map of Field definitions from ObjectRegistry
+   * @returns Schema definition object
+   */
+  generateSchemaFromRegistry(className, tableName, fields, config) {
+    const columns = {};
+    let hasCustomPK = false;
+    for (const [_fieldName, field] of fields.entries()) {
+      if (field._meta?.primaryKey) {
+        hasCustomPK = true;
+        break;
+      }
+    }
+    if (!hasCustomPK) {
+      columns.id = {
+        type: this.getIdColumnType(config),
+        primaryKey: true,
+        referenceKind: "id",
+        notNull: true,
+        description: "Primary identifier"
+      };
+      columns.slug = {
+        type: "TEXT",
+        notNull: true,
+        description: "URL-friendly identifier"
+      };
+      columns.context = {
+        type: "TEXT",
+        notNull: true,
+        defaultValue: "",
+        description: "Context for slug scoping"
+      };
+    }
+    let hasCreatedAt = false;
+    let hasUpdatedAt = false;
+    const indexedColumns = /* @__PURE__ */ new Set();
+    for (const [fieldName, field] of fields.entries()) {
+      if (field.transient || field._meta?.transient) {
+        continue;
+      }
+      const isDefaultSmrtColumn = fieldName === "id" || fieldName === "slug" || fieldName === "context";
+      if (isDefaultSmrtColumn && (!hasCustomPK || field._meta?.__smrtSystemField === true)) {
+        continue;
+      }
+      if (fieldName === "created_at" || fieldName === "createdAt") {
+        if (hasCreatedAt) continue;
+        hasCreatedAt = true;
+        columns.created_at = {
+          type: "TIMESTAMP",
+          notNull: true,
+          defaultValue: "current_timestamp",
+          description: "Creation timestamp"
+        };
+        continue;
+      }
+      if (fieldName === "updated_at" || fieldName === "updatedAt") {
+        if (hasUpdatedAt) continue;
+        hasUpdatedAt = true;
+        columns.updated_at = {
+          type: "TIMESTAMP",
+          notNull: true,
+          defaultValue: "current_timestamp",
+          description: "Last update timestamp"
+        };
+        continue;
+      }
+      if (field.type === "oneToMany" || field.type === "manyToMany") {
+        continue;
+      }
+      if (field.type === "meta") {
+        continue;
+      }
+      const sqlType = this.getRelationshipColumnType(field);
+      const columnDef = {
+        type: sqlType,
+        referenceKind: this.getReferenceKind(field),
+        // If _meta.nullable is true, the field can be null regardless of required
+        notNull: field._meta?.nullable ? false : field._meta?.required || false,
+        primaryKey: field._meta?.primaryKey || false,
+        unique: field._meta?.unique || false,
+        description: field._meta?.description
+      };
+      if (field._meta?.default !== void 0 && this.shouldEmitDefault(field, field._meta.default)) {
+        columnDef.defaultValue = field._meta.default;
+      }
+      if (field.type === "foreignKey") {
+        const relatedName = field.related;
+        const onDeleteAction = field._meta?.onDelete;
+        if (relatedName) {
+          columnDef.foreignKey = {
+            table: this.classNameToTableName(relatedName),
+            column: "id",
+            onDelete: onDeleteAction || "CASCADE",
+            onUpdate: "CASCADE"
+          };
+        }
+      }
+      const isIndexed = field._meta?.indexed === true || field.indexed === true;
+      if (isIndexed && !columnDef.foreignKey && !columnDef.unique && !columnDef.primaryKey) {
+        indexedColumns.add(this.toSnakeCase(fieldName));
+      }
+      columns[this.toSnakeCase(fieldName)] = columnDef;
+    }
+    if (!hasCreatedAt) {
+      columns.created_at = {
+        type: "TIMESTAMP",
+        notNull: true,
+        defaultValue: "current_timestamp",
+        description: "Creation timestamp"
+      };
+    }
+    if (!hasUpdatedAt) {
+      columns.updated_at = {
+        type: "TIMESTAMP",
+        notNull: true,
+        defaultValue: "current_timestamp",
+        description: "Last update timestamp"
+      };
+    }
+    this.reconcileRegistryForeignKeyColumnTypes(
+      columns,
+      fields,
+      config?.registry
+    );
+    const indexes = [];
+    if (!hasCustomPK) {
+      indexes.push({
+        name: `${tableName}_id_idx`,
+        columns: ["id"],
+        description: "Primary key index"
+      });
+      const conflictColumns = config?.conflictColumns || ["slug", "context"];
+      const conflictIndexName = conflictColumns.length > 2 ? `${tableName}_${conflictColumns.slice(0, 2).join("_")}_idx` : `${tableName}_${conflictColumns.join("_")}_idx`;
+      indexes.push({
+        name: conflictIndexName,
+        columns: conflictColumns,
+        unique: true,
+        description: `Unique conflict index for ${className}`
+      });
+    } else {
+      for (const [colName, colDef] of Object.entries(columns)) {
+        if (colDef.primaryKey) {
+          indexes.push({
+            name: `${tableName}_${colName}_idx`,
+            columns: [colName],
+            description: `Primary key index`
+          });
+          break;
+        }
+      }
+    }
+    for (const [colName, colDef] of Object.entries(columns)) {
+      if (colDef.foreignKey) {
+        indexes.push({
+          name: `idx_${tableName}_${colName}`,
+          columns: [colName],
+          description: `Foreign key index for ${colName}`
+        });
+      }
+    }
+    for (const colName of indexedColumns) {
+      indexes.push({
+        name: `${tableName}_${colName}_idx`,
+        columns: [colName],
+        description: `Index for ${colName}`
+      });
+    }
+    return {
+      tableName,
+      columns,
+      indexes,
+      triggers: [],
+      foreignKeys: this.extractForeignKeys(columns),
+      dependencies: [],
+      version: createHash("sha256").update(JSON.stringify(columns)).digest("hex").substring(0, 8),
+      packageName: "runtime",
+      baseClass: "SmrtObject"
+    };
+  }
+  /**
+   * Generate STI (Single Table Inheritance) schema from ObjectRegistry fields
+   *
+   * Creates a shared table for an inheritance hierarchy with:
+   * - _meta_type: Discriminator column to identify class type
+   * - _meta_data: JSON column for flexible field storage
+   * - Union of all FK columns from descendants (all nullable)
+   * - Partial indexes for FK columns (filtered by _meta_type)
+   *
+   * @param baseClassName - Base class name for the STI hierarchy
+   * @param tableName - Shared table name (from base class)
+   * @param fields - Map of Field definitions from base class
+   * @returns Schema definition object for STI table
+   * @example
+   * ```typescript
+   * @smrt({ tableStrategy: 'sti' })
+   * class Event extends SmrtObject {
+   *   title: string = '';
+   * }
+   *
+   * @smrt()
+   * class Meeting extends Event {
+   *   roomId = foreignKey(Room);
+   * }
+   *
+   * // Generates single table 'events' with:
+   * // - title (from Event)
+   * // - room_id (from Meeting, nullable)
+   * // - _meta_type TEXT NOT NULL (discriminator)
+   * // - _meta_data JSON (flexible storage)
+   * ```
+   */
+  async generateSTISchemaFromRegistry(baseClassName, tableName, _fields, config) {
+    const ObjectRegistry = config?.registry ?? (await import("../registry.js")).ObjectRegistry;
+    const columns = {};
+    columns.id = {
+      type: this.getIdColumnType(config),
+      primaryKey: true,
+      referenceKind: "id",
+      notNull: true,
+      description: "Primary identifier"
+    };
+    columns.slug = {
+      type: "TEXT",
+      notNull: true,
+      description: "URL-friendly identifier"
+    };
+    columns.context = {
+      type: "TEXT",
+      notNull: true,
+      defaultValue: "",
+      description: "Context for slug scoping"
+    };
+    columns._meta_type = {
+      type: "TEXT",
+      notNull: true,
+      description: "Class type discriminator for STI"
+    };
+    columns._meta_data = {
+      type: "JSON",
+      notNull: false,
+      description: "Flexible JSON storage for meta() fields"
+    };
+    let hasCreatedAt = false;
+    let hasUpdatedAt = false;
+    const descendants = ObjectRegistry.getDescendants(baseClassName);
+    const allClassNames = [baseClassName, ...descendants];
+    const fkColumnsByClass = /* @__PURE__ */ new Map();
+    const indexedMetaFields = /* @__PURE__ */ new Set();
+    const indexedStiColumns = /* @__PURE__ */ new Set();
+    for (const className of allClassNames) {
+      const classFields = await ObjectRegistry.getAllFields(className);
+      fkColumnsByClass.set(className, /* @__PURE__ */ new Set());
+      for (const [fieldName, field] of classFields.entries()) {
+        if (field.transient || field._meta?.transient) {
+          continue;
+        }
+        if (field.type === "meta" && (field.indexed === true || field._meta?.indexed === true)) {
+          indexedMetaFields.add(fieldName);
+        }
+        if (fieldName === "id" || fieldName === "slug" || fieldName === "context") {
+          continue;
+        }
+        if (fieldName === "created_at" || fieldName === "createdAt") {
+          if (hasCreatedAt) continue;
+          hasCreatedAt = true;
+          columns.created_at = {
+            type: "TIMESTAMP",
+            notNull: true,
+            defaultValue: "current_timestamp",
+            description: "Creation timestamp"
+          };
+          continue;
+        }
+        if (fieldName === "updated_at" || fieldName === "updatedAt") {
+          if (hasUpdatedAt) continue;
+          hasUpdatedAt = true;
+          columns.updated_at = {
+            type: "TIMESTAMP",
+            notNull: true,
+            defaultValue: "current_timestamp",
+            description: "Last update timestamp"
+          };
+          continue;
+        }
+        if (field.type === "oneToMany" || field.type === "manyToMany") {
+          continue;
+        }
+        if (field.type === "meta") {
+          continue;
+        }
+        const columnName = this.toSnakeCase(fieldName);
+        if (columns[columnName]) {
+          continue;
+        }
+        const sqlType = this.getRelationshipColumnType(field);
+        const columnDef = {
+          type: sqlType,
+          referenceKind: this.getReferenceKind(field),
+          // STI: All columns nullable (union of child fields)
+          notNull: false,
+          primaryKey: false,
+          unique: false,
+          description: field._meta?.description
+        };
+        if (field._meta?.default !== void 0 && this.shouldEmitDefault(field, field._meta.default)) {
+          columnDef.defaultValue = field._meta.default;
+        }
+        if (field.type === "foreignKey") {
+          const relatedName = field.related;
+          const onDeleteAction = field._meta?.onDelete;
+          if (relatedName) {
+            columnDef.foreignKey = {
+              table: this.classNameToTableName(relatedName),
+              column: "id",
+              onDelete: onDeleteAction || "CASCADE",
+              onUpdate: "CASCADE"
+            };
+            fkColumnsByClass.get(className)?.add(columnName);
+          }
+        }
+        const isIndexed = field._meta?.indexed === true || field.indexed === true;
+        if (isIndexed && !columnDef.foreignKey) {
+          indexedStiColumns.add(columnName);
+        }
+        columns[columnName] = columnDef;
+      }
+    }
+    if (!hasCreatedAt) {
+      columns.created_at = {
+        type: "TIMESTAMP",
+        notNull: true,
+        defaultValue: "current_timestamp",
+        description: "Creation timestamp"
+      };
+    }
+    if (!hasUpdatedAt) {
+      columns.updated_at = {
+        type: "TIMESTAMP",
+        notNull: true,
+        defaultValue: "current_timestamp",
+        description: "Last update timestamp"
+      };
+    }
+    for (const className of allClassNames) {
+      const classFields = await ObjectRegistry.getAllFields(className);
+      this.reconcileRegistryForeignKeyColumnTypes(
+        columns,
+        classFields,
+        ObjectRegistry
+      );
+    }
+    const indexes = [];
+    indexes.push({
+      name: `${tableName}_id_idx`,
+      columns: ["id"],
+      description: "Primary key index"
+    });
+    indexes.push({
+      name: `${tableName}_slug_context_meta_type_idx`,
+      columns: ["slug", "context", "_meta_type"],
+      unique: true,
+      description: "Unique index for slug, context, and type"
+    });
+    indexes.push({
+      name: `${tableName}_meta_type_idx`,
+      columns: ["_meta_type"],
+      description: "Index for type discriminator queries"
+    });
+    for (const [className, fkColumns] of fkColumnsByClass.entries()) {
+      for (const fkColumn of fkColumns) {
+        indexes.push({
+          name: `idx_${tableName}_${fkColumn}_${className.toLowerCase()}`,
+          columns: [fkColumn],
+          where: `_meta_type = ${quoteStringLiteral(className)}`,
+          description: `Partial index for ${fkColumn} in ${className} rows`
+        });
+      }
+    }
+    for (const fieldName of indexedMetaFields) {
+      indexes.push({
+        name: `${tableName}_meta_${this.toSnakeCase(fieldName)}_idx`,
+        columns: [],
+        jsonPath: { column: "_meta_data", path: fieldName },
+        description: `JSON-path index for @meta({ indexed: true }) field ${fieldName}`
+      });
+    }
+    for (const colName of indexedStiColumns) {
+      indexes.push({
+        name: `${tableName}_${colName}_idx`,
+        columns: [colName],
+        description: `Index for ${colName}`
+      });
+    }
+    return {
+      tableName,
+      columns,
+      indexes,
+      triggers: [],
+      foreignKeys: this.extractForeignKeys(columns),
+      dependencies: [],
+      version: createHash("sha256").update(JSON.stringify({ columns, baseClassName, descendants })).digest("hex").substring(0, 8),
+      packageName: "runtime",
+      baseClass: "SmrtObject"
+    };
+  }
+  /**
+   * Generate STI schema from manifest data (build-time, no runtime registry)
+   *
+   * This method generates STI schema purely from manifest data, without depending
+   * on ObjectRegistry. This enables pre-generating schemas at build time for
+   * efficient external package consumption.
+   *
+   * @param baseClassName - Base class name for the STI hierarchy
+   * @param tableName - Shared table name (from base class)
+   * @param baseFields - Fields from the base class
+   * @param manifest - Full manifest containing all objects
+   * @returns ManifestSchema for storage in manifest.json
+   */
+  generateSTISchemaFromManifest(baseClassName, tableName, _baseFields, manifest, config) {
+    const columns = {};
+    columns.id = {
+      type: this.getIdColumnType(config),
+      primaryKey: true,
+      referenceKind: "id",
+      notNull: true
+    };
+    columns.slug = {
+      type: "TEXT",
+      notNull: true
+    };
+    columns.context = {
+      type: "TEXT",
+      notNull: true,
+      default: ""
+    };
+    columns._meta_type = {
+      type: "TEXT",
+      notNull: true
+    };
+    columns._meta_data = {
+      type: "JSON",
+      notNull: false
+    };
+    columns.created_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      default: "current_timestamp"
+    };
+    columns.updated_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      default: "current_timestamp"
+    };
+    const descendants = this.findDescendantsInManifest(baseClassName, manifest);
+    const allClassNames = [baseClassName, ...descendants];
+    const fkColumnsByClass = /* @__PURE__ */ new Map();
+    const indexedMetaFields = /* @__PURE__ */ new Set();
+    const indexedStiColumns = /* @__PURE__ */ new Set();
+    for (const className of allClassNames) {
+      const objDef = manifest.objects[className];
+      if (!objDef) continue;
+      fkColumnsByClass.set(className, /* @__PURE__ */ new Set());
+      for (const [fieldName, field] of Object.entries(objDef.fields)) {
+        if (field.transient || field._meta?.transient) {
+          continue;
+        }
+        if (field.type === "meta" && (field.indexed === true || field._meta?.indexed === true)) {
+          indexedMetaFields.add(fieldName);
+        }
+        if (fieldName === "id" || fieldName === "slug" || fieldName === "context" || fieldName === "created_at" || fieldName === "createdAt" || fieldName === "updated_at" || fieldName === "updatedAt") {
+          continue;
+        }
+        if (field.type === "oneToMany" || field.type === "manyToMany") {
+          continue;
+        }
+        if (field.type === "meta") {
+          continue;
+        }
+        const columnName = this.toSnakeCase(fieldName);
+        if (columns[columnName]) {
+          continue;
+        }
+        const sqlType = this.getRelationshipColumnType(field);
+        const columnDef = {
+          type: sqlType,
+          referenceKind: this.getReferenceKind(field),
+          // STI: All columns nullable (union of child fields)
+          notNull: false
+        };
+        if (field.default !== void 0 && this.shouldEmitDefault(field, field.default)) {
+          columnDef.default = field.default;
+        }
+        if (field.type === "foreignKey") {
+          fkColumnsByClass.get(className)?.add(columnName);
+        }
+        const isIndexed = field.indexed === true || field._meta?.indexed === true;
+        if (isIndexed && field.type !== "foreignKey") {
+          indexedStiColumns.add(columnName);
+        }
+        columns[columnName] = columnDef;
+      }
+    }
+    const indexes = [];
+    indexes.push({
+      name: `${tableName}_id_idx`,
+      columns: ["id"]
+    });
+    indexes.push({
+      name: `${tableName}_slug_context_meta_type_idx`,
+      columns: ["slug", "context", "_meta_type"],
+      unique: true
+    });
+    indexes.push({
+      name: `${tableName}_meta_type_idx`,
+      columns: ["_meta_type"]
+    });
+    for (const fieldName of indexedMetaFields) {
+      indexes.push({
+        name: `${tableName}_meta_${this.toSnakeCase(fieldName)}_idx`,
+        columns: [],
+        jsonPath: { column: "_meta_data", path: fieldName }
+      });
+    }
+    for (const colName of indexedStiColumns) {
+      indexes.push({
+        name: `${tableName}_${colName}_idx`,
+        columns: [colName]
+      });
+    }
+    const schemaDefinition = {
+      tableName,
+      columns: this.convertManifestColumnsToSchemaColumns(columns),
+      indexes: indexes.map((idx) => ({
+        name: idx.name,
+        columns: idx.columns,
+        unique: idx.unique,
+        where: idx.where,
+        jsonPath: idx.jsonPath
+      })),
+      triggers: [],
+      foreignKeys: [],
+      dependencies: [],
+      version: "",
+      packageName: ""
+    };
+    const ddl = this.generateSQL(schemaDefinition);
+    const version = createHash("sha256").update(JSON.stringify({ columns, baseClassName, descendants })).digest("hex").substring(0, 8);
+    return {
+      tableName,
+      ddl,
+      columns,
+      indexes,
+      version
+    };
+  }
+  /**
+   * Generate CTI (Class Table Inheritance) schema from manifest data
+   *
+   * @param className - Class name
+   * @param tableName - Table name
+   * @param fields - Fields from the class
+   * @returns ManifestSchema for storage in manifest.json
+   */
+  generateCTISchemaFromManifest(className, tableName, fields, config) {
+    const columns = {};
+    columns.id = {
+      type: this.getIdColumnType(config),
+      primaryKey: true,
+      referenceKind: "id",
+      notNull: true
+    };
+    columns.slug = {
+      type: "TEXT",
+      notNull: true
+    };
+    columns.context = {
+      type: "TEXT",
+      notNull: true,
+      default: ""
+    };
+    columns.created_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      default: "current_timestamp"
+    };
+    columns.updated_at = {
+      type: "TIMESTAMP",
+      notNull: true,
+      default: "current_timestamp"
+    };
+    for (const [fieldName, field] of Object.entries(fields)) {
+      if (field.transient || field._meta?.transient) {
+        continue;
+      }
+      if (fieldName === "id" || fieldName === "slug" || fieldName === "context" || fieldName === "created_at" || fieldName === "createdAt" || fieldName === "updated_at" || fieldName === "updatedAt") {
+        continue;
+      }
+      if (field.type === "oneToMany" || field.type === "manyToMany") {
+        continue;
+      }
+      if (field.type === "meta") {
+        continue;
+      }
+      const columnName = this.toSnakeCase(fieldName);
+      const sqlType = this.getRelationshipColumnType(field);
+      const columnDef = {
+        type: sqlType,
+        referenceKind: this.getReferenceKind(field),
+        notNull: field._meta?.nullable ? false : field.required || false,
+        unique: field._meta?.unique || false
+      };
+      if (field.default !== void 0 && this.shouldEmitDefault(field, field.default)) {
+        columnDef.default = field.default;
+      }
+      columns[columnName] = columnDef;
+    }
+    const indexes = [];
+    indexes.push({
+      name: `${tableName}_id_idx`,
+      columns: ["id"]
+    });
+    const conflictColumns = config?.conflictColumns || ["slug", "context"];
+    const indexName = conflictColumns.length > 2 ? `${tableName}_${conflictColumns.slice(0, 2).join("_")}_idx` : `${tableName}_${conflictColumns.join("_")}_idx`;
+    indexes.push({
+      name: indexName,
+      columns: conflictColumns,
+      unique: true
+    });
+    const schemaDefinition = {
+      tableName,
+      columns: this.convertManifestColumnsToSchemaColumns(columns),
+      indexes: indexes.map((idx) => ({
+        name: idx.name,
+        columns: idx.columns,
+        unique: idx.unique,
+        where: idx.where,
+        jsonPath: idx.jsonPath
+      })),
+      triggers: [],
+      foreignKeys: [],
+      dependencies: [],
+      version: "",
+      packageName: ""
+    };
+    const ddl = this.generateSQL(schemaDefinition);
+    const version = createHash("sha256").update(JSON.stringify({ columns, className })).digest("hex").substring(0, 8);
+    return {
+      tableName,
+      ddl,
+      columns,
+      indexes,
+      version
+    };
+  }
+  /**
+   * Find all descendants of a class in the manifest
+   *
+   * Note: Manifest keys are now qualified names (@pkg:ClassName) but `extends` field
+   * stores simple PascalCase class names. We need to handle both qualified and simple
+   * name lookups.
+   *
+   * Issue #713: Updated to handle qualified names in manifest keys
+   */
+  findDescendantsInManifest(baseClassName, manifest, visited = /* @__PURE__ */ new Set()) {
+    const descendants = [];
+    if (visited.has(baseClassName)) return descendants;
+    visited.add(baseClassName);
+    const simpleBaseClassName = baseClassName.includes(":") ? baseClassName.split(":").pop() || baseClassName : baseClassName;
+    const baseClassLower = simpleBaseClassName.toLowerCase();
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      if (obj.className.toLowerCase() === baseClassLower && obj.extends?.toLowerCase() === baseClassLower) {
+        continue;
+      }
+      if (obj.extends?.toLowerCase() === baseClassLower) {
+        descendants.push(name);
+        descendants.push(
+          ...this.findDescendantsInManifest(name, manifest, visited)
+        );
+      }
+    }
+    return descendants;
+  }
+  /**
+   * Convert ManifestColumnDefinition to ColumnDefinition
+   */
+  convertManifestColumnsToSchemaColumns(manifestColumns) {
+    const columns = {};
+    for (const [name, col] of Object.entries(manifestColumns)) {
+      columns[name] = {
+        type: col.type,
+        primaryKey: col.primaryKey,
+        referenceKind: col.referenceKind,
+        notNull: col.notNull,
+        unique: col.unique,
+        defaultValue: col.default
+      };
+    }
+    return columns;
+  }
+  /**
+   * Convert camelCase to snake_case
+   */
+  toSnakeCase(str) {
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  }
+  /**
+   * Generate SQL CREATE TABLE statement from schema definition
+   *
+   * This is the single source of truth for SQL generation, consolidating
+   * logic that was previously duplicated across multiple code paths.
+   *
+   * @param schema - Schema definition object
+   * @returns SQL CREATE TABLE statement with indexes
+   */
+  generateSQL(schema, engine) {
+    if (engine) {
+      return getDDLStrategy(engine).generateCreateTable(schema);
+    }
+    const { tableName, columns } = schema;
+    let sql = `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(tableName)} (
+`;
+    for (const [columnName, columnDef] of Object.entries(columns)) {
+      const parts = [`  ${quoteIdentifier(columnName)} ${columnDef.type}`];
+      if (columnDef.primaryKey) {
+        parts.push("PRIMARY KEY");
+      }
+      if (columnDef.notNull) {
+        parts.push("NOT NULL");
+      }
+      if (columnDef.unique && !columnDef.primaryKey) {
+        parts.push("UNIQUE");
+      }
+      if (columnDef.defaultValue !== void 0) {
+        parts.push(
+          `DEFAULT ${this.formatDefaultValue(
+            columnDef.defaultValue,
+            columnDef.type
+          )}`
+        );
+      }
+      sql += `${parts.join(" ")},
+`;
+    }
+    return `${sql.slice(0, -2)}
+);`;
+  }
+  /**
+   * Format default value for SQL
+   *
+   * SQLite doesn't support CAST expressions in DEFAULT values (only literal values are allowed).
+   * This method generates DEFAULT values that work with both SQLite and DuckDB.
+   *
+   * @param value - Default value
+   * @param type - Column SQL type
+   * @returns Formatted SQL default value expression
+   */
+  formatDefaultValue(value, type) {
+    return formatDefaultValue(value, type, {
+      nonStringTimestampDefault: "current_timestamp"
+    });
+  }
+}
+export {
+  SchemaGenerator
+};
+//# sourceMappingURL=generator.js.map