@postxl/schema 0.0.2

package/dist/enum/enum.json-decoder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zEnumJSON = exports.zEnumNameJSON = exports.zEnumMemberJSON = exports.zEnumMemberCompact = exports.zEnumMemberJSONDetailed = exports.zEnumMemberDescriptionJSON = exports.zEnumMemberNameJSON = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+exports.zEnumMemberNameJSON = zod_1.z
+    //
+    .string()
+    .min(1, 'Value of the enum member must not be empty')
+    .describe('The value of the enum member.');
+exports.zEnumMemberDescriptionJSON = zod_1.z
+    //
+    .string()
+    .optional()
+    .describe('A helpful description of the enum member.');
+exports.zEnumMemberJSONDetailed = zod_1.z.object({
+    value: exports.zEnumMemberNameJSON,
+    description: exports.zEnumMemberDescriptionJSON,
+});
+exports.zEnumMemberCompact = exports.zEnumMemberNameJSON;
+exports.zEnumMemberJSON = zod_1.z.union([exports.zEnumMemberJSONDetailed, exports.zEnumMemberCompact], (0, utils_1.unionErrorMessage)((data) => `Enum member must either be object of type ${(0, utils_1.yellow)('{value: string; description: string}')} or just a plain ${(0, utils_1.yellow)('string')}! Instead, received ${(0, utils_1.red)(JSON.stringify(data))}.`));
+exports.zEnumNameJSON = zod_1.z
+    //
+    .string()
+    .min(1, 'Name of the enum must not be empty')
+    .refine((v) => (0, utils_1.isCamelCase)(v) || (0, utils_1.isPascalCase)(v), (v) => ({
+    message: `Enum name must be camelCase (${(0, utils_1.toCamelCase)(v)} or PascalCase ${(0, utils_1.toPascalCase)(v)})! Received ${v}.`,
+}))
+    .describe('Name of the enum.');
+exports.zEnumJSON = zod_1.z.object({
+    name: exports.zEnumNameJSON,
+    description: zod_1.z
+        //
+        .string()
+        .optional()
+        .default('')
+        .describe('A helpful description of the enum.'),
+    schema: zod_1.z
+        .string()
+        .optional()
+        .describe('The database schema that the enum belongs to. If not provided, the default schema is assumed.'),
+    databaseName: zod_1.z
+        //
+        .string()
+        .optional()
+        .describe('The name of the enum in the database.'),
+    members: zod_1.z
+        //
+        .array(exports.zEnumMemberJSON)
+        .min(1, 'Enum must have at least one member.'),
+});

package/dist/enum/enum.transformer.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { EnumJSON, EnumMemberJSON } from './enum.json-decoder';
+import type { EnumMember } from './enum.types';
+export declare function enumMemberTransformer(input: EnumMemberJSON): EnumMember;
+export type EnumEnriched = ReturnType<typeof enumTransformer>;
+export declare function enumTransformer(input: EnumJSON, ctx: z.RefinementCtx): {
+    name: string & z.BRAND<"PXL.EnumName">;
+    description: string;
+    members: Map<string & z.BRAND<"PXL.EnumValue">, EnumMember>;
+    databaseSchema: (string & z.BRAND<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & z.BRAND<"PXL.DatabaseEnumName">;
+};

package/dist/enum/enum.transformer.js

@@ -0,0 +1,76 @@
+"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.enumMemberTransformer = enumMemberTransformer;
+exports.enumTransformer = enumTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const project_schema_brands_1 = require("../project-schema/project-schema.brands");
+const Branded = __importStar(require("./enum.brands"));
+function enumMemberTransformer(input) {
+    if (typeof input === 'string') {
+        return {
+            value: Branded.toEnumValue(input),
+            description: input,
+        };
+    }
+    return {
+        value: Branded.toEnumValue(input.value),
+        description: input.description ?? input.value,
+    };
+}
+function enumTransformer(input, ctx) {
+    const members = new Map();
+    const memberValues = new Set();
+    for (const member of input.members) {
+        const enumMember = enumMemberTransformer(member);
+        if (memberValues.has(enumMember.value)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Enum ${input.name} has multiple members with the same value ${enumMember.value}!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        memberValues.add(enumMember.value);
+        members.set(enumMember.value, enumMember);
+    }
+    return {
+        name: Branded.toEnumName(input.name),
+        description: input.description,
+        members,
+        databaseSchema: input.schema ? (0, project_schema_brands_1.toDatabaseSchemaName)(input.schema) : undefined,
+        databaseName: Branded.toDatabaseEnumName(input.databaseName ?? (0, utils_1.toSnakeCase)(input.name)),
+    };
+}

package/dist/enum/enum.types.d.ts

@@ -0,0 +1,14 @@
+import { DatabaseSchemaName } from '../project-schema/project-schema.brands';
+import { DatabaseEnumName, EnumName, EnumValue } from './enum.brands';
+export type Enums = Map<EnumName, Enum>;
+export type Enum = {
+    name: EnumName;
+    description: string;
+    databaseSchema: DatabaseSchemaName;
+    databaseName: DatabaseEnumName;
+    members: Map<EnumValue, EnumMember>;
+};
+export type EnumMember = {
+    value: EnumValue;
+    description: string;
+};

package/dist/enum/enum.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/enum/index.d.ts

@@ -0,0 +1,6 @@
+export * from './enum';
+export * from './enum.brands';
+export * from './enum.defaults';
+export * from './enum.json-decoder';
+export * from './enum.transformer';
+export * from './enum.types';

package/dist/enum/index.js

@@ -0,0 +1,22 @@
+"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("./enum"), exports);
+__exportStar(require("./enum.brands"), exports);
+__exportStar(require("./enum.defaults"), exports);
+__exportStar(require("./enum.json-decoder"), exports);
+__exportStar(require("./enum.transformer"), exports);
+__exportStar(require("./enum.types"), exports);

package/dist/field/defaults.d.ts

@@ -0,0 +1,12 @@
+import * as Branded from './shared/brands';
+import { FieldJSONInput } from './field';
+export declare const standardFieldName_id: "id" & import("zod").BRAND<"PXL.FieldName"> & import("zod").BRAND<"PXL.FieldName.Id">;
+export declare const standardFieldName_createdAt: string & import("zod").BRAND<"PXL.FieldName">;
+export declare const standardFieldName_updatedAt: string & import("zod").BRAND<"PXL.FieldName">;
+export declare const standardFieldName_name: string & import("zod").BRAND<"PXL.FieldName">;
+export declare const standardFieldNames: (string & import("zod").BRAND<"PXL.FieldName">)[];
+export declare const standardField_id: FieldJSONInput;
+export declare const standardField_createdAt: FieldJSONInput;
+export declare const standardField_updatedAt: FieldJSONInput;
+export declare const standardField_name: FieldJSONInput;
+export declare const standardFields: Record<Branded.FieldName, FieldJSONInput>;

package/dist/field/defaults.js

@@ -0,0 +1,78 @@
+"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.standardFields = exports.standardField_name = exports.standardField_updatedAt = exports.standardField_createdAt = exports.standardField_id = exports.standardFieldNames = exports.standardFieldName_name = exports.standardFieldName_updatedAt = exports.standardFieldName_createdAt = exports.standardFieldName_id = void 0;
+const Branded = __importStar(require("./shared/brands"));
+exports.standardFieldName_id = Branded.toFieldIdName('id');
+exports.standardFieldName_createdAt = Branded.toFieldName('createdAt');
+exports.standardFieldName_updatedAt = Branded.toFieldName('updatedAt');
+exports.standardFieldName_name = Branded.toFieldName('name');
+exports.standardFieldNames = [
+    exports.standardFieldName_id,
+    exports.standardFieldName_createdAt,
+    exports.standardFieldName_updatedAt,
+    exports.standardFieldName_name,
+];
+exports.standardField_id = {
+    name: exports.standardFieldName_id,
+    excelName: 'Id',
+    type: 'String',
+};
+exports.standardField_createdAt = {
+    name: exports.standardFieldName_createdAt,
+    excelName: 'Created at',
+    type: 'DateTime',
+    isCreatedAt: true,
+    description: 'The date and time when the item was created.',
+};
+exports.standardField_updatedAt = {
+    name: exports.standardFieldName_updatedAt,
+    excelName: 'Updated at',
+    type: 'DateTime',
+    isUpdatedAt: true,
+    description: 'The date and time when the item was last updated. Initially, this is set to the current date and time when the item is created - but is automatically updated when the item is updated.',
+};
+exports.standardField_name = {
+    name: exports.standardFieldName_name,
+    type: 'String',
+    excelName: 'Name',
+    description: 'The name of the item.',
+};
+exports.standardFields = {
+    [exports.standardFieldName_id]: exports.standardField_id,
+    [exports.standardFieldName_createdAt]: exports.standardField_createdAt,
+    [exports.standardFieldName_updatedAt]: exports.standardField_updatedAt,
+    [exports.standardFieldName_name]: exports.standardField_name,
+};

package/dist/field/discriminated-union.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import * as Branded from './shared/brands';
+import { FieldCommon, FieldTransformer } from './shared/types';
+import * as Fields from './field';
+export type FieldKindDiscriminatedUnion = 'discriminatedUnion';
+export declare const fieldKindDiscriminatedUnion: FieldKindDiscriminatedUnion;
+export type DiscriminatedUnionMember = {
+    /**
+     * The discriminator value that is used to identify the member.
+     */
+    type: Discriminator;
+    /**
+     * A human readable label for the member.
+     */
+    label: DiscriminatorLabel;
+    /**
+     * The fields that are part of the member.
+     */
+    fields: Fields.Fields<PartOfDiscriminatedUnionMember<Fields.FieldDatabaseNative>>;
+};
+type PartOfDiscriminatedUnion<T extends Fields.FieldDatabaseNative> = T & {
+    discriminatedUnionFieldName: Branded.FieldName;
+};
+export declare function isPartOfDiscriminatedUnion<T extends Fields.FieldDatabaseNative>(field: Fields.FieldDatabaseNative): field is PartOfDiscriminatedUnion<T>;
+type PartOfDiscriminatedUnionMember<T extends Fields.FieldDatabaseNative> = PartOfDiscriminatedUnion<T> & {
+    discriminatedUnionMemberType: Discriminator;
+};
+export declare function isPartOfDiscriminatedUnionMember<T extends Fields.FieldDatabaseNative>(field: Fields.FieldDatabaseNative): field is PartOfDiscriminatedUnionMember<T>;
+export type FieldDiscriminatedUnion = FieldCommon<FieldKindDiscriminatedUnion> & {
+    type: Branded.DiscriminatedUnionType;
+    /**
+     * The name of the field that is used to discriminate the union.
+     *
+     * This is a constant name `type`.
+     */
+    discriminatorFieldName: Branded.FieldName;
+    /**
+     * The common fields that are shared by all members.
+     */
+    commonFields: Fields.Fields<PartOfDiscriminatedUnion<Fields.FieldDatabaseNative>>;
+    /**
+     * The members of the discriminated union.
+     */
+    members: Map<Discriminator, DiscriminatedUnionMember>;
+};
+export type FieldDiscriminatedUnionEnriched = ReturnType<typeof fieldDiscriminatedUnionJSONTransformer>;
+declare const zDiscriminator: z.ZodBranded<z.ZodString, "PXL.Discriminator">;
+export type Discriminator = z.infer<typeof zDiscriminator>;
+declare const zDiscriminatorLabel: z.ZodBranded<z.ZodString, "PXL.DiscriminatorLabel">;
+type DiscriminatorLabel = z.infer<typeof zDiscriminatorLabel>;
+export declare const zField: z.ZodRecord<z.ZodString, z.ZodAny>;
+/**
+ * JSON Schema for an Discriminated Union field
+ */
+export declare const zFieldDiscriminatedUnionJSON: z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    type: z.ZodUnion<[z.ZodLiteral<"DiscriminatedUnion">, z.ZodLiteral<"DiscriminatedUnion?">]>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    members: z.ZodArray<z.ZodObject<{
+        type: z.ZodEffects<z.ZodString, string, string>;
+        label: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        label?: string | undefined;
+        fields?: Record<string, any>[] | undefined;
+    }, {
+        type: string;
+        label?: string | undefined;
+        fields?: Record<string, any>[] | undefined;
+    }>, "many">;
+    commonFields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
+    isReadonly: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "DiscriminatedUnion" | "DiscriminatedUnion?";
+    name: string;
+    members: {
+        type: string;
+        label?: string | undefined;
+        fields?: Record<string, any>[] | undefined;
+    }[];
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    commonFields?: Record<string, any>[] | undefined;
+}, {
+    type: "DiscriminatedUnion" | "DiscriminatedUnion?";
+    name: string;
+    members: {
+        type: string;
+        label?: string | undefined;
+        fields?: Record<string, any>[] | undefined;
+    }[];
+    description?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    isReadonly?: boolean | undefined;
+    commonFields?: Record<string, any>[] | undefined;
+}>;
+export type FieldDiscriminatedUnionJSON = z.infer<typeof zFieldDiscriminatedUnionJSON>;
+export declare function fieldDiscriminatedUnionJSONTransformer(fieldInput: FieldDiscriminatedUnionJSON): {
+    kind: "discriminatedUnion";
+    name: string & z.BRAND<"PXL.FieldName">;
+    discriminatorFieldName: string & z.BRAND<"PXL.FieldName">;
+    label: string;
+    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
+    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    description: string | undefined;
+    members: {
+        type: string;
+        label?: string | undefined;
+        fields?: Record<string, any>[] | undefined;
+    }[];
+    commonFields: Record<string, any>[] | undefined;
+    isReadonly: boolean;
+    isRequired: boolean;
+};
+export declare const fieldDiscriminatedUnionTransformer: FieldTransformer<FieldKindDiscriminatedUnion, FieldDiscriminatedUnionEnriched, FieldDiscriminatedUnion>;
+export {};

package/dist/field/discriminated-union.js

@@ -0,0 +1,207 @@
+"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.fieldDiscriminatedUnionTransformer = exports.zFieldDiscriminatedUnionJSON = exports.zField = exports.fieldKindDiscriminatedUnion = void 0;
+exports.isPartOfDiscriminatedUnion = isPartOfDiscriminatedUnion;
+exports.isPartOfDiscriminatedUnionMember = isPartOfDiscriminatedUnionMember;
+exports.fieldDiscriminatedUnionJSONTransformer = fieldDiscriminatedUnionJSONTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const enum_1 = require("../enum");
+const model_1 = require("../model");
+const Branded = __importStar(require("./shared/brands"));
+const Decoders = __importStar(require("./shared/decoders"));
+const utils_2 = require("./shared/utils");
+const Fields = __importStar(require("./field"));
+exports.fieldKindDiscriminatedUnion = 'discriminatedUnion';
+function isPartOfDiscriminatedUnion(field) {
+    return 'discriminatedUnionFieldName' in field;
+}
+function isPartOfDiscriminatedUnionMember(field) {
+    return 'discriminatedUnionMemberType' in field;
+}
+const zDiscriminator = zod_1.z.string().brand('PXL.Discriminator');
+const toDiscriminator = (input) => zDiscriminator.parse(input);
+const zDiscriminatorLabel = zod_1.z.string().brand('PXL.DiscriminatorLabel');
+const toDiscriminatorLabel = (input) => zDiscriminatorLabel.parse(input);
+exports.zField = zod_1.z.record(zod_1.z.string(), zod_1.z.any());
+/**
+ * JSON Schema for an Discriminated Union field
+ */
+exports.zFieldDiscriminatedUnionJSON = zod_1.z.object({
+    name: Decoders.zFieldPropertyName,
+    type: zod_1.z //
+        .literal('DiscriminatedUnion')
+        .or(zod_1.z.literal('DiscriminatedUnion?'))
+        .describe('The kind of the field. This should always be `discriminatedUnion`.'),
+    label: Decoders.zFieldPropertyLabel,
+    description: Decoders.zFieldPropertyDescription,
+    databaseName: Decoders.zFieldPropertyDatabaseName,
+    excelName: Decoders.zFieldPropertyExcelName,
+    members: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z
+            .string()
+            .regex(/^[a-zA-Z0-9]*$/, 'Type name shall only contain letters and numbers.')
+            .refine((v) => v !== 'type', {
+            message: 'Element field name cannot be "type" as this is reserved for the discriminator.',
+        }),
+        label: zod_1.z.string().optional(),
+        fields: zod_1.z.array(exports.zField).optional(),
+    })),
+    commonFields: zod_1.z.array(exports.zField).optional(),
+    isReadonly: Decoders.zFieldPropertyIsReadonly,
+});
+function fieldDiscriminatedUnionJSONTransformer(fieldInput) {
+    const { isRequired } = (0, utils_2.isFieldRequired)(fieldInput.type);
+    return {
+        kind: exports.fieldKindDiscriminatedUnion,
+        name: Branded.toFieldName(fieldInput.name),
+        discriminatorFieldName: Branded.toFieldName('type'),
+        label: (0, utils_1.toHumanReadable)(fieldInput.label ?? fieldInput.name),
+        databaseName: Branded.toDatabaseFieldName(fieldInput.databaseName ?? (0, utils_1.toSnakeCase)(fieldInput.name)),
+        excelName: Branded.toExcelColumnName(fieldInput.excelName ?? fieldInput.label ?? fieldInput.name),
+        description: fieldInput.description,
+        members: fieldInput.members,
+        commonFields: fieldInput.commonFields,
+        isReadonly: fieldInput.isReadonly ?? false,
+        isRequired,
+    };
+}
+const fieldDiscriminatedUnionTransformer = ({ fieldInput, model, projectSchema }, ctx) => {
+    const modelNames = [...projectSchema.models.keys()].map((name) => (0, model_1.toModelName)(name));
+    const enumNames = [...projectSchema.enums.keys()].map((name) => (0, enum_1.toEnumName)(name));
+    // The field decoder for the fields in the discriminated union. It ensures that discriminated unions cannot be nested.
+    const zFieldDecoder = Fields.createFieldJSONDecoder({
+        modelNames,
+        enumNames,
+    }).transform((f) => {
+        if (f.kind === 'discriminatedUnion') {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Discriminated union ${model.name}.${fieldInput.name} cannot contain a discriminated unions as a field!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        return f;
+    });
+    const commonFields = new Map();
+    for (const field of fieldInput.commonFields ?? []) {
+        const decodedFieldResult = zFieldDecoder.safeParse(field);
+        if (!decodedFieldResult.success) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Error decoding common field in ${model.name}.${fieldInput.name}: ${decodedFieldResult.error.message}`,
+            });
+            return zod_1.z.NEVER;
+        }
+        const decodedField = decodedFieldResult.data;
+        const transformedField = Fields.fieldTransformer(decodedField, model, projectSchema, ctx);
+        commonFields.set(transformedField.name, addDiscriminatedUnionParent(transformedField, fieldInput.name));
+    }
+    const members = new Map();
+    for (const memberInput of fieldInput.members) {
+        const discriminator = toDiscriminator(memberInput.type);
+        const label = toDiscriminatorLabel(memberInput.label ?? memberInput.type);
+        const memberFields = new Map();
+        for (const field of memberInput.fields ?? []) {
+            const decodedFieldResult = zFieldDecoder.safeParse(field);
+            if (!decodedFieldResult.success) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Error decoding field in ${model.name}.${fieldInput.name}: ${decodedFieldResult.error.message}`,
+                });
+                return zod_1.z.NEVER;
+            }
+            const decodedField = decodedFieldResult.data;
+            if (decodedField.name === 'type') {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Field name "type" is reserved for the discriminator in discriminated union ${model.name}.${fieldInput.name}`,
+                });
+                return zod_1.z.NEVER;
+            }
+            const transformedField = Fields.fieldTransformer(decodedField, model, projectSchema, ctx);
+            memberFields.set(transformedField.name, addDiscriminatedUnionParentMember(transformedField, fieldInput.name, discriminator));
+        }
+        members.set(discriminator, {
+            type: discriminator,
+            label,
+            fields: memberFields,
+        });
+    }
+    const result = {
+        ...fieldInput,
+        modelName: model.name,
+        databaseType: Branded.toDatabaseFieldType('String'),
+        isUnique: false,
+        type: Branded.toDiscriminatedUnionType((0, utils_1.toPascalCase)(fieldInput.name)),
+        kind: 'discriminatedUnion',
+        commonFields,
+        members,
+    };
+    return result;
+};
+exports.fieldDiscriminatedUnionTransformer = fieldDiscriminatedUnionTransformer;
+function addDiscriminatedUnionParent(field, duFieldName) {
+    const result = {
+        ...field,
+        discriminatedUnionFieldName: duFieldName,
+        databaseName: ensureCustomDatabaseName({
+            name: field.name,
+            databaseName: field.databaseName,
+            newName: `${duFieldName}${(0, utils_1.toPascalCase)(field.name)}`,
+        }),
+    };
+    return result;
+}
+function addDiscriminatedUnionParentMember(field, duFieldName, duMemberType) {
+    const result = {
+        ...field,
+        discriminatedUnionFieldName: duFieldName,
+        discriminatedUnionMemberType: duMemberType,
+        databaseName: ensureCustomDatabaseName({
+            name: field.name,
+            databaseName: field.databaseName,
+            newName: `${duFieldName}${(0, utils_1.toPascalCase)(duMemberType)}${(0, utils_1.toPascalCase)(field.name)}`,
+        }),
+    };
+    return result;
+}
+function ensureCustomDatabaseName({ databaseName, name, newName, }) {
+    if (databaseName !== name && databaseName !== (0, utils_1.toSnakeCase)(name)) {
+        return databaseName;
+    }
+    return Branded.toDatabaseFieldName((0, utils_1.toSnakeCase)(newName));
+}