@effectify/prisma 1.0.1 → 1.1.0

package/dist/src/schema-generator/effect/type.js

@@ -0,0 +1,82 @@
+import { isListField, isRequiredField, isUuidField } from "../prisma/type.js";
+import { extractEffectTypeOverride } from "../utils/annotations.js";
+import { toPascalCase } from "../utils/naming.js";
+/**
+ * Prisma scalar type mapping to Effect Schema types
+ * Uses const assertion to avoid type guards
+ *
+ * Note: DateTime uses Schema.DateFromSelf (not Schema.Date) so that:
+ * - Type = Date (runtime)
+ * - Encoded = Date (database)
+ * This allows Kysely to work with native Date objects directly.
+ * Schema.Date would encode to string, requiring ISO string conversions.
+ */
+const PRISMA_SCALAR_MAP = {
+    String: "Schema.String",
+    Int: "Schema.Number",
+    Float: "Schema.Number",
+    BigInt: "Schema.BigInt",
+    Decimal: "Schema.String", // For precision
+    Boolean: "Schema.Boolean",
+    DateTime: "Schema.DateFromSelf", // Native Date type for Kysely compatibility
+    Json: "Schema.Unknown", // Safe unknown type
+    Bytes: "Schema.Uint8Array",
+};
+/**
+ * Map Prisma field type to Effect Schema type
+ * Priority order: annotation → FK branded → UUID → scalar → enum → unknown fallback
+ *
+ * @param field - The Prisma field to map
+ * @param dmmf - The full DMMF document for enum lookups
+ * @param fkMap - Optional FK field → target model mapping for branded FK types
+ */
+export function mapFieldToEffectType(field, dmmf, fkMap) {
+    // PRIORITY 1: Check for @customType annotation
+    const typeOverride = extractEffectTypeOverride(field);
+    if (typeOverride) {
+        return typeOverride;
+    }
+    // PRIORITY 2: Check if this is a FK field with branded target
+    // FK fields use the referenced model's branded ID (e.g., UserId for user_id)
+    if (fkMap && fkMap.has(field.name)) {
+        const targetModel = fkMap.get(field.name);
+        return `${toPascalCase(targetModel)}Id`;
+    }
+    // PRIORITY 3: Handle String type with UUID detection (non-FK UUIDs)
+    if (field.type === "String" && isUuidField(field)) {
+        return "Schema.UUID";
+    }
+    // PRIORITY 4: Handle scalar types with const assertion lookup
+    const scalarType = PRISMA_SCALAR_MAP[field.type];
+    if (scalarType) {
+        return scalarType;
+    }
+    // PRIORITY 5: Check if it's an enum
+    const enumDef = dmmf.datamodel.enums.find((e) => e.name === field.type);
+    if (enumDef) {
+        // PascalCase name IS the Schema now (not raw enum)
+        return toPascalCase(field.type);
+    }
+    // PRIORITY 6: Fallback to Unknown
+    return "Schema.Unknown";
+}
+/**
+ * Build complete field type with array and optional wrapping
+ *
+ * @param field - The Prisma field to build type for
+ * @param dmmf - The full DMMF document for enum lookups
+ * @param fkMap - Optional FK field → target model mapping for branded FK types
+ */
+export function buildFieldType(field, dmmf, fkMap) {
+    let baseType = mapFieldToEffectType(field, dmmf, fkMap);
+    // Handle arrays
+    if (isListField(field)) {
+        baseType = `Schema.Array(${baseType})`;
+    }
+    // Handle nullable fields - wrap with NullOr regardless of default value
+    // This ensures SELECT type correctly allows null values (e.g., Boolean? @default(false))
+    if (!isRequiredField(field)) {
+        baseType = `Schema.NullOr(${baseType})`;
+    }
+    return baseType;
+}

package/dist/src/schema-generator/index.d.ts

@@ -0,0 +1,11 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import type { DMMF } from "@prisma/generator-helper";
+import * as Effect from "effect/Effect";
+import { RenderService } from "../services/render-service.js";
+import { FormatterService } from "../services/formatter-service.js";
+/**
+ * Generate Effect schemas (enums, types, index)
+ * Replicates legacy generator logic using Effect patterns and Eta templates
+ */
+export declare const generateSchemas: (dmmf: DMMF.Document, outputDir: string) => Effect.Effect<void, import("@effect/platform/Error").PlatformError | Error, FileSystem.FileSystem | Path.Path | RenderService | FormatterService>;

package/dist/src/schema-generator/index.js

@@ -0,0 +1,83 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Effect from "effect/Effect";
+import { RenderService } from "../services/render-service.js";
+import { FormatterService } from "../services/formatter-service.js";
+import * as EnumGenerator from "./effect/enum.js";
+import * as EffectGenerator from "./effect/generator.js";
+import * as JoinTableGenerator from "./effect/join-table.js";
+import * as KyselyGenerator from "./kysely/generator.js";
+import * as PrismaGenerator from "./prisma/generator.js";
+/**
+ * Generate Effect schemas (enums, types, index)
+ * Replicates legacy generator logic using Effect patterns and Eta templates
+ */
+export const generateSchemas = (dmmf, outputDir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const { render } = yield* RenderService;
+    const { format } = yield* FormatterService;
+    yield* fs.makeDirectory(outputDir, { recursive: true });
+    const writeFile = (filename, content) => Effect.gen(function* () {
+        const formatted = yield* format(content);
+        const filePath = path.join(outputDir, filename);
+        yield* fs.writeFileString(filePath, formatted);
+    });
+    // Generate Enums
+    const enums = PrismaGenerator.getEnums(dmmf);
+    const enumsData = EnumGenerator.prepareEnumsData(enums);
+    if (enumsData) {
+        const content = yield* render("effect-enums", enumsData);
+        yield* writeFile("enums.ts", content);
+    }
+    // Generate Types
+    const models = PrismaGenerator.getModels(dmmf);
+    const joinTables = PrismaGenerator.getManyToManyJoinTables(dmmf);
+    const hasEnums = enums.length > 0;
+    // Header
+    const headerData = EffectGenerator.prepareTypesHeaderData(dmmf, hasEnums);
+    let content = yield* render("effect-types-header", headerData);
+    // Branded IDs
+    const brandedIdsData = models
+        .map((model) => {
+        const fields = PrismaGenerator.getModelFields(model);
+        return EffectGenerator.prepareBrandedIdSchemaData(model, fields);
+    })
+        .filter((data) => data !== null);
+    if (brandedIdsData.length > 0) {
+        content += `\n\n// ===== Branded ID Schemas =====`;
+        for (const data of brandedIdsData) {
+            const idContent = yield* render("effect-branded-id", data);
+            content += `\n\n${idContent}`;
+        }
+    }
+    // Models
+    const modelsData = models.map((model) => {
+        const fields = PrismaGenerator.getModelFields(model);
+        return EffectGenerator.prepareModelSchemaData(dmmf, model, fields);
+    });
+    if (modelsData.length > 0) {
+        content += `\n\n// ===== Model Schemas =====`;
+        for (const data of modelsData) {
+            const modelContent = yield* render("effect-model", data);
+            content += `\n\n${modelContent}`;
+        }
+    }
+    // Join Tables
+    const joinTablesData = joinTables.map((jt) => JoinTableGenerator.prepareJoinTableData(jt, dmmf));
+    if (joinTablesData.length > 0) {
+        for (const data of joinTablesData) {
+            const jtContent = yield* render("effect-join-table", data);
+            content += `\n\n${jtContent}`;
+        }
+    }
+    // DB Interface
+    const dbInterfaceData = KyselyGenerator.prepareDBInterfaceData(models, joinTables);
+    const dbInterfaceContent = yield* render("kysely-db-interface", dbInterfaceData);
+    content += `\n\n${dbInterfaceContent}`;
+    yield* writeFile("types.ts", content);
+    // Index
+    const indexData = KyselyGenerator.prepareIndexData(hasEnums);
+    const indexContent = yield* render("effect-index", indexData);
+    yield* writeFile("index.ts", indexContent);
+});

package/dist/src/schema-generator/kysely/generator.d.ts

@@ -0,0 +1,11 @@
+import type { DMMF } from "@prisma/generator-helper";
+import type { JoinTableInfo } from "../prisma/relation.js";
+export declare const prepareDBInterfaceData: (models: readonly DMMF.Model[], joinTables?: JoinTableInfo[]) => {
+    models: {
+        tableName: string;
+        typeName: string;
+    }[];
+};
+export declare const prepareIndexData: (hasEnums?: boolean) => {
+    hasEnums: boolean;
+};

package/dist/src/schema-generator/kysely/generator.js

@@ -0,0 +1,7 @@
+import { prepareDBInterfaceData as prepareDBInterfaceDataHelper } from "./type.js";
+export const prepareDBInterfaceData = (models, joinTables = []) => {
+    return prepareDBInterfaceDataHelper(models, joinTables);
+};
+export const prepareIndexData = (hasEnums = true) => {
+    return { hasEnums };
+};

package/dist/src/schema-generator/kysely/type.d.ts

@@ -0,0 +1,14 @@
+import type { DMMF } from "@prisma/generator-helper";
+import type { JoinTableInfo } from "../prisma/relation.js";
+export declare function needsColumnType(field: DMMF.Field): boolean;
+export declare function isEnumField(field: DMMF.Field, dmmf: DMMF.Document): boolean;
+export declare function needsGenerated(field: DMMF.Field, dmmf: DMMF.Document): boolean;
+export declare function applyKyselyHelpers(fieldType: string, field: DMMF.Field, dmmf: DMMF.Document, modelName?: string): string;
+export declare function applyMapDirective(fieldType: string, field: DMMF.Field): string;
+export declare function buildKyselyFieldType(baseFieldType: string, field: DMMF.Field, dmmf: DMMF.Document, modelName?: string): string;
+export declare function prepareDBInterfaceData(models: readonly DMMF.Model[], joinTables?: JoinTableInfo[]): {
+    models: {
+        tableName: string;
+        typeName: string;
+    }[];
+};

package/dist/src/schema-generator/kysely/type.js

@@ -0,0 +1,44 @@
+import { getFieldDbName, hasDefaultValue, isIdField } from "../prisma/type.js";
+import { toPascalCase } from "../utils/naming.js";
+export function needsColumnType(field) {
+    return hasDefaultValue(field) && isIdField(field);
+}
+export function isEnumField(field, dmmf) {
+    return dmmf.datamodel.enums.some((e) => e.name === field.type);
+}
+export function needsGenerated(field, dmmf) {
+    return hasDefaultValue(field) && !isIdField(field) && !isEnumField(field, dmmf);
+}
+export function applyKyselyHelpers(fieldType, field, dmmf, modelName) {
+    if (needsColumnType(field)) {
+        const idType = modelName ? `${toPascalCase(modelName)}Id` : fieldType;
+        return `generated(${idType})`;
+    }
+    else if (needsGenerated(field, dmmf)) {
+        return `generated(${fieldType})`;
+    }
+    return fieldType;
+}
+export function applyMapDirective(fieldType, field) {
+    const dbName = getFieldDbName(field);
+    if (field.dbName && field.dbName !== field.name) {
+        return `Schema.propertySignature(${fieldType}).pipe(Schema.fromKey("${dbName}"))`;
+    }
+    return fieldType;
+}
+export function buildKyselyFieldType(baseFieldType, field, dmmf, modelName) {
+    let fieldType = applyKyselyHelpers(baseFieldType, field, dmmf, modelName);
+    fieldType = applyMapDirective(fieldType, field);
+    return fieldType;
+}
+export function prepareDBInterfaceData(models, joinTables = []) {
+    const modelEntries = models.map((m) => ({
+        tableName: m.dbName || m.name,
+        typeName: toPascalCase(m.name),
+    }));
+    const joinTableEntries = joinTables.map((jt) => ({
+        tableName: jt.tableName,
+        typeName: toPascalCase(jt.relationName),
+    }));
+    return { models: [...modelEntries, ...joinTableEntries] };
+}

package/dist/src/schema-generator/prisma/enum.d.ts

@@ -0,0 +1,19 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * Extract enum definitions from Prisma DMMF
+ * Handles @map directive for database-level enum values
+ */
+export declare function extractEnums(dmmf: DMMF.Document): readonly DMMF.ReadonlyDeep<DMMF.ReadonlyDeep<DMMF.ReadonlyDeep<{
+    name: string;
+    values: DMMF.EnumValue[];
+    dbName?: string | null;
+    documentation?: string;
+}>>>[];
+/**
+ * Get the database value for an enum value (respects @map directive)
+ */
+export declare function getEnumValueDbName(enumValue: DMMF.EnumValue): string;
+/**
+ * Get all database values for an enum
+ */
+export declare function getEnumDbValues(enumDef: DMMF.DatamodelEnum): string[];

package/dist/src/schema-generator/prisma/enum.js

@@ -0,0 +1,19 @@
+/**
+ * Extract enum definitions from Prisma DMMF
+ * Handles @map directive for database-level enum values
+ */
+export function extractEnums(dmmf) {
+    return dmmf.datamodel.enums;
+}
+/**
+ * Get the database value for an enum value (respects @map directive)
+ */
+export function getEnumValueDbName(enumValue) {
+    return enumValue.dbName ?? enumValue.name;
+}
+/**
+ * Get all database values for an enum
+ */
+export function getEnumDbValues(enumDef) {
+    return enumDef.values.map(getEnumValueDbName);
+}

package/dist/src/schema-generator/prisma/generator.d.ts

@@ -0,0 +1,53 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * Get all enums from DMMF
+ */
+export declare const getEnums: (dmmf: DMMF.Document) => readonly DMMF.ReadonlyDeep<DMMF.ReadonlyDeep<DMMF.ReadonlyDeep<{
+    name: string;
+    values: DMMF.EnumValue[];
+    dbName?: string | null;
+    documentation?: string;
+}>>>[];
+/**
+ * Get all models from DMMF (filtered and sorted)
+ */
+export declare const getModels: (dmmf: DMMF.Document) => DMMF.ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: DMMF.Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: DMMF.uniqueIndex[];
+    documentation?: string;
+    primaryKey: DMMF.PrimaryKey | null;
+    isGenerated?: boolean;
+}>[];
+/**
+ * Get schema fields for a model (filtered and sorted)
+ */
+export declare const getModelFields: (model: DMMF.Model) => DMMF.ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    type: string;
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefault | DMMF.FieldDefaultScalar | DMMF.FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>[];
+/**
+ * Get implicit many-to-many join tables
+ */
+export declare const getManyToManyJoinTables: (dmmf: DMMF.Document) => import("./relation.js").JoinTableInfo[];

package/dist/src/schema-generator/prisma/generator.js

@@ -0,0 +1,29 @@
+import * as PrismaEnum from "./enum.js";
+import { detectImplicitManyToMany } from "./relation.js";
+import * as PrismaType from "./type.js";
+/**
+ * Get all enums from DMMF
+ */
+export const getEnums = (dmmf) => {
+    return PrismaEnum.extractEnums(dmmf);
+};
+/**
+ * Get all models from DMMF (filtered and sorted)
+ */
+export const getModels = (dmmf) => {
+    const filtered = PrismaType.filterInternalModels(dmmf.datamodel.models);
+    return PrismaType.sortModels(filtered);
+};
+/**
+ * Get schema fields for a model (filtered and sorted)
+ */
+export const getModelFields = (model) => {
+    const filtered = PrismaType.filterSchemaFields(model.fields);
+    return PrismaType.sortFields(filtered);
+};
+/**
+ * Get implicit many-to-many join tables
+ */
+export const getManyToManyJoinTables = (dmmf) => {
+    return detectImplicitManyToMany(dmmf.datamodel.models);
+};

package/dist/src/schema-generator/prisma/relation.d.ts

@@ -0,0 +1,83 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * Metadata for implicit many-to-many join tables
+ */
+export interface JoinTableInfo {
+    /** Table name in database (e.g., "_CategoryToPost") */
+    tableName: string;
+    /** Relation name without underscore (e.g., "CategoryToPost") */
+    relationName: string;
+    /** First model name (alphabetically) */
+    modelA: string;
+    /** Second model name (alphabetically) */
+    modelB: string;
+    /** Type of column A (from modelA's ID field) */
+    columnAType: string;
+    /** Type of column B (from modelB's ID field) */
+    columnBType: string;
+    /** Whether column A is a UUID */
+    columnAIsUuid: boolean;
+    /** Whether column B is a UUID */
+    columnBIsUuid: boolean;
+}
+/**
+ * Get the ID field from a model
+ * Handles both single @id and composite @@id
+ */
+export declare function getModelIdField(model: DMMF.Model): DMMF.ReadonlyDeep<DMMF.ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    type: string;
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefault | DMMF.FieldDefaultScalar | DMMF.FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>>;
+/**
+ * Build FK field → target model mapping for a model
+ * Returns map from FK field name to target model name
+ *
+ * Detection logic: A scalar field is a FK if any relation field
+ * in the same model has this field in its `relationFromFields` array.
+ *
+ * IMPORTANT: Only includes FKs that reference the target model's ID field.
+ * FKs to non-ID unique fields (like enums) should use the target field's type,
+ * not a branded ID schema.
+ *
+ * @param model - The model to analyze
+ * @param models - All models in the datamodel (for looking up target model ID fields)
+ *
+ * @example
+ * // For Seller model with user_id FK:
+ * // fields = [
+ * //   { name: "user_id", kind: "scalar", type: "String" },
+ * //   { name: "user", kind: "object", type: "User", relationFromFields: ["user_id"], relationToFields: ["id"] }
+ * // ]
+ * // Returns: Map { "user_id" => "User" }
+ *
+ * // For Product model with market FK to market.code (enum):
+ * // fields = [
+ * //   { name: "market", kind: "scalar", type: "MARKET_TYPE" },
+ * //   { name: "market_relation", kind: "object", type: "market", relationFromFields: ["market"], relationToFields: ["code"] }
+ * // ]
+ * // Returns: Map {} (empty - code is not the ID field)
+ */
+export declare function buildForeignKeyMap(model: DMMF.Model, models?: readonly DMMF.Model[]): Map<string, string>;
+/**
+ * Detect all implicit many-to-many relations from DMMF models
+ * Returns metadata for generating join table schemas
+ */
+export declare function detectImplicitManyToMany(models: readonly DMMF.Model[]): JoinTableInfo[];

package/dist/src/schema-generator/prisma/relation.js

@@ -0,0 +1,165 @@
+import { isUuidField } from "./type.js";
+/**
+ * Detect if a relation field is part of an implicit many-to-many relation
+ * Criteria:
+ * - kind === "object" (relation field)
+ * - isList === true (many side)
+ * - relationFromFields is empty (no foreign key on this side)
+ * - relationToFields is empty (no explicit relation table)
+ */
+function isImplicitManyToManyField(field) {
+    return (field.kind === "object" &&
+        field.isList === true &&
+        field.relationFromFields !== undefined &&
+        field.relationFromFields.length === 0 &&
+        field.relationToFields !== undefined &&
+        field.relationToFields.length === 0);
+}
+/**
+ * Get the ID field from a model
+ * Handles both single @id and composite @@id
+ */
+export function getModelIdField(model) {
+    // Try to find single @id field
+    const idField = model.fields.find((f) => f.isId === true);
+    if (idField) {
+        return idField;
+    }
+    // For composite @@id, get the first field from primaryKey
+    if (model.primaryKey && model.primaryKey.fields.length > 0) {
+        const firstIdFieldName = model.primaryKey.fields[0];
+        const field = model.fields.find((f) => f.name === firstIdFieldName);
+        if (field) {
+            return field;
+        }
+    }
+    throw new Error(`Model ${model.name} has no ID field (@id or @@id required)`);
+}
+/**
+ * Build FK field → target model mapping for a model
+ * Returns map from FK field name to target model name
+ *
+ * Detection logic: A scalar field is a FK if any relation field
+ * in the same model has this field in its `relationFromFields` array.
+ *
+ * IMPORTANT: Only includes FKs that reference the target model's ID field.
+ * FKs to non-ID unique fields (like enums) should use the target field's type,
+ * not a branded ID schema.
+ *
+ * @param model - The model to analyze
+ * @param models - All models in the datamodel (for looking up target model ID fields)
+ *
+ * @example
+ * // For Seller model with user_id FK:
+ * // fields = [
+ * //   { name: "user_id", kind: "scalar", type: "String" },
+ * //   { name: "user", kind: "object", type: "User", relationFromFields: ["user_id"], relationToFields: ["id"] }
+ * // ]
+ * // Returns: Map { "user_id" => "User" }
+ *
+ * // For Product model with market FK to market.code (enum):
+ * // fields = [
+ * //   { name: "market", kind: "scalar", type: "MARKET_TYPE" },
+ * //   { name: "market_relation", kind: "object", type: "market", relationFromFields: ["market"], relationToFields: ["code"] }
+ * // ]
+ * // Returns: Map {} (empty - code is not the ID field)
+ */
+export function buildForeignKeyMap(model, models) {
+    const fkMap = new Map();
+    // Find all relation fields (kind === "object")
+    const relationFields = model.fields.filter((f) => f.kind === "object");
+    for (const relation of relationFields) {
+        if (relation.relationFromFields && relation.relationFromFields.length > 0) {
+            // Check if this FK references the target model's ID field
+            const targetModel = models?.find((m) => m.name === relation.type);
+            if (!targetModel) {
+                // Can't verify - skip this FK to be safe
+                continue;
+            }
+            // Get target model's ID field name
+            let targetIdFieldName;
+            const idField = targetModel.fields.find((f) => f.isId === true);
+            if (idField) {
+                targetIdFieldName = idField.name;
+            }
+            else if (targetModel.primaryKey && targetModel.primaryKey.fields.length > 0) {
+                targetIdFieldName = targetModel.primaryKey.fields[0];
+            }
+            if (!targetIdFieldName) {
+                // Target model has no ID field - skip
+                continue;
+            }
+            // Check if relationToFields references the ID field
+            const refersToIdField = relation.relationToFields?.length === 1 &&
+                relation.relationToFields[0] === targetIdFieldName;
+            if (!refersToIdField) {
+                // FK points to non-ID field (e.g., enum) - don't use branded ID
+                continue;
+            }
+            // Map each FK field to the target model
+            for (const fkFieldName of relation.relationFromFields) {
+                fkMap.set(fkFieldName, relation.type); // relation.type is the target model name
+            }
+        }
+    }
+    return fkMap;
+}
+/**
+ * Detect all implicit many-to-many relations from DMMF models
+ * Returns metadata for generating join table schemas
+ */
+export function detectImplicitManyToMany(models) {
+    const joinTables = new Map();
+    for (const model of models) {
+        const validFields = model.fields.filter((field) => shouldProcessField(field, model, models));
+        for (const field of validFields) {
+            const relatedModel = models.find((m) => m.name === field.type);
+            if (!(relatedModel && isValidImplicitRelation(field, relatedModel))) {
+                continue;
+            }
+            if (!field.relationName || joinTables.has(field.relationName)) {
+                continue;
+            }
+            const joinTableInfo = createJoinTableInfo(field, model, relatedModel, models);
+            if (joinTableInfo) {
+                joinTables.set(field.relationName, joinTableInfo);
+            }
+        }
+    }
+    return Array.from(joinTables.values());
+}
+function shouldProcessField(field, model, models) {
+    if (!isImplicitManyToManyField(field)) {
+        return false;
+    }
+    const relatedModel = models.find((m) => m.name === field.type);
+    return !!(relatedModel && model.name !== relatedModel.name);
+}
+function createJoinTableInfo(field, model, relatedModel, models) {
+    const modelNames = [model.name, relatedModel.name].sort();
+    const modelA = models.find((m) => m.name === modelNames[0]);
+    const modelB = models.find((m) => m.name === modelNames[1]);
+    if (!(modelA && modelB)) {
+        return null;
+    }
+    const modelAIdField = getModelIdField(modelA);
+    const modelBIdField = getModelIdField(modelB);
+    const relationName = field.relationName;
+    if (!relationName) {
+        return null;
+    }
+    return {
+        tableName: `_${relationName}`,
+        relationName,
+        modelA: modelNames[0],
+        modelB: modelNames[1],
+        columnAType: modelAIdField.type,
+        columnBType: modelBIdField.type,
+        columnAIsUuid: isUuidField(modelAIdField),
+        columnBIsUuid: isUuidField(modelBIdField),
+    };
+}
+function isValidImplicitRelation(field, relatedModel) {
+    const relatedField = relatedModel.fields.find((f) => f.relationName === field.relationName && f.isList === true);
+    return !!(relatedField && isImplicitManyToManyField(relatedField));
+}