@vibeorm/dsl 0.3.0 → 2.0.0-alpha.1

package/src/generator/prisma.ts

@@ -1,728 +0,0 @@
-/**
- * Prisma schema generator for @vibeorm/dsl
- *
- * Generates a valid Prisma schema string from a SchemaDef.
- * Includes fix for 1:1 relation merging: when both sides of a one-to-one
- * define r.one pointing at the same FK column, they are merged into a
- * single Prisma relation pair instead of generating two separate relations.
- */
-
-import type {
-  ColumnDef,
-  IndexType,
-  ModelDef,
-  PrismaGeneratorConfig,
-  RelationsMap,
-  SchemaDef,
-  StoredRelationDef,
-} from "../types.ts";
-import { evaluateIndexes } from "../model.ts";
-
-// ─── Types ─────────────────────────────────
-
-/**
- * Describes which role a relation plays in a merged 1:1 pair
- */
-type MergedOneToOneSide = {
-  role: "fkOwner" | "backRelation";
-  /** The relation name on the paired (other) side */
-  pairedRelName: string;
-  /** The model name on the paired (other) side */
-  pairedModelName: string;
-  /** Merged onDelete (prefer FK owner's value) */
-  onDelete?: string;
-  /** Merged onUpdate (prefer FK owner's value) */
-  onUpdate?: string;
-};
-
-// ─── Column Formatting ─────────────────────────────────
-
-/**
- * Maps DSL column types to Prisma types
- */
-function getPrismaType(column: ColumnDef): string {
-  const isArray = column.__config.array ? "[]" : "";
-
-  switch (column.__columnType) {
-    case "string":
-      return `String${isArray}`;
-    case "int":
-      return `Int${isArray}`;
-    case "bigint":
-      return `BigInt${isArray}`;
-    case "float":
-      return `Float${isArray}`;
-    case "decimal":
-      return `Decimal${isArray}`;
-    case "boolean":
-      return `Boolean${isArray}`;
-    case "datetime":
-      return `DateTime${isArray}`;
-    case "json":
-      return `Json${isArray}`;
-    case "id": {
-      const idGenType = column.__config.type as string;
-      return idGenType === "autoincrement" ? "Int" : "String";
-    }
-    case "bytes":
-      return `Bytes${isArray}`;
-    case "enum": {
-      const enumName = column.__enumName;
-      return enumName ? `${enumName}${isArray}` : `String${isArray}`;
-    }
-    case "unsupported": {
-      const dbType = column.__config.dbType as string;
-      return `Unsupported("${dbType}")`;
-    }
-    default:
-      return `String${isArray}`;
-  }
-}
-
-/**
- * Formats a column definition to Prisma syntax
- */
-function formatColumn(name: string, column: ColumnDef): string {
-  const commentLines: string[] = [];
-
-  // Triple-slash comments (for Zod generators, docs, etc.)
-  if (column.__config.comment) {
-    const comment = column.__config.comment as string;
-    for (const line of comment.split("\n")) {
-      commentLines.push(`  /// ${line}`);
-    }
-  }
-
-  const type = getPrismaType(column);
-  const optional = column.__config.optional ? "?" : "";
-  const parts: string[] = [`  ${name} ${type}${optional}`];
-
-  // Handle ID column
-  if (column.__columnType === "id") {
-    parts.push("@id");
-    const idType = column.__config.type as string;
-    if (idType === "ulid") {
-      parts.push("@default(ulid())");
-    } else if (idType === "cuid") {
-      parts.push("@default(cuid())");
-    } else if (idType === "uuid") {
-      parts.push("@default(uuid())");
-    } else if (idType === "autoincrement") {
-      parts.push("@default(autoincrement())");
-    }
-  }
-
-  // Handle default values
-  if (column.__config.default !== undefined && column.__columnType !== "id") {
-    const defaultVal = column.__config.default;
-    if (column.__columnType === "datetime" && defaultVal === "now") {
-      parts.push("@default(now())");
-    } else if (column.__columnType === "enum" && typeof defaultVal === "string") {
-      parts.push(`@default(${defaultVal})`);
-    } else if (typeof defaultVal === "string") {
-      parts.push(`@default("${defaultVal}")`);
-    } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
-      parts.push(`@default(${defaultVal})`);
-    }
-  }
-
-  // Handle @updatedAt
-  if (column.__columnType === "datetime" && column.__config.updatedAt) {
-    parts.push("@updatedAt");
-  }
-
-  // Handle @db.Timestamptz
-  if (column.__columnType === "datetime" && column.__config.tz) {
-    parts.push("@db.Timestamptz()");
-  }
-
-  // Handle unique
-  if (column.__config.unique) {
-    parts.push("@unique");
-  }
-
-  // Handle @map for column name mapping
-  if (column.__config.map) {
-    parts.push(`@map("${column.__config.map}")`);
-  }
-
-  // Handle @default(dbgenerated(...)) for database-native defaults
-  if (column.__config.dbgenerated) {
-    parts.push(`@default(dbgenerated("${column.__config.dbgenerated}"))`);
-  }
-
-  // Handle database-level string type annotations
-  if (column.__columnType === "string") {
-    const maxLen = column.__config.maxLength as number | undefined;
-    const isText = column.__config.text as boolean | undefined;
-    if (maxLen) {
-      parts.push(`@db.VarChar(${maxLen})`);
-    } else if (isText) {
-      parts.push("@db.Text");
-    }
-  }
-
-  // Handle decimal precision/scale
-  if (column.__columnType === "decimal") {
-    const precision = column.__config.precision as number | undefined;
-    const scale = column.__config.scale as number | undefined;
-    if (precision !== undefined) {
-      parts.push(`@db.Decimal(${precision}, ${scale ?? 0})`);
-    }
-  }
-
-  const columnLine = parts.join(" ");
-  if (commentLines.length > 0) {
-    return [...commentLines, columnLine].join("\n");
-  }
-  return columnLine;
-}
-
-// ─── 1:1 Relation Merge Detection ─────────────────────────────────
-
-/**
- * Detects pairs of r.one relations between two models that describe the same
- * logical 1:1 relationship and determines which side owns the FK.
- *
- * Two r.one relations form a pair when:
- *   relA: fromModel=A, fromColumn=colA, toModel=B, toColumn=colB
- *   relB: fromModel=B, fromColumn=colB, toModel=A, toColumn=colA
- *
- * The FK owner is the side whose fromColumn is NOT a primary key (id) column.
- *
- * Returns a Map keyed by "ModelName:relationName" with merge metadata.
- */
-function detectOneToOnePairs(params: {
-  relations: RelationsMap;
-  allModels: Map<string, ModelDef>;
-}): Map<string, MergedOneToOneSide> {
-  const { relations, allModels } = params;
-  const mergeMap = new Map<string, MergedOneToOneSide>();
-
-  // Collect all "one" type relations into a flat list
-  type OneRelEntry = {
-    modelName: string;
-    relName: string;
-    rel: StoredRelationDef;
-  };
-
-  const allOnes: OneRelEntry[] = [];
-  for (const [modelName, modelRels] of Object.entries(relations)) {
-    for (const [relName, rel] of Object.entries(modelRels)) {
-      if (rel.__relationType === "one") {
-        allOnes.push({ modelName, relName, rel });
-      }
-    }
-  }
-
-  // Track already-paired entries to avoid double-processing
-  const paired = new Set<string>();
-
-  for (let i = 0; i < allOnes.length; i++) {
-    const a = allOnes[i]!;
-    const keyA = `${a.modelName}:${a.relName}`;
-    if (paired.has(keyA)) continue;
-
-    for (let j = i + 1; j < allOnes.length; j++) {
-      const b = allOnes[j]!;
-      const keyB = `${b.modelName}:${b.relName}`;
-      if (paired.has(keyB)) continue;
-
-      // Check if they describe the same FK column pair (cross-match)
-      const sameColumnPair =
-        a.rel.__fromModel === b.rel.__toModel &&
-        a.rel.__fromColumn === b.rel.__toColumn &&
-        a.rel.__toModel === b.rel.__fromModel &&
-        a.rel.__toColumn === b.rel.__fromColumn;
-
-      if (!sameColumnPair) continue;
-
-      // They're a pair! Determine which side owns the FK.
-      // The FK owner is the side whose __fromColumn is NOT a primary key column.
-      const modelA = allModels.get(a.modelName);
-      const modelB = allModels.get(b.modelName);
-
-      const aFromColIsId = modelA?.__columns.get(a.rel.__fromColumn)?.__columnType === "id";
-      const bFromColIsId = modelB?.__columns.get(b.rel.__fromColumn)?.__columnType === "id";
-
-      let fkOwner: OneRelEntry;
-      let backRelSide: OneRelEntry;
-
-      if (aFromColIsId && !bFromColIsId) {
-        // A's from is a PK, B's from is a FK → B owns the FK
-        fkOwner = b;
-        backRelSide = a;
-      } else if (!aFromColIsId && bFromColIsId) {
-        // B's from is a PK, A's from is a FK → A owns the FK
-        fkOwner = a;
-        backRelSide = b;
-      } else {
-        // Ambiguous: neither or both are PKs. Fall back to: the side that
-        // specifies onDelete/onUpdate is the FK owner, otherwise pick the
-        // second one (the one whose fromColumn looks like a FK name - contains "Id").
-        if (a.rel.__onDelete || a.rel.__onUpdate) {
-          fkOwner = a;
-          backRelSide = b;
-        } else if (b.rel.__onDelete || b.rel.__onUpdate) {
-          fkOwner = b;
-          backRelSide = a;
-        } else {
-          // Last resort: pick the side whose fromColumn contains "Id" (typical FK naming)
-          const aLooksFk = a.rel.__fromColumn.toLowerCase().includes("id") && a.rel.__fromColumn !== "id";
-          const bLooksFk = b.rel.__fromColumn.toLowerCase().includes("id") && b.rel.__fromColumn !== "id";
-          if (aLooksFk && !bLooksFk) {
-            fkOwner = a;
-            backRelSide = b;
-          } else {
-            fkOwner = b;
-            backRelSide = a;
-          }
-        }
-      }
-
-      const fkKey = `${fkOwner.modelName}:${fkOwner.relName}`;
-      const backKey = `${backRelSide.modelName}:${backRelSide.relName}`;
-
-      // Merge onDelete/onUpdate: prefer FK owner's, fall back to back-relation's
-      const mergedOnDelete = fkOwner.rel.__onDelete ?? backRelSide.rel.__onDelete;
-      const mergedOnUpdate = fkOwner.rel.__onUpdate ?? backRelSide.rel.__onUpdate;
-
-      mergeMap.set(fkKey, {
-        role: "fkOwner",
-        pairedRelName: backRelSide.relName,
-        pairedModelName: backRelSide.modelName,
-        onDelete: mergedOnDelete,
-        onUpdate: mergedOnUpdate,
-      });
-
-      mergeMap.set(backKey, {
-        role: "backRelation",
-        pairedRelName: fkOwner.relName,
-        pairedModelName: fkOwner.modelName,
-        onDelete: mergedOnDelete,
-        onUpdate: mergedOnUpdate,
-      });
-
-      paired.add(fkKey);
-      paired.add(backKey);
-      break; // relA is paired, move to next i
-    }
-  }
-
-  return mergeMap;
-}
-
-// ─── Relation Formatting ─────────────────────────────────
-
-/**
- * Capitalizes the first letter of a string (for PascalCase relation names)
- */
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-/**
- * Determines if this model owns the FK for a "one" relation.
- */
-function isOwningFkSide(relation: StoredRelationDef, modelName: string): boolean {
-  return relation.__fromModel === modelName;
-}
-
-/**
- * Formats a "one" relation to Prisma syntax.
- *
- * If the relation is part of a merged 1:1 pair, uses the merge metadata
- * to determine correct output. Otherwise falls back to standard behavior.
- */
-function formatOneRelation(params: {
-  name: string;
-  relation: StoredRelationDef;
-  modelName: string;
-  model: ModelDef;
-  mergeMap: Map<string, MergedOneToOneSide>;
-}): string {
-  const { name, relation, modelName, model, mergeMap } = params;
-  const targetName = relation.__targetModel;
-  const pascalName = capitalize(name);
-  const mergeKey = `${modelName}:${name}`;
-  const mergeInfo = mergeMap.get(mergeKey);
-
-  // ─── Merged 1:1 pair handling ─────
-  if (mergeInfo) {
-    if (mergeInfo.role === "fkOwner") {
-      // This side owns the FK — emit @relation(fields/references)
-      const fkName = relation.__fromColumn;
-      const fkColumn = model.__columns.get(fkName);
-      const isOptional = fkColumn?.__config.optional || relation.__optional;
-      const optional = isOptional ? "?" : "";
-
-      const relationParts: string[] = [];
-      if (relation.__alias) {
-        relationParts.push(`"${relation.__alias}"`);
-      }
-      relationParts.push(`fields: [${fkName}]`);
-      relationParts.push(`references: [${relation.__toColumn}]`);
-
-      // Use merged cascade actions
-      if (mergeInfo.onDelete) {
-        relationParts.push(`onDelete: ${mergeInfo.onDelete}`);
-      }
-      if (mergeInfo.onUpdate) {
-        relationParts.push(`onUpdate: ${mergeInfo.onUpdate}`);
-      }
-
-      return `  ${pascalName} ${targetName}${optional} @relation(${relationParts.join(", ")})`;
-    } else {
-      // This is the back-relation side of a 1:1 — emit simple optional reference
-      const relationAttr = relation.__alias ? ` @relation("${relation.__alias}")` : "";
-      return `  ${pascalName} ${targetName}?${relationAttr}`;
-    }
-  }
-
-  // ─── Standard (non-merged) one relation handling ─────
-  const ownsFk = isOwningFkSide(relation, modelName);
-
-  if (ownsFk) {
-    const fkName = relation.__fromColumn;
-    const fkColumn = model.__columns.get(fkName);
-    const isOptional = fkColumn?.__config.optional || relation.__optional;
-    const optional = isOptional ? "?" : "";
-
-    const relationParts: string[] = [];
-    if (relation.__alias) {
-      relationParts.push(`"${relation.__alias}"`);
-    }
-    relationParts.push(`fields: [${fkName}]`);
-    relationParts.push(`references: [${relation.__toColumn}]`);
-
-    if (relation.__onDelete) {
-      relationParts.push(`onDelete: ${relation.__onDelete}`);
-    }
-    if (relation.__onUpdate) {
-      relationParts.push(`onUpdate: ${relation.__onUpdate}`);
-    }
-
-    return `  ${pascalName} ${targetName}${optional} @relation(${relationParts.join(", ")})`;
-  } else {
-    // Reverse side of a one-to-one — simple back-relation
-    const optional = relation.__optional ? "?" : "";
-    const relationAttr = relation.__alias ? ` @relation("${relation.__alias}")` : "";
-    return `  ${pascalName} ${targetName}${optional}${relationAttr}`;
-  }
-}
-
-/**
- * Formats a "many" relation to Prisma syntax.
- * "many" relations never have fields/references.
- */
-function formatManyRelation(name: string, relation: StoredRelationDef): string {
-  const targetName = relation.__targetModel;
-  const pascalName = capitalize(name);
-  const relationAttr = relation.__alias ? ` @relation("${relation.__alias}")` : "";
-  return `  ${pascalName} ${targetName}[]${relationAttr}`;
-}
-
-// ─── Index Collection ─────────────────────────────────
-
-/**
- * Collects all single-column indexes from a model
- */
-function collectSingleColumnIndexes(model: ModelDef): string[] {
-  const indexedColumns: string[] = [];
-
-  for (const [name, column] of model.__columns) {
-    if (column.__columnType === "id" || column.__config.unique) {
-      continue;
-    }
-    if (column.__config.index) {
-      indexedColumns.push(name);
-    }
-  }
-
-  return indexedColumns;
-}
-
-// ─── Missing Reverse Relations ─────────────────────────────────
-
-/**
- * Finds missing reverse relations that need to be auto-generated.
- *
- * For each "one" relation pointing TO this model, check if there's a
- * corresponding "many" relation FROM this model back. If not, generate it.
- *
- * IMPORTANT: Skips any relation that is part of a merged 1:1 pair, since
- * those are fully handled by the merge logic and should NOT get array reverses.
- */
-function findMissingReverseRelations(params: {
-  modelName: string;
-  relations: RelationsMap;
-  allModels: Map<string, ModelDef>;
-  mergeMap: Map<string, MergedOneToOneSide>;
-}): Array<{ name: string; targetModel: string; alias?: string }> {
-  const { modelName, relations, allModels, mergeMap } = params;
-  const missing: Array<{ name: string; targetModel: string; alias?: string }> = [];
-
-  // Track existing "many" relations by target+alias combo
-  const existingManyRelations = new Set<string>();
-  // Track existing field names to avoid duplicates
-  const existingFieldNames = new Set<string>();
-
-  // Collect existing relations from this model
-  const modelRelations = relations[modelName] ?? {};
-  for (const [relName, rel] of Object.entries(modelRelations)) {
-    existingFieldNames.add(relName);
-    if (rel.__relationType === "many") {
-      const key = `${rel.__targetModel}:${rel.__alias || ""}`;
-      existingManyRelations.add(key);
-    }
-  }
-
-  // Check ALL models (including self) for relations pointing TO this model
-  for (const [sourceModelName, sourceModelRels] of Object.entries(relations)) {
-    for (const [relName, rel] of Object.entries(sourceModelRels)) {
-      if (rel.__targetModel === modelName && rel.__relationType === "one") {
-        // Skip if this relation is part of a merged 1:1 pair
-        const sourceKey = `${sourceModelName}:${relName}`;
-        if (mergeMap.has(sourceKey)) {
-          continue;
-        }
-
-        const reverseKey = `${sourceModelName}:${rel.__alias || ""}`;
-
-        // For self-referential relations, check if there's already an explicit
-        // "many" relation with the same alias defined
-        if (sourceModelName === modelName) {
-          const hasExplicitReverse = Object.values(sourceModelRels).some(
-            (r): r is StoredRelationDef =>
-              r.__relationType === "many" &&
-              r.__targetModel === modelName &&
-              r.__alias === rel.__alias
-          );
-          if (hasExplicitReverse) continue;
-        }
-
-        if (!existingManyRelations.has(reverseKey)) {
-          let baseName = sourceModelName;
-          let fieldName = baseName;
-
-          if (rel.__alias) {
-            fieldName = rel.__alias;
-            baseName = fieldName;
-          }
-
-          let counter = 1;
-          while (existingFieldNames.has(fieldName)) {
-            counter++;
-            fieldName = `${baseName}${counter}`;
-          }
-
-          missing.push({
-            name: fieldName,
-            targetModel: sourceModelName,
-            alias: rel.__alias,
-          });
-          existingManyRelations.add(reverseKey);
-          existingFieldNames.add(fieldName);
-        }
-      }
-    }
-  }
-
-  return missing;
-}
-
-// ─── Model Formatting ─────────────────────────────────
-
-/**
- * Formats a single model to Prisma syntax
- */
-function formatModel(params: {
-  model: ModelDef;
-  relations: RelationsMap;
-  allModels: Map<string, ModelDef>;
-  mergeMap: Map<string, MergedOneToOneSide>;
-}): string {
-  const { model, relations, allModels, mergeMap } = params;
-  const lines: string[] = [];
-  const modelName = model.__name;
-  lines.push(`model ${modelName} {`);
-
-  // Section: Columns
-  lines.push("  //> Columns");
-  for (const [name, column] of model.__columns) {
-    lines.push(formatColumn(name, column));
-  }
-
-  // Section: Relations
-  lines.push("");
-  lines.push("  //> Relations");
-
-  const outputManyRelations = new Set<string>();
-
-  // Relations from the centralized relations map
-  const modelRelations = relations[modelName] ?? {};
-  for (const [name, relation] of Object.entries(modelRelations)) {
-    if (relation.__relationType === "one") {
-      lines.push(formatOneRelation({
-        name,
-        relation,
-        modelName,
-        model,
-        mergeMap,
-      }));
-    } else if (relation.__relationType === "many") {
-      lines.push(formatManyRelation(name, relation));
-      const key = `${relation.__targetModel}:${relation.__alias || ""}`;
-      outputManyRelations.add(key);
-    }
-  }
-
-  // Auto-generate missing reverse relations (skips merged 1:1 pairs)
-  const missingReverses = findMissingReverseRelations({
-    modelName,
-    relations,
-    allModels,
-    mergeMap,
-  });
-  for (const reverse of missingReverses) {
-    const key = `${reverse.targetModel}:${reverse.alias || ""}`;
-    if (!outputManyRelations.has(key)) {
-      const relationAttr = reverse.alias ? ` @relation("${reverse.alias}")` : "";
-      lines.push(`  ${reverse.name} ${reverse.targetModel}[]${relationAttr}`);
-      outputManyRelations.add(key);
-    }
-  }
-
-  // Children (inline nested models)
-  for (const [name, childModel] of model.__children) {
-    lines.push(`  ${name} ${childModel.__name}[]`);
-  }
-
-  // Parent FK relations for child models
-  for (const [parentModelName, parentModel] of allModels) {
-    for (const [childKey, childModel] of parentModel.__children) {
-      if (childModel.__name === modelName) {
-        const parentFkName = `${parentModelName.charAt(0).toLowerCase()}${parentModelName.slice(1)}Id`;
-        const parentRelName = parentModelName;
-        const parentPkCol = parentModel.__primaryKey?.[0]
-          ?? Array.from(parentModel.__columns.entries()).find(([, col]) => col.__columnType === "id")?.[0]
-          ?? "id";
-        lines.push(
-          `  ${parentRelName} ${parentModelName} @relation(fields: [${parentFkName}], references: [${parentPkCol}])`
-        );
-      }
-    }
-  }
-
-  // Section: Indexes
-  lines.push("");
-  lines.push("  //> Indexes");
-  lines.push("");
-
-  const allIndexes = new Map<string, { type: "index" | "unique"; indexType?: IndexType }>();
-
-  // Single-column indexes from column config
-  const singleIndexes = collectSingleColumnIndexes(model);
-  for (const colName of singleIndexes) {
-    allIndexes.set(colName, { type: "index" });
-  }
-
-  // Composite/explicit indexes from indexes callback
-  const compositeIndexes = evaluateIndexes(model);
-  for (const idx of compositeIndexes) {
-    const key = idx.__columns.join(",");
-    const existing = allIndexes.get(key);
-    if (!existing || idx.__type === "unique") {
-      allIndexes.set(key, { type: idx.__type, indexType: idx.__indexType });
-    } else if (idx.__indexType && !existing.indexType) {
-      allIndexes.set(key, { ...existing, indexType: idx.__indexType });
-    }
-  }
-
-  // Output deduplicated indexes
-  for (const [columns, { type, indexType }] of allIndexes) {
-    const colList = columns.split(",").join(", ");
-    const typeArg = indexType ? `, type: ${indexType}` : "";
-    if (type === "unique") {
-      lines.push(`  @@unique([${colList}])`);
-    } else {
-      lines.push(`  @@index([${colList}]${typeArg})`);
-    }
-  }
-
-  // Handle @@id for compound primary keys
-  if (model.__primaryKey && model.__primaryKey.length > 0) {
-    const pkCols = model.__primaryKey.join(", ");
-    lines.push(`  @@id([${pkCols}])`);
-  }
-
-  // Handle @@map for table name mapping
-  if (model.__map) {
-    lines.push(`  @@map("${model.__map}")`);
-  }
-
-  lines.push("}");
-  return lines.join("\n");
-}
-
-// ─── Enum Formatting ─────────────────────────────────
-
-/**
- * Formats an enum to Prisma syntax
- */
-function formatEnum(name: string, values: readonly string[]): string {
-  const lines: string[] = [];
-  lines.push(`enum ${name} {`);
-  for (const value of values) {
-    lines.push(`  ${value}`);
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-
-// ─── Public API ─────────────────────────────────
-
-/**
- * Generates a complete Prisma schema from a SchemaDef.
- *
- * This only generates models and enums. Developers should manage their own
- * datasource and generator blocks in a separate base.prisma file.
- */
-export function generatePrisma(schema: SchemaDef, config: PrismaGeneratorConfig = {}): string {
-  const sections: string[] = [];
-
-  // Pre-process: detect 1:1 relation pairs and build merge map
-  const mergeMap = detectOneToOnePairs({
-    relations: schema.__relations,
-    allModels: schema.__models,
-  });
-
-  // Enums
-  if (schema.__enums.size > 0) {
-    sections.push("// ============================================");
-    sections.push("// Enums");
-    sections.push("// ============================================");
-    sections.push("");
-    for (const [name, values] of schema.__enums) {
-      sections.push(formatEnum(name, values));
-      sections.push("");
-    }
-  }
-
-  // Models
-  sections.push("// ============================================");
-  sections.push("// Models");
-  sections.push("// ============================================");
-  sections.push("");
-  for (const [name, model] of schema.__models) {
-    sections.push(formatModel({
-      model,
-      relations: schema.__relations,
-      allModels: schema.__models,
-      mergeMap,
-    }));
-    sections.push("");
-  }
-
-  return sections.join("\n").trim();
-}