@prisma-next/sql-contract-emitter 0.3.0-pr.99.6 → 0.3.0

package/src/index.ts

@@ -1,54 +1,38 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
+import type { Contract, ContractModel } from '@prisma-next/contract/types';
+import {
+  generateCodecTypeIntersection,
+  serializeObjectKey,
+  serializeValue,
+} from '@prisma-next/emitter/domain-type-generation';
 import type {
   GenerateContractTypesOptions,
-  TypeRenderContext,
-  TypeRenderEntry,
-  TypesImportSpec,
   ValidationContext,
-} from '@prisma-next/contract/types';
-import type {
-  ModelDefinition,
-  ModelField,
-  SqlStorage,
-  StorageColumn,
-  StorageTable,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+} from '@prisma-next/framework-components/emission';
+import type { SqlModelStorage, SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
 import { assertDefined } from '@prisma-next/utils/assertions';
 
-/**
- * Resolves the typeParams for a column, either from inline typeParams or from typeRef.
- * Returns undefined if no typeParams are available.
- */
-function resolveColumnTypeParams(
-  column: StorageColumn,
-  storage: SqlStorage,
-): Record<string, unknown> | undefined {
-  // Inline typeParams take precedence
-  if (column.typeParams && Object.keys(column.typeParams).length > 0) {
-    return column.typeParams;
+function serializeTypeParamsLiteral(params: Record<string, unknown> | undefined): string {
+  if (!params || Object.keys(params).length === 0) {
+    return 'Record<string, never>';
   }
-  // Check typeRef
-  if (column.typeRef && storage.types) {
-    const typeInstance = storage.types[column.typeRef] as StorageTypeInstance | undefined;
-    if (typeInstance?.typeParams) {
-      return typeInstance.typeParams;
-    }
+
+  const entries: string[] = [];
+  for (const [key, value] of Object.entries(params)) {
+    entries.push(`readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`);
   }
-  return undefined;
+
+  return `{ ${entries.join('; ')} }`;
 }
 
-export const sqlTargetFamilyHook = {
+export const sqlEmission = {
   id: 'sql',
 
-  validateTypes(ir: ContractIR, _ctx: ValidationContext): void {
-    const storage = ir.storage as SqlStorage | undefined;
+  validateTypes(contract: Contract, _ctx: ValidationContext): void {
+    const storage = contract.storage as unknown as SqlStorage | undefined;
     if (!storage || !storage.tables) {
       return;
     }
 
-    // Validate codec ID format (ns/name@version). Adapter-provided codecs are available regardless of contract.extensionPacks (which is for framework extensions); TypeScript prevents invalid usage and runtime validates availability.
-
     const typeIdRegex = /^([^/]+)\/([^@]+)@(\d+)$/;
 
     for (const [tableName, tableUnknown] of Object.entries(storage.tables)) {
@@ -70,22 +54,21 @@ export const sqlTargetFamilyHook = {
     }
   },
 
-  validateStructure(ir: ContractIR): void {
-    if (ir.targetFamily !== 'sql') {
-      throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
+  validateStructure(contract: Contract): void {
+    if (contract.targetFamily !== 'sql') {
+      throw new Error(`Expected targetFamily "sql", got "${contract.targetFamily}"`);
     }
 
-    const storage = ir.storage as SqlStorage | undefined;
+    const storage = contract.storage as unknown as SqlStorage | undefined;
     if (!storage || !storage.tables) {
       throw new Error('SQL contract must have storage.tables');
     }
 
-    const models = ir.models as Record<string, ModelDefinition> | undefined;
+    const models = contract.models as Record<string, ContractModel<SqlModelStorage>>;
     const tableNames = new Set(Object.keys(storage.tables));
 
     if (models) {
-      for (const [modelName, modelUnknown] of Object.entries(models)) {
-        const model = modelUnknown as ModelDefinition;
+      for (const [modelName, model] of Object.entries(models)) {
         if (!model.storage?.table) {
           throw new Error(`Model "${modelName}" is missing storage.table`);
         }
@@ -103,12 +86,12 @@ export const sqlTargetFamilyHook = {
         }
 
         const columnNames = new Set(Object.keys(table.columns));
-        if (!model.fields || Object.keys(model.fields).length === 0) {
-          throw new Error(`Model "${modelName}" is missing fields`);
+        const storageFields = model.storage.fields;
+        if (!storageFields || Object.keys(storageFields).length === 0) {
+          throw new Error(`Model "${modelName}" is missing storage.fields`);
         }
 
-        for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {
-          const field = fieldUnknown as ModelField;
+        for (const [fieldName, field] of Object.entries(storageFields)) {
           if (!field.column) {
             throw new Error(`Model "${modelName}" field "${fieldName}" is missing column property`);
           }
@@ -132,10 +115,6 @@ export const sqlTargetFamilyHook = {
       const table = tableUnknown as StorageTable;
       const columnNames = new Set(Object.keys(table.columns));
 
-      // Column structure (nullable, nativeType, codecId) and table arrays (uniques, indexes, foreignKeys)
-      // are validated by Arktype schema validation - no need to re-check here.
-      // We only validate logical consistency (foreign key references, model references, etc.)
-
       if (!Array.isArray(table.uniques)) {
         throw new Error(
           `Table "${tableName}" is missing required field "uniques" (must be an array)`,
@@ -197,7 +176,6 @@ export const sqlTargetFamilyHook = {
           );
         }
 
-        // Table existence guaranteed by Set.has() check above
         const referencedTable: StorageTable | undefined = storage.tables[fk.references.table];
         assertDefined(
           referencedTable,
@@ -222,109 +200,50 @@ export const sqlTargetFamilyHook = {
     }
   },
 
-  generateContractTypes(
-    ir: ContractIR,
-    codecTypeImports: ReadonlyArray<TypesImportSpec>,
-    operationTypeImports: ReadonlyArray<TypesImportSpec>,
-    options?: GenerateContractTypesOptions,
-  ): string {
-    const parameterizedRenderers = options?.parameterizedRenderers;
-    const parameterizedTypeImports = options?.parameterizedTypeImports;
-    const storage = ir.storage as SqlStorage;
-    const models = ir.models as Record<string, ModelDefinition>;
-
-    // Collect all type imports from three sources:
-    // 1. Codec type imports (from adapters, targets, and extensions)
-    // 2. Operation type imports (from adapters, targets, and extensions)
-    // 3. Parameterized type imports (for parameterized codec renderers, may contain duplicates)
-    const allImports: TypesImportSpec[] = [...codecTypeImports, ...operationTypeImports];
-
-    if (parameterizedTypeImports) {
-      allImports.push(...parameterizedTypeImports);
-    }
-
-    // Deduplicate imports by package+named to avoid duplicate import statements.
-    // Strategy: When the same package::named appears multiple times, keep the first
-    // occurrence (and its alias); later duplicates with different aliases are silently ignored.
-    //
-    // Note: uniqueImports must be an array (not a Set) because:
-    // - We need to preserve the full TypesImportSpec objects (package, named, alias)
-    // - We need to preserve insertion order (first occurrence wins)
-    // - seenImportKeys is a Set used only for O(1) duplicate detection
-    const seenImportKeys = new Set<string>();
-    const uniqueImports: TypesImportSpec[] = [];
-    for (const imp of allImports) {
-      const key = `${imp.package}::${imp.named}`;
-      if (!seenImportKeys.has(key)) {
-        seenImportKeys.add(key);
-        uniqueImports.push(imp);
-      }
-    }
-
-    // Generate import statements, omitting redundant "as Alias" when named === alias
-    const importLines = uniqueImports.map((imp) => {
-      // Simplify import when named === alias (e.g., `import type { Vector }` instead of `{ Vector as Vector }`)
-      const importClause = imp.named === imp.alias ? imp.named : `${imp.named} as ${imp.alias}`;
-      return `import type { ${importClause} } from '${imp.package}';`;
-    });
-
-    const codecTypes = codecTypeImports.map((imp) => imp.alias).join(' & ');
-    const operationTypes = operationTypeImports.map((imp) => imp.alias).join(' & ');
-
-    const storageType = this.generateStorageType(storage);
-    const modelsType = this.generateModelsType(models, storage, parameterizedRenderers);
-    const relationsType = this.generateRelationsType(ir.relations);
-    const mappingsType = this.generateMappingsType(models, storage, codecTypes, operationTypes);
-
-    return `// ⚠️  GENERATED FILE - DO NOT EDIT
-  // This file is automatically generated by 'prisma-next contract emit'.
-  // To regenerate, run: prisma-next contract emit
-  ${importLines.join('\n')}
-
-  import type { SqlContract, SqlStorage, SqlMappings, ModelDefinition } from '@prisma-next/sql-contract/types';
-
-  export type CodecTypes = ${codecTypes || 'Record<string, never>'};
-  export type LaneCodecTypes = CodecTypes;
-  export type OperationTypes = ${operationTypes || 'Record<string, never>'};
-
-  export type Contract = SqlContract<
-  ${storageType},
-  ${modelsType},
-  ${relationsType},
-  ${mappingsType}
-  >;
-
-  export type Tables = Contract['storage']['tables'];
-  export type Models = Contract['models'];
-  export type Relations = Contract['relations'];
-  `;
-  },
-
-  generateStorageType(storage: SqlStorage): string {
+  generateStorageType(contract: Contract, storageHashTypeName: string): string {
+    const storage = contract.storage as unknown as SqlStorage;
     const tables: string[] = [];
-    for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const [tableName, table] of Object.entries(storage.tables).sort(([a], [b]) =>
+      a.localeCompare(b),
+    )) {
       const columns: string[] = [];
       for (const [colName, col] of Object.entries(table.columns)) {
         const nullable = col.nullable ? 'true' : 'false';
-        const nativeType = `'${col.nativeType}'`;
-        const codecId = `'${col.codecId}'`;
+        const nativeType = serializeValue(col.nativeType);
+        const codecId = serializeValue(col.codecId);
+        const defaultSpec = col.default
+          ? col.default.kind === 'literal'
+            ? `; readonly default: { readonly kind: 'literal'; readonly value: DefaultLiteralValue<${codecId}, ${serializeValue(
+                col.default.value,
+              )}> }`
+            : `; readonly default: { readonly kind: 'function'; readonly expression: ${serializeValue(
+                col.default.expression,
+              )} }`
+          : '';
+        const typeParamsSpec =
+          col.typeParams && Object.keys(col.typeParams).length > 0
+            ? `; readonly typeParams: ${serializeTypeParamsLiteral(col.typeParams)}`
+            : '';
+        const typeRefSpec = col.typeRef ? `; readonly typeRef: ${serializeValue(col.typeRef)}` : '';
         columns.push(
-          `readonly ${colName}: { readonly nativeType: ${nativeType}; readonly codecId: ${codecId}; readonly nullable: ${nullable} }`,
+          `readonly ${colName}: { readonly nativeType: ${nativeType}; readonly codecId: ${codecId}; readonly nullable: ${nullable}${defaultSpec}${typeParamsSpec}${typeRefSpec} }`,
         );
       }
 
       const tableParts: string[] = [`columns: { ${columns.join('; ')} }`];
 
       if (table.primaryKey) {
-        const pkCols = table.primaryKey.columns.map((c) => `'${c}'`).join(', ');
-        const pkName = table.primaryKey.name ? `; readonly name: '${table.primaryKey.name}'` : '';
+        const pkCols = table.primaryKey.columns.map((c) => serializeValue(c)).join(', ');
+        const pkName = table.primaryKey.name
+          ? `; readonly name: ${serializeValue(table.primaryKey.name)}`
+          : '';
         tableParts.push(`primaryKey: { readonly columns: readonly [${pkCols}]${pkName} }`);
       }
 
       const uniques = table.uniques
         .map((u) => {
-          const cols = u.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = u.name ? `; readonly name: '${u.name}'` : '';
+          const cols = u.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = u.name ? `; readonly name: ${serializeValue(u.name)}` : '';
           return `{ readonly columns: readonly [${cols}]${name} }`;
         })
         .join(', ');
@@ -332,19 +251,22 @@ export const sqlTargetFamilyHook = {
 
       const indexes = table.indexes
         .map((i) => {
-          const cols = i.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = i.name ? `; readonly name: '${i.name}'` : '';
-          return `{ readonly columns: readonly [${cols}]${name} }`;
+          const cols = i.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = i.name ? `; readonly name: ${serializeValue(i.name)}` : '';
+          const using = i.using !== undefined ? `; readonly using: ${serializeValue(i.using)}` : '';
+          const config =
+            i.config !== undefined ? `; readonly config: ${serializeValue(i.config)}` : '';
+          return `{ readonly columns: readonly [${cols}]${name}${using}${config} }`;
         })
         .join(', ');
       tableParts.push(`indexes: readonly [${indexes}]`);
 
       const fks = table.foreignKeys
         .map((fk) => {
-          const cols = fk.columns.map((c: string) => `'${c}'`).join(', ');
-          const refCols = fk.references.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = fk.name ? `; readonly name: '${fk.name}'` : '';
-          return `{ readonly columns: readonly [${cols}]; readonly references: { readonly table: '${fk.references.table}'; readonly columns: readonly [${refCols}] }${name} }`;
+          const cols = fk.columns.map((c: string) => serializeValue(c)).join(', ');
+          const refCols = fk.references.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = fk.name ? `; readonly name: ${serializeValue(fk.name)}` : '';
+          return `{ readonly columns: readonly [${cols}]; readonly references: { readonly table: ${serializeValue(fk.references.table)}; readonly columns: readonly [${refCols}] }${name}; readonly constraint: ${fk.constraint}; readonly index: ${fk.index} }`;
         })
         .join(', ');
       tableParts.push(`foreignKeys: readonly [${fks}]`);
@@ -352,296 +274,84 @@ export const sqlTargetFamilyHook = {
       tables.push(`readonly ${tableName}: { ${tableParts.join('; ')} }`);
     }
 
-    const typesType = this.generateStorageTypesType(storage.types);
+    const typesType = generateStorageTypesType(storage.types);
 
-    return `{ readonly tables: { ${tables.join('; ')} }; readonly types: ${typesType} }`;
+    return `{ readonly tables: { ${tables.join('; ')} }; readonly types: ${typesType}; readonly storageHash: ${storageHashTypeName} }`;
   },
 
-  /**
-   * Generates the TypeScript type for storage.types with literal types.
-   * This preserves type params as literal values for precise typing.
-   */
-  generateStorageTypesType(types: SqlStorage['types']): string {
-    if (!types || Object.keys(types).length === 0) {
-      return 'Record<string, never>';
-    }
-
-    const typeEntries: string[] = [];
-    for (const [typeName, typeInstance] of Object.entries(types)) {
-      const codecId = `'${typeInstance.codecId}'`;
-      const nativeType = `'${typeInstance.nativeType}'`;
-      const typeParamsStr = this.serializeTypeParamsLiteral(typeInstance.typeParams);
-      typeEntries.push(
-        `readonly ${typeName}: { readonly codecId: ${codecId}; readonly nativeType: ${nativeType}; readonly typeParams: ${typeParamsStr} }`,
-      );
+  generateModelStorageType(_modelName: string, model: ContractModel): string {
+    const sqlModel = model as ContractModel<SqlModelStorage>;
+    const tableName = sqlModel.storage.table;
+    const storageFields = sqlModel.storage.fields;
+
+    const storageParts = [`readonly table: ${serializeValue(tableName)}`];
+    if (Object.keys(storageFields).length > 0) {
+      const fieldParts: string[] = [];
+      for (const [fieldName, field] of Object.entries(storageFields)) {
+        fieldParts.push(
+          `readonly ${serializeObjectKey(fieldName)}: { readonly column: ${serializeValue(field.column)} }`,
+        );
+      }
+      storageParts.push(`readonly fields: { ${fieldParts.join('; ')} }`);
     }
 
-    return `{ ${typeEntries.join('; ')} }`;
+    return `{ ${storageParts.join('; ')} }`;
   },
 
-  /**
-   * Serializes a typeParams object to a TypeScript literal type.
-   * Converts { length: 1536 } to "{ readonly length: 1536 }".
-   */
-  serializeTypeParamsLiteral(params: Record<string, unknown>): string {
-    if (!params || Object.keys(params).length === 0) {
-      return 'Record<string, never>';
-    }
-
-    const entries: string[] = [];
-    for (const [key, value] of Object.entries(params)) {
-      const serialized = this.serializeValue(value);
-      entries.push(`readonly ${key}: ${serialized}`);
-    }
-
-    return `{ ${entries.join('; ')} }`;
+  getFamilyImports(): string[] {
+    return [
+      'import type {',
+      '  ContractWithTypeMaps,',
+      '  TypeMaps as TypeMapsType,',
+      "} from '@prisma-next/sql-contract/types';",
+    ];
   },
 
-  /**
-   * Serializes a value to a TypeScript literal type expression.
-   */
-  serializeValue(value: unknown): string {
-    if (value === null) {
-      return 'null';
-    }
-    if (value === undefined) {
-      return 'undefined';
-    }
-    if (typeof value === 'string') {
-      // Escape backslashes first, then single quotes
-      const escaped = value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-      return `'${escaped}'`;
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      return String(value);
-    }
-    if (typeof value === 'bigint') {
-      return `${value}n`;
-    }
-    if (Array.isArray(value)) {
-      const items = value.map((v) => this.serializeValue(v)).join(', ');
-      return `readonly [${items}]`;
-    }
-    if (typeof value === 'object') {
-      const entries: string[] = [];
-      for (const [k, v] of Object.entries(value)) {
-        entries.push(`readonly ${k}: ${this.serializeValue(v)}`);
-      }
-      return `{ ${entries.join('; ')} }`;
-    }
-    return 'unknown';
+  getFamilyTypeAliases(options?: GenerateContractTypesOptions): string {
+    const queryOperationTypeImports = options?.queryOperationTypeImports ?? [];
+    const queryOperationTypes = generateCodecTypeIntersection(
+      queryOperationTypeImports,
+      'QueryOperationTypes',
+    );
+
+    return [
+      'export type LaneCodecTypes = CodecTypes;',
+      `export type QueryOperationTypes = ${queryOperationTypes};`,
+      'type DefaultLiteralValue<CodecId extends string, _Encoded> =',
+      '  CodecId extends keyof CodecTypes',
+      "    ? CodecTypes[CodecId]['output']",
+      '    : _Encoded;',
+    ].join('\n');
   },
 
-  generateModelsType(
-    models: Record<string, ModelDefinition> | undefined,
-    storage: SqlStorage,
-    parameterizedRenderers?: Map<string, TypeRenderEntry>,
-  ): string {
-    if (!models) {
-      return 'Record<string, never>';
-    }
-
-    const renderCtx: TypeRenderContext = { codecTypesName: 'CodecTypes' };
-
-    const modelTypes: string[] = [];
-    for (const [modelName, model] of Object.entries(models)) {
-      const fields: string[] = [];
-      const tableName = model.storage.table;
-      const table = storage.tables[tableName];
-
-      if (table) {
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          const column = table.columns[field.column];
-          if (!column) {
-            fields.push(`readonly ${fieldName}: { readonly column: '${field.column}' }`);
-            continue;
-          }
-
-          const jsType = this.generateColumnType(
-            column,
-            storage,
-            parameterizedRenderers,
-            renderCtx,
-          );
-          fields.push(`readonly ${fieldName}: ${jsType}`);
-        }
-      } else {
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          fields.push(`readonly ${fieldName}: { readonly column: '${field.column}' }`);
-        }
-      }
-
-      const relations: string[] = [];
-      for (const [relName, rel] of Object.entries(model.relations)) {
-        if (typeof rel === 'object' && rel !== null && 'on' in rel) {
-          const on = rel.on as { parentCols?: string[]; childCols?: string[] };
-          if (on.parentCols && on.childCols) {
-            const parentCols = on.parentCols.map((c) => `'${c}'`).join(', ');
-            const childCols = on.childCols.map((c) => `'${c}'`).join(', ');
-            relations.push(
-              `readonly ${relName}: { readonly on: { readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] } }`,
-            );
-          }
-        }
-      }
-
-      const modelParts: string[] = [
-        `storage: { readonly table: '${tableName}' }`,
-        `fields: { ${fields.join('; ')} }`,
-      ];
-
-      if (relations.length > 0) {
-        modelParts.push(`relations: { ${relations.join('; ')} }`);
-      }
-
-      modelTypes.push(`readonly ${modelName}: { ${modelParts.join('; ')} }`);
-    }
-
-    return `{ ${modelTypes.join('; ')} }`;
+  getTypeMapsExpression(): string {
+    return 'TypeMapsType<CodecTypes, OperationTypes, QueryOperationTypes, FieldOutputTypes, FieldInputTypes>';
   },
 
-  /**
-   * Generates the TypeScript type expression for a column.
-   * Uses parameterized renderer if the column has typeParams and a matching renderer exists,
-   * otherwise falls back to CodecTypes[codecId]['output'].
-   */
-  generateColumnType(
-    column: StorageColumn,
-    storage: SqlStorage,
-    parameterizedRenderers: Map<string, TypeRenderEntry> | undefined,
-    renderCtx: TypeRenderContext,
-  ): string {
-    const typeParams = resolveColumnTypeParams(column, storage);
-    const nullable = column.nullable ?? false;
-    const fallbackType = `CodecTypes['${column.codecId}']['output']`;
-    const renderer = typeParams && parameterizedRenderers?.get(column.codecId);
-    const baseType = renderer ? renderer.render(typeParams, renderCtx) : fallbackType;
-
-    return nullable ? `${baseType} | null` : baseType;
+  getContractWrapper(contractBaseName: string, typeMapsName: string): string {
+    return [
+      `export type Contract = ContractWithTypeMaps<${contractBaseName}, ${typeMapsName}>;`,
+      '',
+      "export type Tables = Contract['storage']['tables'];",
+      "export type Models = Contract['models'];",
+    ].join('\n');
   },
+} as const;
 
-  generateRelationsType(relations: Record<string, unknown> | undefined): string {
-    if (!relations || Object.keys(relations).length === 0) {
-      return 'Record<string, never>';
-    }
-
-    const tableEntries: string[] = [];
-    for (const [tableName, relsValue] of Object.entries(relations)) {
-      if (typeof relsValue !== 'object' || relsValue === null) {
-        continue;
-      }
-      const rels = relsValue as Record<string, unknown>;
-      const relationEntries: string[] = [];
-      for (const [relName, relValue] of Object.entries(rels)) {
-        if (typeof relValue !== 'object' || relValue === null) {
-          relationEntries.push(`readonly ${relName}: unknown`);
-          continue;
-        }
-        const { to, cardinality, on, through } = relValue as {
-          readonly to?: string;
-          readonly cardinality?: string;
-          readonly on?: {
-            readonly parentCols?: readonly string[];
-            readonly childCols?: readonly string[];
-          };
-          readonly through?: {
-            readonly table: string;
-            readonly parentCols: readonly string[];
-            readonly childCols: readonly string[];
-          };
-        };
-
-        const parts: string[] = [];
-        if (to) {
-          parts.push(`readonly to: '${to}'`);
-        }
-        if (cardinality) {
-          parts.push(`readonly cardinality: '${cardinality}'`);
-        }
-        if (on?.parentCols && on.childCols) {
-          const parentCols = on.parentCols.map((c) => `'${c}'`).join(', ');
-          const childCols = on.childCols.map((c) => `'${c}'`).join(', ');
-          parts.push(
-            `readonly on: { readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] }`,
-          );
-        }
-        if (through) {
-          const parentCols = through.parentCols.map((c) => `'${c}'`).join(', ');
-          const childCols = through.childCols.map((c) => `'${c}'`).join(', ');
-          parts.push(
-            `readonly through: { readonly table: '${through.table}'; readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] }`,
-          );
-        }
-
-        relationEntries.push(
-          parts.length > 0
-            ? `readonly ${relName}: { ${parts.join('; ')} }`
-            : `readonly ${relName}: unknown`,
-        );
-      }
-      tableEntries.push(`readonly ${tableName}: { ${relationEntries.join('; ')} }`);
-    }
-
-    return `{ ${tableEntries.join('; ')} }`;
-  },
-
-  generateMappingsType(
-    models: Record<string, ModelDefinition> | undefined,
-    storage: SqlStorage,
-    codecTypes: string,
-    operationTypes: string,
-  ): string {
-    if (!models) {
-      return `SqlMappings & { readonly codecTypes: ${codecTypes || 'Record<string, never>'}; readonly operationTypes: ${operationTypes || 'Record<string, never>'}; }`;
-    }
-
-    const modelToTable: string[] = [];
-    const tableToModel: string[] = [];
-    const fieldToColumn: string[] = [];
-    const columnToField: string[] = [];
-
-    for (const [modelName, model] of Object.entries(models)) {
-      const tableName = model.storage.table;
-      modelToTable.push(`readonly ${modelName}: '${tableName}'`);
-      tableToModel.push(`readonly ${tableName}: '${modelName}'`);
-
-      const fieldMap: string[] = [];
-      for (const [fieldName, field] of Object.entries(model.fields)) {
-        fieldMap.push(`readonly ${fieldName}: '${field.column}'`);
-      }
-
-      if (fieldMap.length > 0) {
-        fieldToColumn.push(`readonly ${modelName}: { ${fieldMap.join('; ')} }`);
-      }
-
-      if (storage.tables[tableName]) {
-        const colMap: string[] = [];
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          colMap.push(`readonly ${field.column}: '${fieldName}'`);
-        }
-
-        if (colMap.length > 0) {
-          columnToField.push(`readonly ${tableName}: { ${colMap.join('; ')} }`);
-        }
-      }
-    }
+function generateStorageTypesType(types: SqlStorage['types']): string {
+  if (!types || Object.keys(types).length === 0) {
+    return 'Record<string, never>';
+  }
 
-    const parts: string[] = [];
-    if (modelToTable.length > 0) {
-      parts.push(`modelToTable: { ${modelToTable.join('; ')} }`);
-    }
-    if (tableToModel.length > 0) {
-      parts.push(`tableToModel: { ${tableToModel.join('; ')} }`);
-    }
-    if (fieldToColumn.length > 0) {
-      parts.push(`fieldToColumn: { ${fieldToColumn.join('; ')} }`);
-    }
-    if (columnToField.length > 0) {
-      parts.push(`columnToField: { ${columnToField.join('; ')} }`);
-    }
-    parts.push(`codecTypes: ${codecTypes || 'Record<string, never>'}`);
-    parts.push(`operationTypes: ${operationTypes || 'Record<string, never>'}`);
+  const typeEntries: string[] = [];
+  for (const [typeName, typeInstance] of Object.entries(types)) {
+    const codecId = serializeValue(typeInstance.codecId);
+    const nativeType = serializeValue(typeInstance.nativeType);
+    const typeParamsStr = serializeTypeParamsLiteral(typeInstance.typeParams);
+    typeEntries.push(
+      `readonly ${typeName}: { readonly codecId: ${codecId}; readonly nativeType: ${nativeType}; readonly typeParams: ${typeParamsStr} }`,
+    );
+  }
 
-    return `{ ${parts.join('; ')} }`;
-  },
-} as const;
+  return `{ ${typeEntries.join('; ')} }`;
+}