@postxl/schema 0.0.2

package/dist/field/field.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldTransformer = exports.zFieldJSONInput = exports.createFieldJSONDecoder = void 0;
+exports.isFieldDatabaseNative = isFieldDatabaseNative;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const discriminated_union_1 = require("./discriminated-union");
+const enum_1 = require("./enum");
+const id_1 = require("./id");
+const relation_1 = require("./relation");
+const scalar_1 = require("./scalar");
+/*
+  JSON Schema for a field
+
+  We have different kinds of fields:
+  - id: a field that is the primary key of the model
+  - scalar: a field that is not the primary key of the model
+  - relation: a field that is a relation to another model
+  - enum: a field that is an enum
+  - discriminatedUnion: a field that is a discriminated union
+
+  To differentiate between these kinds, we check the `type` of the field:
+  - if `name` is `id`, we know that it is an id field
+  - if `name` is not `id` and `type` is one of the database scalar types (e.g. `String`, `Int`, `DateTime`), we know that it is a scalar field
+  - else, we assume that it is a relation or enum field. Differentiation between these two cannot be done in the JSON schema of a field, but only on the ProjectSchema level.
+*/
+/**
+ * JSON Schema for a field
+ */
+const createFieldJSONDecoder = (params) => zod_1.z.union([
+    //
+    id_1.zFieldIdJSON.transform(id_1.fieldIdJSONTransformer),
+    scalar_1.zFieldScalarJSON.transform(scalar_1.fieldScalarJSONTransformer),
+    discriminated_union_1.zFieldDiscriminatedUnionJSON.transform(discriminated_union_1.fieldDiscriminatedUnionJSONTransformer),
+    // As relation and enum fields have flexible type names (i.e. the names of the referenced model/enum) and we use the
+    // type property to determine the type of the field, we need to handle these last
+    (0, relation_1.createRelationJSONDecoder)(params).transform(relation_1.fieldRelationJSONTransformer),
+    (0, enum_1.createEnumJSONDecoder)(params).transform(enum_1.fieldEnumJSONTransformer),
+]);
+exports.createFieldJSONDecoder = createFieldJSONDecoder;
+const zFieldJSONInput = (params) => zod_1.z.union([
+    //
+    id_1.zFieldIdJSON,
+    scalar_1.zFieldScalarJSON,
+    (0, relation_1.createRelationJSONDecoder)(params),
+    (0, enum_1.createEnumJSONDecoder)(params),
+]);
+exports.zFieldJSONInput = zFieldJSONInput;
+const fieldTransformer = (fieldInput, model, projectSchema, ctx) => {
+    switch (fieldInput.kind) {
+        case 'id':
+            return (0, id_1.fieldIdTransformer)({ fieldInput, model, projectSchema }, ctx);
+        case 'scalar':
+            return (0, scalar_1.fieldScalarTransformer)({ fieldInput, model, projectSchema }, ctx);
+        case 'discriminatedUnion':
+            return (0, discriminated_union_1.fieldDiscriminatedUnionTransformer)({ fieldInput, model, projectSchema }, ctx);
+        case 'relation':
+            return (0, relation_1.fieldRelationTransformer)({ fieldInput, model, projectSchema }, ctx);
+        case 'enum':
+            return (0, enum_1.fieldEnumTransformer)({ fieldInput, model, projectSchema }, ctx);
+        default:
+            throw new utils_1.ExhaustiveSwitchCheck(fieldInput);
+    }
+};
+exports.fieldTransformer = fieldTransformer;
+function isFieldDatabaseNative(field) {
+    return field.kind !== 'discriminatedUnion';
+}

package/dist/field/id.d.ts

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+import * as Branded from './shared/brands';
+import { FieldSeedConfig } from './shared/seed';
+import { FieldCommon, FieldTransformer } from './shared/types';
+export type FieldKindId = 'id';
+export declare const fieldKindId: FieldKindId;
+export type FieldId = Omit<FieldCommon<FieldKindId>, 'name'> & {
+    kind: 'id';
+    /**
+     * Name of the id field. We enforce that this is always `id` to lower complexity.
+     */
+    name: Branded.FieldIdName;
+    /**
+     * The branded TypeScript type of the id field, e.g. `UserId`.
+     */
+    type: Branded.IdType;
+    idType: IdGenerationType;
+    unbrandedTypeName: Branded.ScalarType;
+    /**
+     * If true, the repository will expose an index for the field.
+     */
+    hasIndex: boolean;
+    /**
+     * If true, the field is automatically set to the current date and time when the item is created.
+     */
+    isCreatedAt: false;
+    /**
+     * If true, the field is automatically set to the current date and time when the item is updated.
+     */
+    isUpdatedAt: false;
+    seed: FieldSeedConfig;
+};
+export type IdGenerationType = 
+/**
+ * A UUID is generated/used for the id field.
+ */
+'UUID'
+/**
+ * An incrementing number is used for the id field.
+ */
+ | 'Increment';
+/**
+ * JSON Schema for an id field
+ */
+export declare const zFieldIdJSON: z.ZodObject<{
+    name: z.ZodLiteral<"id">;
+    type: z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    isReadonly: z.ZodOptional<z.ZodBoolean>;
+    faker: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "String" | "Int";
+    name: "id";
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: string | undefined;
+    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
+}, {
+    type: "String" | "Int";
+    name: "id";
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: string | undefined;
+    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
+}>;
+export type FieldIdJSON = z.infer<typeof zFieldIdJSON>;
+export declare const zFieldId: z.ZodEffects<z.ZodObject<{
+    name: z.ZodLiteral<"id">;
+    type: z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    isReadonly: z.ZodOptional<z.ZodBoolean>;
+    faker: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "String" | "Int";
+    name: "id";
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: string | undefined;
+    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
+}, {
+    type: "String" | "Int";
+    name: "id";
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: string | undefined;
+    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
+}>, {
+    kind: "id";
+    name: "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
+    unbrandedTypeName: ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
+    databaseType: ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;
+    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
+    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    description: string;
+    label: string;
+    hasIndex: true;
+    isReadonly: boolean;
+    isRequired: true;
+    isUnique: true;
+    isCreatedAt: false;
+    isUpdatedAt: false;
+    seed: FieldSeedConfig;
+}, {
+    type: "String" | "Int";
+    name: "id";
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: string | undefined;
+    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
+}>;
+export declare function fieldIdJSONTransformer(fieldInput: FieldIdJSON, ctx: z.RefinementCtx): {
+    kind: "id";
+    name: "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
+    unbrandedTypeName: ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
+    databaseType: ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;
+    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
+    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    description: string;
+    label: string;
+    hasIndex: true;
+    isReadonly: boolean;
+    isRequired: true;
+    isUnique: true;
+    isCreatedAt: false;
+    isUpdatedAt: false;
+    seed: FieldSeedConfig;
+};
+export type FieldIdEnriched = ReturnType<typeof fieldIdJSONTransformer>;
+export declare const fieldIdTransformer: FieldTransformer<FieldKindId, FieldIdEnriched, FieldId>;

package/dist/field/id.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldIdTransformer = exports.zFieldId = exports.zFieldIdJSON = exports.fieldKindId = void 0;
+exports.fieldIdJSONTransformer = fieldIdJSONTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const Branded = __importStar(require("./shared/brands"));
+const Decoders = __importStar(require("./shared/decoders"));
+const seed_1 = require("./shared/seed");
+exports.fieldKindId = 'id';
+const zDatabaseType = zod_1.z
+    .union([zod_1.z.literal('String'), zod_1.z.literal('Int')])
+    .describe('The type of the field. This should either be `String` or `Int` in case name is `id`');
+function databaseTypeToFieldTypeScalar(input) {
+    switch (input) {
+        case 'String':
+            return Branded.toScalarIdType('string');
+        case 'Int':
+            return Branded.toScalarIdType('number');
+        default:
+            throw new utils_1.ExhaustiveSwitchCheck(input);
+    }
+}
+/**
+ * JSON Schema for an id field
+ */
+exports.zFieldIdJSON = zod_1.z.object({
+    name: zod_1.z.literal('id'),
+    type: zDatabaseType,
+    databaseName: Decoders.zFieldPropertyDatabaseName,
+    excelName: Decoders.zFieldPropertyExcelName,
+    label: Decoders.zFieldPropertyLabel,
+    description: Decoders.zFieldPropertyDescription,
+    isReadonly: Decoders.zFieldPropertyIsReadonly,
+    faker: Decoders.zFieldFaker,
+    seed: Decoders.zFieldSeed,
+});
+exports.zFieldId = exports.zFieldIdJSON.transform(fieldIdJSONTransformer);
+function fieldIdJSONTransformer(fieldInput, ctx) {
+    return {
+        kind: exports.fieldKindId,
+        name: Branded.toFieldIdName(fieldInput.name),
+        unbrandedTypeName: databaseTypeToFieldTypeScalar(fieldInput.type),
+        databaseType: Branded.toDatabaseFieldType(fieldInput.type),
+        databaseName: Branded.toDatabaseFieldName(fieldInput.databaseName ?? (0, utils_1.toSnakeCase)(fieldInput.name)),
+        excelName: Branded.toExcelColumnName(fieldInput.excelName ?? fieldInput.label ?? fieldInput.name),
+        description: fieldInput.description ?? '',
+        label: fieldInput.label ?? 'Id',
+        hasIndex: true,
+        isReadonly: fieldInput.isReadonly ?? false,
+        isRequired: true,
+        isUnique: true,
+        isCreatedAt: false,
+        isUpdatedAt: false,
+        seed: (0, seed_1.seedTransformer)(fieldInput, ctx),
+    };
+}
+const fieldIdTransformer = ({ fieldInput, model }) => {
+    const idType = fieldInput.unbrandedTypeName === 'string' ? 'UUID' : 'Increment';
+    return {
+        ...fieldInput,
+        modelName: model.name,
+        kind: 'id',
+        idType,
+        type: Branded.toIdType(model.name),
+        name: Branded.toFieldIdName(fieldInput.name),
+        label: fieldInput.label ?? fieldInput.name,
+        description: fieldInput.description === '' ? `The id of the ${model.name} item.` : fieldInput.description,
+    };
+};
+exports.fieldIdTransformer = fieldIdTransformer;

package/dist/field/index.d.ts

@@ -0,0 +1,11 @@
+export * from './discriminated-union';
+export * from './defaults';
+export * from './enum';
+export * from './field';
+export * from './id';
+export * from './relation';
+export * from './scalar';
+export * from './shared/brands';
+export * from './shared/seed';
+export * from './shared/utils';
+export * from './shared/types';

package/dist/field/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./discriminated-union"), exports);
+__exportStar(require("./defaults"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./field"), exports);
+__exportStar(require("./id"), exports);
+__exportStar(require("./relation"), exports);
+__exportStar(require("./scalar"), exports);
+__exportStar(require("./shared/brands"), exports);
+__exportStar(require("./shared/seed"), exports);
+__exportStar(require("./shared/utils"), exports);
+__exportStar(require("./shared/types"), exports);

package/dist/field/relation.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { ModelName } from '../model';
+import * as Branded from './shared/brands';
+import { FieldCommon, FieldTransformer } from './shared/types';
+export type FieldKindRelation = 'relation';
+export declare const fieldKindRelation: FieldKindRelation;
+export type FieldRelation = FieldCommon<FieldKindRelation> & {
+    type: Branded.IdType;
+    referencedModelName: ModelName;
+    /**
+     * The name of the field (in the Prisma schema) in the referenced model that
+     * contains the array of these items. If left empty, it defaults to "modelNamePlural"
+     * if only one relation to this model exists, otherwise an error is thrown.
+     */
+    prismaRelationFieldName: Branded.DatabaseFieldName;
+    /**
+     * If true, when cloning an entity, this relation will be deep cloned (i.e., the referenced
+     * entity will also be cloned). If false or undefined, the clone will reference the same entity.
+     *
+     * Note: Setting this to true on a relation to a readonly model will cause a validation error.
+     */
+    deepClone: boolean;
+    /**
+     * Name of the unbranded TypeScript type of the field, e.g. string
+     *
+     * Note: This should only be used in the type generator - all other generators
+     * should use the branded type "typeName"!
+     *
+     * @internal
+     */
+    unbrandedType: Branded.ScalarType;
+};
+export declare const createRelationJSONDecoder: ({ modelNames }: {
+    modelNames: ModelName[];
+}) => z.ZodObject<{
+    name: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    type: z.ZodEffects<z.ZodString, string, string>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    prismaRelationFieldName: z.ZodOptional<z.ZodString>;
+    deepClone: z.ZodOptional<z.ZodBoolean>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    isReadonly: z.ZodOptional<z.ZodBoolean>;
+    isUnique: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    isUnique?: boolean | undefined;
+    prismaRelationFieldName?: string | undefined;
+    deepClone?: boolean | undefined;
+}, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    isUnique?: boolean | undefined;
+    prismaRelationFieldName?: string | undefined;
+    deepClone?: boolean | undefined;
+}>;
+export type FieldRelationJSON = z.infer<ReturnType<typeof createRelationJSONDecoder>>;
+export declare function fieldRelationJSONTransformer(fieldInput: FieldRelationJSON): {
+    kind: "relation";
+    type: string & z.BRAND<"PXL.IdType"> & z.BRAND<"PXL.Type">;
+    name: string & z.BRAND<"PXL.FieldName">;
+    referencedModelName: string & z.BRAND<"PXL.ModelName">;
+    label: string;
+    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
+    prismaRelationFieldName: (string & z.BRAND<"PXL.DatabaseFieldName">) | undefined;
+    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    deepClone: boolean;
+    description: string | undefined;
+    isReadonly: boolean;
+    isRequired: boolean;
+    isUnique: boolean;
+    validations: never[];
+    generation: string;
+};
+export type FieldRelationEnriched = ReturnType<typeof fieldRelationJSONTransformer>;
+export declare const fieldRelationTransformer: FieldTransformer<FieldKindRelation, FieldRelationEnriched, FieldRelation>;

package/dist/field/relation.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldRelationTransformer = exports.createRelationJSONDecoder = exports.fieldKindRelation = void 0;
+exports.fieldRelationJSONTransformer = fieldRelationJSONTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const model_1 = require("../model");
+const Branded = __importStar(require("./shared/brands"));
+const Decoders = __importStar(require("./shared/decoders"));
+const utils_2 = require("./shared/utils");
+exports.fieldKindRelation = 'relation';
+const createRelationJSONDecoder = ({ modelNames }) => {
+    return zod_1.z.object({
+        name: Decoders.zFieldPropertyName.refine((name) => name.endsWith('Id'), (name) => ({ message: `Relation field name must end with 'Id' - received ${name}` })),
+        type: zod_1.z //
+            .string()
+            .describe('The name of the referenced model. If suffixed with "?", the field is optional.')
+            .transform((input, ctx) => {
+            const modelName = (0, model_1.toModelName)(input.endsWith('?') ? input.slice(0, -1) : input);
+            if (!modelNames.includes(modelName)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Model ${modelName} is not defined in the project!`,
+                });
+                return zod_1.z.NEVER;
+            }
+            return input;
+        }),
+        databaseName: Decoders.zFieldPropertyDatabaseName,
+        excelName: Decoders.zFieldPropertyExcelName,
+        prismaRelationFieldName: zod_1.z
+            //
+            .string()
+            .optional()
+            .describe('The name of the field that references the related model (e.g. `User`, `name` property would be `userId`).'),
+        deepClone: zod_1.z
+            .boolean()
+            .optional()
+            .describe('If true, when cloning an entity, this relation will be deep cloned. If false or undefined, the clone will reference the same entity.'),
+        label: Decoders.zFieldPropertyLabel,
+        description: Decoders.zFieldPropertyDescription,
+        isReadonly: Decoders.zFieldPropertyIsReadonly,
+        isUnique: Decoders.zFieldPropertyIsUnique,
+    });
+};
+exports.createRelationJSONDecoder = createRelationJSONDecoder;
+function fieldRelationJSONTransformer(fieldInput) {
+    const { isRequired, type: modelName } = (0, utils_2.isFieldRequired)(fieldInput.type);
+    const referencedModelName = (0, model_1.toModelName)(modelName);
+    const type = Branded.toIdType(referencedModelName);
+    return {
+        kind: exports.fieldKindRelation,
+        type,
+        name: Branded.toFieldName(fieldInput.name),
+        referencedModelName,
+        label: (0, utils_1.toHumanReadable)(fieldInput.label ?? fieldInput.name),
+        databaseName: Branded.toDatabaseFieldName(fieldInput.databaseName ?? (0, utils_1.toSnakeCase)(fieldInput.name)),
+        prismaRelationFieldName: fieldInput.prismaRelationFieldName
+            ? Branded.toDatabaseFieldName(fieldInput.prismaRelationFieldName)
+            : undefined,
+        excelName: Branded.toExcelColumnName(fieldInput.excelName ?? fieldInput.label ?? fieldInput.name),
+        deepClone: fieldInput.deepClone ?? false,
+        description: fieldInput.description,
+        isReadonly: fieldInput.isReadonly ?? false,
+        isRequired,
+        isUnique: fieldInput.isUnique ?? false,
+        validations: [],
+        generation: '',
+    };
+}
+const fieldRelationTransformer = ({ fieldInput, model, projectSchema }, ctx) => {
+    const referencedModel = projectSchema.models.get(fieldInput.referencedModelName);
+    if (referencedModel === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Cannot find referenced model for ${model.name}.${fieldInput.name}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    // Validate that deepClone is not set to true for readonly models
+    if (fieldInput.deepClone && referencedModel.isReadonly) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Field ${model.name}.${fieldInput.name} has deepClone set to true, but the referenced model ${referencedModel.name} is readonly. Deep cloning readonly models is not allowed.`,
+        });
+        return zod_1.z.NEVER;
+    }
+    const idField = (0, utils_2.getIdField)(model);
+    if (idField === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Cannot find id field for ${model.name}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    return {
+        ...fieldInput,
+        kind: 'relation',
+        modelName: model.name,
+        unbrandedType: idField.unbrandedTypeName,
+        databaseType: idField.databaseType,
+        prismaRelationFieldName: fieldInput.prismaRelationFieldName ?? Branded.toDatabaseFieldName((0, utils_1.pluralize)(model.name)),
+    };
+};
+exports.fieldRelationTransformer = fieldRelationTransformer;