@fragno-dev/db 0.2.2 → 0.4.1

package/src/{adapters/drizzle/generate.ts → schema-output/drizzle.ts}

@@ -1,20 +1,25 @@
-import { importGenerator } from "../../util/import-generator";
-import { ident, parseVarchar } from "../../util/parse";
+import {
+  defaultNamingStrategyForDatabase,
+  type SupportedDatabase,
+} from "../adapters/generic-sql/driver-config";
+import { internalSchema } from "../fragments/internal-fragment.schema";
+import {
+  createNamingResolver,
+  sanitizeNamespace,
+  type NamingResolver,
+  type SqlNamingStrategy,
+} from "../naming/sql-naming";
 import {
   type AnyColumn,
   type AnySchema,
   type AnyTable,
   type Relation,
   InternalIdColumn,
-} from "../../schema/create";
-import type { SQLProvider } from "../../shared/providers";
-import {
-  createTableNameMapper,
-  sanitizeNamespace,
-  type TableNameMapper,
-} from "../shared/table-name-mapper";
-import { type DatabaseTypeLiteral } from "../../schema/type-conversion/type-mapping";
-import { createSQLTypeMapper } from "../../schema/type-conversion/create-sql-type-mapper";
+} from "../schema/create";
+import { createSQLTypeMapper } from "../schema/type-conversion/create-sql-type-mapper";
+import { type DatabaseTypeLiteral } from "../schema/type-conversion/type-mapping";
+import { importGenerator } from "../util/import-generator";
+import { ident, parseVarchar } from "../util/parse";
 
 // ============================================================================
 // PROVIDER CONFIGURATION
@@ -32,7 +37,7 @@ const PROVIDER_TABLE_FUNCTIONS = {
   sqlite: "sqliteTable",
 } as const;
 
-export type SupportedProvider = Exclude<SQLProvider, "cockroachdb" | "mssql">;
+export type SupportedProvider = SupportedDatabase;
 
 // ============================================================================
 // CONTEXT
@@ -47,7 +52,7 @@ interface GeneratorContext {
 }
 
 function createContext(
-  provider: SupportedProvider,
+  provider: SupportedDatabase,
   idGeneratorImport?: { name: string; from: string },
 ): GeneratorContext {
   return {
@@ -224,7 +229,7 @@ function mapDBTypeToDrizzleFunction(
       case "text":
         // Check if it's JSON
         if (column.type === "json") {
-          return { name: "blob", params: [`{ mode: "json" }`] };
+          return { name: "text", params: [`{ mode: "json" }`] };
         }
         return { name: "text" };
       case "real":
@@ -243,17 +248,10 @@ function mapDBTypeToDrizzleFunction(
 // ============================================================================
 
 /**
- * Get the physical table name (with namespace suffix) using the mapper if available
+ * Get the physical table name using the naming resolver if available
  */
-function getPhysicalTableName(
-  logicalName: string,
-  namespace: string | undefined,
-  mapper: TableNameMapper | undefined,
-): string {
-  if (!namespace) {
-    return logicalName;
-  }
-  return mapper ? mapper.toPhysical(logicalName) : `${logicalName}_${sanitizeNamespace(namespace)}`;
+function getPhysicalTableName(logicalName: string, resolver?: NamingResolver): string {
+  return resolver ? resolver.getTableName(logicalName) : logicalName;
 }
 
 // ============================================================================
@@ -264,12 +262,13 @@ function generateColumnDefinition(
   ctx: GeneratorContext,
   column: AnyColumn,
   customTypes: string[],
+  physicalColumnName: string,
 ): string {
   const parts: string[] = [];
   const typeFn = getColumnTypeFunction(ctx, column, customTypes);
 
   // Column type with parameters
-  const params: string[] = [`"${column.name}"`, ...(typeFn.params ?? [])];
+  const params: string[] = [`"${physicalColumnName}"`, ...(typeFn.params ?? [])];
   if (!typeFn.isCustomType) {
     ctx.imports.addImport(typeFn.name, ctx.importSource);
   }
@@ -295,6 +294,11 @@ function generateColumnDefinition(
     parts.push("notNull()");
   }
 
+  // External IDs are unique by definition in Fragno's SQL migrations.
+  if (column.role === "external-id") {
+    parts.push("unique()");
+  }
+
   // Default values
   if (column.default) {
     if ("value" in column.default) {
@@ -310,7 +314,12 @@ function generateColumnDefinition(
     } else if ("dbSpecial" in column.default) {
       // Database-level special functions: defaultTo(b => b.now())
       if (column.default.dbSpecial === "now") {
-        parts.push("defaultNow()");
+        if (ctx.provider === "mysql") {
+          ctx.imports.addImport("sql", "drizzle-orm");
+          parts.push("default(sql`(now())`)");
+        } else {
+          parts.push("defaultNow()");
+        }
       }
     } else if ("runtime" in column.default) {
       // Runtime defaults: defaultTo$()
@@ -326,16 +335,22 @@ function generateColumnDefinition(
     }
   }
 
-  return `  ${column.ormName}: ${parts.join(".")}`;
+  return `  ${column.name}: ${parts.join(".")}`;
 }
 
 function generateAllColumns(
   ctx: GeneratorContext,
   table: AnyTable,
   customTypes: string[],
+  resolver?: NamingResolver,
 ): string[] {
   return Object.values(table.columns).map((column) =>
-    generateColumnDefinition(ctx, column, customTypes),
+    generateColumnDefinition(
+      ctx,
+      column,
+      customTypes,
+      resolver ? resolver.getColumnName(table.name, column.name) : column.name,
+    ),
   );
 }
 
@@ -346,44 +361,47 @@ function generateAllColumns(
 function generateForeignKeys(
   ctx: GeneratorContext,
   table: AnyTable,
-  namespace?: string,
-  mapper?: TableNameMapper,
+  namespace?: string | null,
+  resolver?: NamingResolver,
 ): string[] {
   const keys: string[] = [];
 
   for (const relation of Object.values(table.relations)) {
     // Only "one" relations generate foreign keys
     // "many" relations don't have foreign keys (they're on the other side)
-    if (relation.type === "many") {
+    if (relation.type === "many" || relation.foreignKey === false) {
       continue;
     }
 
     const columns: string[] = [];
     const foreignColumns: string[] = [];
-    const isSelfReference = relation.table.ormName === table.ormName;
+    const isSelfReference = relation.table.name === table.name;
 
     for (const [localCol, refCol] of relation.on) {
       columns.push(`table.${localCol}`);
       // Foreign keys always reference internal IDs
-      const actualRefCol = refCol === "id" ? "_internalId" : refCol;
+      const actualRefCol = refCol !== "id" ? refCol : "_internalId";
       // For self-referencing foreign keys, use table parameter instead of table constant
       if (isSelfReference) {
         foreignColumns.push(`table.${actualRefCol}`);
       } else {
         // Use sanitized TypeScript export name for identifier reference
         const foreignTableRef = namespace
-          ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
-          : relation.table.ormName;
+          ? `${relation.table.name}_${sanitizeNamespace(namespace)}`
+          : relation.table.name;
         foreignColumns.push(`${foreignTableRef}.${actualRefCol}`);
       }
     }
 
     ctx.imports.addImport("foreignKey", ctx.importSource);
     // Include namespace in FK name to avoid collisions
-    const fkName =
-      namespace && mapper
-        ? "fk_" + mapper.toPhysical(`${table.ormName}_${relation.table.ormName}_${relation.name}`)
-        : `${table.ormName}_${relation.table.ormName}_${relation.name}_fk`;
+    const fkName = resolver
+      ? resolver.getForeignKeyName({
+          logicalTable: table.name,
+          logicalReferencedTable: relation.table.name,
+          referenceName: relation.name,
+        })
+      : `${table.name}_${relation.table.name}_${relation.name}_fk`;
 
     keys.push(`foreignKey({
   columns: [${columns.join(", ")}],
@@ -395,14 +413,24 @@ function generateForeignKeys(
   return keys;
 }
 
-function generateIndexes(ctx: GeneratorContext, table: AnyTable, namespace?: string): string[] {
+function generateIndexes(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  namespace?: string | null,
+  resolver?: NamingResolver,
+): string[] {
   const indexes: string[] = [];
 
   for (const idx of Object.values(table.indexes)) {
-    const columns = idx.columns.map((col) => `table.${col.ormName}`).join(", ");
+    const columns = idx.columns.map((col) => `table.${col.name}`).join(", ");
 
-    // Include namespace in index name to avoid collisions
-    const indexName = namespace ? `${idx.name}_${namespace}` : idx.name;
+    const indexName = resolver
+      ? idx.unique
+        ? resolver.getUniqueIndexName(idx.name, table.name)
+        : resolver.getIndexName(idx.name, table.name)
+      : namespace
+        ? `${idx.name}_${namespace}`
+        : idx.name;
 
     if (idx.unique) {
       ctx.imports.addImport("uniqueIndex", ctx.importSource);
@@ -419,13 +447,30 @@ function generateIndexes(ctx: GeneratorContext, table: AnyTable, namespace?: str
 function generateTableConstraints(
   ctx: GeneratorContext,
   table: AnyTable,
-  namespace?: string,
-  mapper?: TableNameMapper,
+  namespace?: string | null,
+  resolver?: NamingResolver,
 ): string[] {
-  return [
-    ...generateForeignKeys(ctx, table, namespace, mapper),
-    ...generateIndexes(ctx, table, namespace),
+  const constraints: string[] = [
+    ...generateForeignKeys(ctx, table, namespace, resolver),
+    ...generateIndexes(ctx, table, namespace, resolver),
   ];
+
+  if (ctx.provider === "sqlite") {
+    const externalIdColumn = Object.values(table.columns).find(
+      (column) => column.role === "external-id",
+    );
+    if (externalIdColumn) {
+      const indexName = resolver
+        ? resolver.getUniqueIndexName(`idx_${table.name}_external_id`, table.name)
+        : namespace
+          ? `idx_${table.name}_external_id_${namespace}`
+          : `idx_${table.name}_external_id`;
+      ctx.imports.addImport("uniqueIndex", ctx.importSource);
+      constraints.push(`uniqueIndex("${indexName}").on(table.${externalIdColumn.name})`);
+    }
+  }
+
+  return constraints;
 }
 
 // ============================================================================
@@ -436,19 +481,22 @@ function generateTable(
   ctx: GeneratorContext,
   table: AnyTable,
   customTypes: string[],
-  namespace?: string,
-  mapper?: TableNameMapper,
+  namespace?: string | null,
+  resolver?: NamingResolver,
+  schemaRef?: string,
 ): string {
-  const tableFn = PROVIDER_TABLE_FUNCTIONS[ctx.provider];
-  ctx.imports.addImport(tableFn, ctx.importSource);
+  const tableFn = schemaRef ? `${schemaRef}.table` : PROVIDER_TABLE_FUNCTIONS[ctx.provider];
+  if (!schemaRef) {
+    ctx.imports.addImport(tableFn, ctx.importSource);
+  }
 
-  const columns = generateAllColumns(ctx, table, customTypes);
-  const constraints = generateTableConstraints(ctx, table, namespace, mapper);
+  const columns = generateAllColumns(ctx, table, customTypes, resolver);
+  const constraints = generateTableConstraints(ctx, table, namespace, resolver);
 
   // Physical table name in the database (respects mapper configuration)
-  const physicalTableName = getPhysicalTableName(table.ormName, namespace, mapper);
+  const physicalTableName = getPhysicalTableName(table.name, resolver);
   // TypeScript export name must always be sanitized to be a valid JavaScript identifier
-  const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+  const exportName = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
 
   const args: string[] = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 
@@ -466,9 +514,9 @@ function generateTable(
 function generateRelation(
   ctx: GeneratorContext,
   table: AnyTable,
-  namespace?: string,
+  namespace?: string | null,
   inverseRelations?: Array<{ fromTable: AnyTable; relation: Relation }>,
-  _mapper?: TableNameMapper,
+  _resolver?: NamingResolver,
 ): string | undefined {
   const relations: string[] = [];
   let hasOne = false;
@@ -476,6 +524,9 @@ function generateRelation(
 
   // Generate explicit relations defined on this table
   for (const relation of Object.values(table.relations)) {
+    if (relation.foreignKey === false) {
+      continue;
+    }
     const options: string[] = [`relationName: "${relation.id}"`];
 
     // Track which relation types are used
@@ -491,17 +542,15 @@ function generateRelation(
       const references: string[] = [];
 
       // Use sanitized TypeScript export names for identifier references
-      const tableRef = namespace
-        ? `${table.ormName}_${sanitizeNamespace(namespace)}`
-        : table.ormName;
+      const tableRef = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
       const relatedTableRef = namespace
-        ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
-        : relation.table.ormName;
+        ? `${relation.table.name}_${sanitizeNamespace(namespace)}`
+        : relation.table.name;
 
       for (const [left, right] of relation.on) {
         fields.push(`${tableRef}.${left}`);
         // Relations reference internal IDs
-        const actualRight = right === "id" ? "_internalId" : right;
+        const actualRight = right !== "id" ? right : "_internalId";
         references.push(`${relatedTableRef}.${actualRight}`);
       }
 
@@ -509,8 +558,8 @@ function generateRelation(
     }
 
     const relatedTableRef = namespace
-      ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
-      : relation.table.ormName;
+      ? `${relation.table.name}_${sanitizeNamespace(namespace)}`
+      : relation.table.name;
 
     const args: string[] = [relatedTableRef];
     if (options.length > 0) {
@@ -525,17 +574,17 @@ function generateRelation(
   if (inverseRelations && inverseRelations.length > 0) {
     for (const { fromTable, relation } of inverseRelations) {
       // Only generate inverse for "one" relations (they become "many" on this side)
-      if (relation.type === "one") {
+      if (relation.type === "one" && relation.foreignKey !== false) {
         hasMany = true;
 
         // Use sanitized TypeScript export name for identifier reference
         const fromTableRef = namespace
-          ? `${fromTable.ormName}_${sanitizeNamespace(namespace)}`
-          : fromTable.ormName;
+          ? `${fromTable.name}_${sanitizeNamespace(namespace)}`
+          : fromTable.name;
 
         // Generate inverse relation name with consistent suffix
         // e.g., if session has "sessionOwner" relation to user, user gets "sessionList" inverse relation
-        const inverseRelationName = `${fromTable.ormName}List`;
+        const inverseRelationName = `${fromTable.name}List`;
 
         const options: string[] = [`relationName: "${relation.id}"`];
         const args: string[] = [fromTableRef, `{\n${ident(options.join(",\n"))}\n}`];
@@ -560,10 +609,8 @@ function generateRelation(
   const relationParams = params.length > 0 ? `{ ${params.join(", ")} }` : "{}";
 
   // Use sanitized names for TypeScript export identifiers
-  const exportTableRef = namespace
-    ? `${table.ormName}_${sanitizeNamespace(namespace)}`
-    : table.ormName;
-  const relationsName = namespace ? `${exportTableRef}Relations` : `${table.ormName}Relations`;
+  const exportTableRef = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
+  const relationsName = namespace ? `${exportTableRef}Relations` : `${table.name}Relations`;
 
   ctx.imports.addImport("relations", "drizzle-orm");
   return `export const ${relationsName} = relations(${exportTableRef}, (${relationParams}) => ({
@@ -581,24 +628,22 @@ ${relations.join(",\n")}
  */
 function generateFragmentSchemaExport(
   schema: AnySchema,
-  namespace: string,
+  namespace: string | null,
   tablesWithRelations?: Set<string>,
-  _mapper?: TableNameMapper,
+  _resolver?: NamingResolver,
 ): string {
   const drizzleEntries: string[] = [];
 
   for (const table of Object.values(schema.tables)) {
     // TypeScript export name (always sanitized for valid JS identifiers)
-    const exportName = namespace
-      ? `${table.ormName}_${sanitizeNamespace(namespace)}`
-      : table.ormName;
+    const exportName = namespace ? `${table.name}_${sanitizeNamespace(namespace)}` : table.name;
 
     // Add physical table name to drizzle schema
     drizzleEntries.push(`  ${exportName}: ${exportName}`);
 
     // Include relations for this table if they exist (either explicit or inverse)
     if (tablesWithRelations?.has(table.name)) {
-      const relationsName = namespace ? `${exportName}Relations` : `${table.ormName}Relations`;
+      const relationsName = namespace ? `${exportName}Relations` : `${table.name}Relations`;
 
       drizzleEntries.push(`  ${relationsName}: ${relationsName}`);
     }
@@ -607,12 +652,12 @@ function generateFragmentSchemaExport(
     // The key insight: Drizzle needs BOTH the table alias AND its relations alias
     // in the same schema object for relational queries to work
     if (namespace) {
-      drizzleEntries.push(`  ${table.ormName}: ${exportName}`);
+      drizzleEntries.push(`  ${table.name}: ${exportName}`);
 
       // Also add the relations under the aliased name if they exist
       if (tablesWithRelations?.has(table.name)) {
         const physicalRelationsName = `${exportName}Relations`;
-        const aliasRelationsName = `${table.ormName}Relations`;
+        const aliasRelationsName = `${table.name}Relations`;
         drizzleEntries.push(`  ${aliasRelationsName}: ${physicalRelationsName}`);
       }
     }
@@ -639,8 +684,8 @@ export interface GenerateSchemaOptions {
     /** Module to import from */
     from: string;
   };
-  /** Optional mapper factory for creating table name mappers with custom sanitization */
-  mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined;
+  /** Optional naming strategy override for physical names */
+  namingStrategy?: SqlNamingStrategy;
 }
 
 /**
@@ -649,35 +694,45 @@ export interface GenerateSchemaOptions {
 /**
  * Generate a schema file from one or more fragments with automatic de-duplication
  */
-export function generateSchema(
-  fragments: { namespace: string; schema: AnySchema }[],
-  provider: SupportedProvider,
+export function generateDrizzleSchema(
+  fragments: { namespace: string | null; schema: AnySchema }[],
+  provider: SupportedDatabase,
   options?: GenerateSchemaOptions,
 ): string {
   const ctx = createContext(provider, options?.idGeneratorImport);
   const customTypes: string[] = [];
   const sections: string[] = [];
-  const getMapper =
-    options?.mapperFactory ||
-    ((ns: string | undefined) => (ns ? createTableNameMapper(ns, true) : undefined));
+  const namingStrategy = options?.namingStrategy ?? defaultNamingStrategyForDatabase(provider);
 
   for (const { schema, namespace } of fragments) {
     const fragmentTables: string[] = [];
-    const mapper = getMapper(namespace);
+    const resolver = createNamingResolver(schema, namespace, namingStrategy);
+    const schemaName = resolver.getSchemaName();
+    const schemaRef =
+      ctx.provider === "postgresql" && schemaName
+        ? `schema_${sanitizeNamespace(schemaName)}`
+        : undefined;
 
     // Add section header
     fragmentTables.push("");
     fragmentTables.push(
       "// ============================================================================",
     );
-    fragmentTables.push(`// Fragment: ${namespace}`);
+    const namespaceLabel = namespace ?? "(none)";
+    fragmentTables.push(`// Fragment: ${namespaceLabel}`);
     fragmentTables.push(
       "// ============================================================================",
     );
 
+    if (schemaRef && schemaName) {
+      ctx.imports.addImport("pgSchema", ctx.importSource);
+      fragmentTables.push("");
+      fragmentTables.push(`const ${schemaRef} = pgSchema("${schemaName}");`);
+    }
+
     // Generate tables for this fragment
     for (const table of Object.values(schema.tables)) {
-      const tableCode = generateTable(ctx, table, customTypes, namespace, mapper);
+      const tableCode = generateTable(ctx, table, customTypes, namespace, resolver, schemaRef);
       fragmentTables.push("");
       fragmentTables.push(tableCode);
     }
@@ -687,6 +742,9 @@ export function generateSchema(
     const inverseRelations = new Map<string, Array<{ fromTable: AnyTable; relation: Relation }>>();
     for (const table of Object.values(schema.tables)) {
       for (const relation of Object.values(table.relations)) {
+        if (relation.foreignKey === false) {
+          continue;
+        }
         // Track this relation as an inverse on the target table
         const targetTableName = relation.table.name;
         if (!inverseRelations.has(targetTableName)) {
@@ -704,7 +762,7 @@ export function generateSchema(
         table,
         namespace,
         inverseRelations.get(table.name),
-        mapper,
+        resolver,
       );
       if (relationCode) {
         fragmentTables.push("");
@@ -713,12 +771,10 @@ export function generateSchema(
       }
     }
 
-    // Generate schema export object (skip for empty namespace to avoid duplicate _schema exports)
-    if (namespace !== "") {
+    // Generate schema export object (skip for internal fragment to avoid duplicate _schema exports)
+    if (!(namespace === null && schema.name === internalSchema.name)) {
       fragmentTables.push("");
-      fragmentTables.push(
-        generateFragmentSchemaExport(schema, namespace, tablesWithRelations, mapper),
-      );
+      fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
     }
 
     sections.push(...fragmentTables);