@postxl/schema 0.0.2

package/dist/field/scalar.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+import * as Branded from './shared/brands';
+import { FieldSeedConfig } from './shared/seed';
+import { FieldCommon, FieldTransformer } from './shared/types';
+export type FieldKindScalar = 'scalar';
+export declare const fieldKindScalar: FieldKindScalar;
+export type FieldScalar = FieldScalarString | FieldScalarNumber | FieldScalarBoolean | FieldScalarDate;
+export type FieldScalarString = FieldCommon<FieldKindScalar> & FieldCommonScalar & FieldScalarStringWithValidations;
+export type FieldScalarNumber = FieldCommon<FieldKindScalar> & FieldCommonScalar & FieldScalarNumberWithValidations;
+export type FieldScalarBoolean = FieldCommon<FieldKindScalar> & FieldCommonScalar & FieldScalarBooleanNoValidation;
+export type FieldScalarDate = FieldCommon<FieldKindScalar> & FieldCommonScalar & FieldScalarDateNoValidation;
+type FieldCommonScalar = {
+    kind: 'scalar';
+    generation: string;
+    /**
+     * 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: boolean;
+    /**
+     * If true, the field is automatically set to the current date and time when the item is updated.
+     */
+    isUpdatedAt: boolean;
+    seed: FieldSeedConfig;
+    /**
+     * A generic placeholder that is used to pre-populate empty fields.
+     */
+    placeholder: string;
+};
+type FieldScalarStringWithValidations = {
+    type: 'string';
+    validations: ValidationString;
+};
+type ValidationString = {
+    maxLength: number | undefined;
+};
+type FieldScalarNumberWithValidations = {
+    type: 'number';
+    validations: ValidationNumber;
+};
+type ValidationNumber = {
+    type: 'int' | 'float';
+    min: number | undefined;
+    max: number | undefined;
+};
+type FieldScalarBooleanNoValidation = {
+    type: 'boolean';
+};
+type FieldScalarDateNoValidation = {
+    type: 'Date';
+};
+/**
+ * JSON Schema for an scalar field
+ */
+export declare const zFieldScalarJSON: z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    type: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
+    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>;
+    isUnique: z.ZodOptional<z.ZodBoolean>;
+    hasIndex: z.ZodOptional<z.ZodBoolean>;
+    isCreatedAt: z.ZodOptional<z.ZodBoolean>;
+    isUpdatedAt: z.ZodOptional<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    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">]>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    name: string;
+    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;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    isCreatedAt?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    maxLength?: number | undefined;
+    placeholder?: string | undefined;
+}, {
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    name: string;
+    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;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    isCreatedAt?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    maxLength?: number | undefined;
+    placeholder?: string | undefined;
+}>;
+export type FieldScalarJSON = z.infer<typeof zFieldScalarJSON>;
+export declare function fieldScalarJSONTransformer(fieldInput: FieldScalarJSON, ctx: z.RefinementCtx): FieldScalarEnriched;
+export type FieldScalarEnriched = Omit<FieldCommon<FieldKindScalar>, 'modelName'> & FieldCommonScalar & {
+    type: Branded.ScalarType;
+    validations: Partial<ValidationString & ValidationNumber>;
+};
+export declare const zFieldScalar: z.ZodEffects<z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    type: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
+    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>;
+    isUnique: z.ZodOptional<z.ZodBoolean>;
+    hasIndex: z.ZodOptional<z.ZodBoolean>;
+    isCreatedAt: z.ZodOptional<z.ZodBoolean>;
+    isUpdatedAt: z.ZodOptional<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    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">]>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    name: string;
+    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;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    isCreatedAt?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    maxLength?: number | undefined;
+    placeholder?: string | undefined;
+}, {
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    name: string;
+    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;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    isCreatedAt?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    maxLength?: number | undefined;
+    placeholder?: string | undefined;
+}>, FieldScalarEnriched, {
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    name: string;
+    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;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    isCreatedAt?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    maxLength?: number | undefined;
+    placeholder?: string | undefined;
+}>;
+export declare const fieldScalarTransformer: FieldTransformer<FieldKindScalar, FieldScalarEnriched, FieldScalar>;
+export {};

package/dist/field/scalar.js

@@ -0,0 +1,197 @@
+"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.fieldScalarTransformer = exports.zFieldScalar = exports.zFieldScalarJSON = exports.fieldKindScalar = void 0;
+exports.fieldScalarJSONTransformer = fieldScalarJSONTransformer;
+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");
+const utils_2 = require("./shared/utils");
+exports.fieldKindScalar = 'scalar';
+const zDatabaseType = zod_1.z
+    .union([
+    zod_1.z.literal('String').or(zod_1.z.literal('String?')),
+    zod_1.z.literal('Boolean').or(zod_1.z.literal('Boolean?')),
+    zod_1.z.literal('DateTime').or(zod_1.z.literal('DateTime?')),
+    zod_1.z.literal('Decimal').or(zod_1.z.literal('Decimal?')),
+    zod_1.z.literal('Float').or(zod_1.z.literal('Float?')),
+    zod_1.z.literal('Int').or(zod_1.z.literal('Int?')),
+    zod_1.z.literal('Json').or(zod_1.z.literal('Json?')),
+    zod_1.z.literal('Bytes').or(zod_1.z.literal('Bytes?')),
+    zod_1.z.literal('BigInt').or(zod_1.z.literal('BigInt?')),
+])
+    .describe('The type of the field. Should be a native database type.');
+function databaseTypeToFieldTypeScalar(input, ctx) {
+    switch (input) {
+        case 'String':
+        case 'String?':
+            return Branded.toScalarType('string');
+        case 'Boolean':
+        case 'Boolean?':
+            return Branded.toScalarType('boolean');
+        case 'DateTime':
+        case 'DateTime?':
+            return Branded.toScalarType('Date');
+        case 'Decimal':
+        case 'Decimal?':
+        case 'Float':
+        case 'Float?':
+        case 'Int':
+        case 'Int?':
+            return Branded.toScalarType('number');
+        case 'Json':
+        case 'Json?':
+        case 'Bytes':
+        case 'Bytes?':
+        case 'BigInt':
+        case 'BigInt?':
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Support for DatabaseType ${input} is not implemented yet!`,
+            });
+            return zod_1.z.NEVER;
+        default:
+            throw new utils_1.ExhaustiveSwitchCheck(input);
+    }
+}
+/**
+ * JSON Schema for an scalar field
+ */
+exports.zFieldScalarJSON = zod_1.z
+    .object({
+    name: Decoders.zFieldPropertyName,
+    type: zDatabaseType,
+    databaseName: Decoders.zFieldPropertyDatabaseName,
+    excelName: Decoders.zFieldPropertyExcelName,
+    label: Decoders.zFieldPropertyLabel,
+    description: Decoders.zFieldPropertyDescription,
+    isReadonly: Decoders.zFieldPropertyIsReadonly,
+    isUnique: Decoders.zFieldPropertyIsUnique,
+    hasIndex: Decoders.zFieldPropertyHasIndex,
+    isCreatedAt: Decoders.zFieldPropertyIsCreatedAt,
+    isUpdatedAt: Decoders.zFieldPropertyIsUpdatedAt,
+    maxLength: Decoders.zFieldPropertyMaxLength,
+    faker: Decoders.zFieldFaker,
+    seed: Decoders.zFieldSeed,
+    placeholder: Decoders.zFieldPropertyPlaceholder,
+})
+    .strict();
+const defaultPlaceholders = {
+    String: (label) => `${label} here...`,
+    Boolean: () => 'true',
+    DateTime: () => '2025-03-01T12: () =>00: () =>00.000Z',
+    Decimal: () => '1234.56',
+    Float: () => '1234.56',
+    Int: () => '1234',
+    Json: () => '{}',
+    Bytes: () => '1234',
+    BigInt: () => '1234',
+};
+function fieldScalarJSONTransformer(fieldInput, ctx) {
+    const isCreatedAt = fieldInput.isCreatedAt ?? false;
+    const isUpdatedAt = fieldInput.isUpdatedAt ?? false;
+    const required = (0, utils_2.isFieldRequired)(fieldInput.type);
+    const isRequired = isCreatedAt || isUpdatedAt ? false : required.isRequired;
+    const databaseType = Branded.toDatabaseFieldType(required.type);
+    const type = databaseTypeToFieldTypeScalar(databaseType, ctx);
+    const label = fieldInput.label ?? (0, utils_1.toHumanReadable)(fieldInput.name);
+    const placeholder = fieldInput.placeholder ?? defaultPlaceholders[databaseType](label);
+    return {
+        type,
+        kind: exports.fieldKindScalar,
+        name: Branded.toFieldName(fieldInput.name),
+        databaseType,
+        databaseName: Branded.toDatabaseFieldName(fieldInput.databaseName ?? (0, utils_1.toSnakeCase)(fieldInput.name)),
+        excelName: Branded.toExcelColumnName(fieldInput.excelName ?? fieldInput.label ?? fieldInput.name),
+        description: fieldInput.description,
+        label,
+        hasIndex: fieldInput.hasIndex ?? false,
+        isReadonly: fieldInput.isReadonly ?? (isCreatedAt || isUpdatedAt),
+        isRequired,
+        isUnique: fieldInput.isUnique ?? false,
+        isCreatedAt,
+        isUpdatedAt,
+        generation: '',
+        validations: {
+            maxLength: fieldInput.maxLength,
+            min: undefined,
+            max: undefined,
+        },
+        seed: (0, seed_1.seedTransformer)(fieldInput, ctx),
+        placeholder,
+    };
+}
+exports.zFieldScalar = exports.zFieldScalarJSON.transform(fieldScalarJSONTransformer);
+const fieldScalarTransformer = ({ fieldInput: { type, validations, ...shared }, model: { name: modelName }, }) => {
+    switch (type) {
+        case 'string':
+            return {
+                type,
+                validations: {
+                    maxLength: validations.maxLength,
+                },
+                ...shared,
+                modelName,
+            };
+        case 'number':
+            return {
+                type,
+                validations: {
+                    type: shared.databaseType === 'Int' ? 'int' : 'float',
+                    min: validations.min,
+                    max: validations.max,
+                },
+                ...shared,
+                modelName,
+            };
+        case 'boolean':
+            return {
+                type,
+                ...shared,
+                modelName,
+            };
+        case 'Date':
+            return {
+                type,
+                ...shared,
+                modelName,
+            };
+        default:
+            throw new utils_1.ExhaustiveSwitchCheck(type);
+    }
+};
+exports.fieldScalarTransformer = fieldScalarTransformer;

package/dist/field/shared/brands.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ModelName } from '../../model/model.brands';
+export declare const zFieldName: z.ZodBranded<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, "PXL.FieldName">;
+export type FieldName = z.infer<typeof zFieldName>;
+export declare const toFieldName: (input: string) => string & z.BRAND<"PXL.FieldName">;
+export declare const zFieldIdName: z.ZodBranded<z.ZodBranded<z.ZodLiteral<"id">, "PXL.FieldName">, "PXL.FieldName.Id">;
+export type FieldIdName = z.infer<typeof zFieldIdName>;
+export declare const toFieldIdName: (input: string) => "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
+export declare const zDatabaseFieldName: z.ZodBranded<z.ZodString, "PXL.DatabaseFieldName">;
+export type DatabaseFieldName = z.infer<typeof zDatabaseFieldName>;
+export declare const toDatabaseFieldName: (input: string) => string & z.BRAND<"PXL.DatabaseFieldName">;
+export declare const zExcelColumnName: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.ExcelColumnName">;
+export type ExcelColumnName = z.infer<typeof zExcelColumnName>;
+export declare const toExcelColumnName: (input: string) => string & z.BRAND<"PXL.ExcelColumnName">;
+export declare const zFieldLabel: z.ZodBranded<z.ZodString, "PXL.FieldLabel">;
+export type FieldLabel = z.infer<typeof zFieldLabel>;
+export declare const toFieldLabel: (input: string) => string & z.BRAND<"PXL.FieldLabel">;
+export declare const zType: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.Type">;
+export type Type = z.infer<typeof zType>;
+export declare const toType: (input: string) => string & z.BRAND<"PXL.Type">;
+export declare const zIdType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.IdType">, "PXL.Type">;
+export type IdType = z.infer<typeof zIdType>;
+export declare const toIdType: (input: ModelName) => string & z.BRAND<"PXL.IdType"> & z.BRAND<"PXL.Type">;
+export declare const zScalarType: z.ZodBranded<z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"Date">]>, "PXL.ScalarType">, "PXL.Type">;
+export type ScalarType = z.infer<typeof zScalarType>;
+export declare const toScalarType: (input: string) => (("string" | "number" | "boolean" | "Date") & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
+export declare const zScalarIdType: z.ZodBranded<z.ZodBranded<z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"string">, z.ZodLiteral<"number">]>, "PXL.ScalarIdType">, "PXL.ScalarType">, "PXL.Type">;
+export type ScalarIdType = z.infer<typeof zScalarIdType>;
+export declare const toScalarIdType: (input: string) => ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
+export declare const zEnumType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.EnumType">, "PXL.Type">;
+export type EnumType = z.infer<typeof zEnumType>;
+export declare const toEnumType: (input: string) => string & z.BRAND<"PXL.EnumType"> & z.BRAND<"PXL.Type">;
+export declare const zDiscriminatedUnionType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.DiscriminatedUnionType">, "PXL.Type">;
+export type DiscriminatedUnionType = z.infer<typeof zDiscriminatedUnionType>;
+export declare const toDiscriminatedUnionType: (input: string) => string & z.BRAND<"PXL.DiscriminatedUnionType"> & z.BRAND<"PXL.Type">;
+export declare const zDatabaseFieldType: z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"String">, z.ZodLiteral<"Boolean">, z.ZodLiteral<"DateTime">, z.ZodLiteral<"Decimal">, z.ZodLiteral<"Float">, z.ZodLiteral<"Int">, z.ZodLiteral<"Json">, z.ZodLiteral<"Bytes">]>, "PXL.DatabaseFieldType">;
+export type DatabaseFieldType = z.infer<typeof zDatabaseFieldType>;
+export declare const toDatabaseFieldType: (input: string) => ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;

package/dist/field/shared/brands.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatabaseFieldType = exports.zDatabaseFieldType = exports.toDiscriminatedUnionType = exports.zDiscriminatedUnionType = exports.toEnumType = exports.zEnumType = exports.toScalarIdType = exports.zScalarIdType = exports.toScalarType = exports.zScalarType = exports.toIdType = exports.zIdType = exports.toType = exports.zType = exports.toFieldLabel = exports.zFieldLabel = exports.toExcelColumnName = exports.zExcelColumnName = exports.toDatabaseFieldName = exports.zDatabaseFieldName = exports.toFieldIdName = exports.zFieldIdName = exports.toFieldName = exports.zFieldName = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+// --- Names ---------------------------------------------------------------------------------------
+exports.zFieldName = zod_1.z
+    .string()
+    .refine(utils_1.isCamelCase, (s) => ({ message: `Field name must be camelCase - received ${s}, expected ${(0, utils_1.toCamelCase)(s)}` }))
+    .refine((s) => !s.endsWith('?'), (s) => ({
+    message: `Field name "${s}" must not end with '?'! If you want to make a field optional, add "?" to the 'type' property, not to 'name'!`,
+}))
+    .brand('PXL.FieldName');
+const toFieldName = (input) => exports.zFieldName.parse(input);
+exports.toFieldName = toFieldName;
+exports.zFieldIdName = zod_1.z.literal('id').brand('PXL.FieldName').brand('PXL.FieldName.Id');
+const toFieldIdName = (input) => exports.zFieldIdName.parse(input);
+exports.toFieldIdName = toFieldIdName;
+exports.zDatabaseFieldName = zod_1.z.string().brand('PXL.DatabaseFieldName');
+const toDatabaseFieldName = (input) => exports.zDatabaseFieldName.parse(input);
+exports.toDatabaseFieldName = toDatabaseFieldName;
+exports.zExcelColumnName = zod_1.z
+    .string()
+    .transform((name) => (0, utils_1.toExcelColumnName)(name))
+    .brand('PXL.ExcelColumnName');
+const toExcelColumnName = (input) => exports.zExcelColumnName.parse(input);
+exports.toExcelColumnName = toExcelColumnName;
+exports.zFieldLabel = zod_1.z.string().brand('PXL.FieldLabel');
+const toFieldLabel = (input) => exports.zFieldLabel.parse(input);
+exports.toFieldLabel = toFieldLabel;
+// --- Types ---------------------------------------------------------------------------------------
+exports.zType = zod_1.z
+    .string()
+    .refine(utils_1.isPascalCase, (s) => ({ message: `Type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}` }))
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type');
+const toType = (input) => exports.zType.parse(input);
+exports.toType = toType;
+exports.zIdType = zod_1.z
+    .string()
+    .refine(utils_1.isPascalCase, (s) => ({ message: `Id type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}` }))
+    .brand('PXL.IdType')
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type that represents an id field of a model, e.g. `UserId`');
+const toIdType = (input) => {
+    const name = `${input}Id`;
+    return exports.zIdType.parse(name);
+};
+exports.toIdType = toIdType;
+exports.zScalarType = zod_1.z
+    .union([
+    //
+    zod_1.z.literal('string'),
+    zod_1.z.literal('number'),
+    zod_1.z.literal('boolean'),
+    zod_1.z.literal('Date'),
+])
+    .brand('PXL.ScalarType')
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type that represents a scalar field, e.g. `string`');
+const toScalarType = (input) => exports.zScalarType.parse(input);
+exports.toScalarType = toScalarType;
+exports.zScalarIdType = zod_1.z
+    .union([
+    //
+    zod_1.z.literal('string'),
+    zod_1.z.literal('number'),
+])
+    .brand('PXL.ScalarIdType')
+    .brand('PXL.ScalarType')
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type that represents a scalar Id field, i.e. `string` or `number`');
+const toScalarIdType = (input) => exports.zScalarIdType.parse(input);
+exports.toScalarIdType = toScalarIdType;
+exports.zEnumType = zod_1.z
+    .string()
+    .refine(utils_1.isPascalCase, (s) => ({
+    message: `Enum name must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}`,
+}))
+    .brand('PXL.EnumType')
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type that represents an enum, e.g. `ActionStatus`');
+const toEnumType = (input) => exports.zEnumType.parse(input);
+exports.toEnumType = toEnumType;
+exports.zDiscriminatedUnionType = zod_1.z
+    .string()
+    .refine(utils_1.isPascalCase, { message: 'Discriminated union name must be PascalCase' })
+    .brand('PXL.DiscriminatedUnionType')
+    .brand('PXL.Type')
+    .describe('The name of the TypeScript type that represents a discriminated union, e.g. `ActionStatus`');
+const toDiscriminatedUnionType = (input) => exports.zDiscriminatedUnionType.parse(input);
+exports.toDiscriminatedUnionType = toDiscriminatedUnionType;
+// --- Database ---------------------------------------------------------------------------------------
+exports.zDatabaseFieldType = zod_1.z
+    .union([
+    zod_1.z.literal('BigInt'),
+    zod_1.z.literal('String'),
+    zod_1.z.literal('Boolean'),
+    zod_1.z.literal('DateTime'),
+    zod_1.z.literal('Decimal'),
+    zod_1.z.literal('Float'),
+    zod_1.z.literal('Int'),
+    zod_1.z.literal('Json'),
+    zod_1.z.literal('Bytes'),
+])
+    .brand('PXL.DatabaseFieldType')
+    .describe('The name of the database type, e.g. `BigInt`, `String`, `Boolean`, `DateTime`');
+const toDatabaseFieldType = (input) => exports.zDatabaseFieldType.parse(input);
+exports.toDatabaseFieldType = toDatabaseFieldType;

package/dist/field/shared/decoders.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const zFieldPropertyName: z.ZodEffects<z.ZodString, string, string>;
+export declare const zFieldPropertyType: z.ZodString;
+export declare const zFieldPropertyDatabaseName: z.ZodOptional<z.ZodString>;
+export declare const zFieldPropertyExcelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare const zFieldPropertyLabel: z.ZodOptional<z.ZodString>;
+export declare const zFieldPropertyDescription: z.ZodOptional<z.ZodString>;
+export declare const zFieldPropertyIsReadonly: z.ZodOptional<z.ZodBoolean>;
+export declare const zFieldPropertyIsUnique: z.ZodOptional<z.ZodBoolean>;
+export declare const zFieldPropertyHasIndex: z.ZodOptional<z.ZodBoolean>;
+export declare const zFieldPropertyIsCreatedAt: z.ZodOptional<z.ZodBoolean>;
+export declare const zFieldPropertyIsUpdatedAt: z.ZodOptional<z.ZodBoolean>;
+export declare const zFieldPropertyMaxLength: z.ZodOptional<z.ZodNumber>;
+export declare const zFieldFaker: z.ZodOptional<z.ZodString>;
+export declare const zScalarValue: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>;
+export declare const zFieldSeed: 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">]>>;
+export declare const zFieldPropertyPlaceholder: z.ZodOptional<z.ZodString>;

package/dist/field/shared/decoders.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zFieldPropertyPlaceholder = exports.zFieldSeed = exports.zScalarValue = exports.zFieldFaker = exports.zFieldPropertyMaxLength = exports.zFieldPropertyIsUpdatedAt = exports.zFieldPropertyIsCreatedAt = exports.zFieldPropertyHasIndex = exports.zFieldPropertyIsUnique = exports.zFieldPropertyIsReadonly = exports.zFieldPropertyDescription = exports.zFieldPropertyLabel = exports.zFieldPropertyExcelName = exports.zFieldPropertyDatabaseName = exports.zFieldPropertyType = exports.zFieldPropertyName = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+exports.zFieldPropertyName = zod_1.z
+    //
+    .string()
+    .min(1, 'Name of the field must not be empty')
+    .refine((name) => (0, utils_1.toCamelCase)(name) === name, (name) => ({ message: `Field name must be camelCased, but is ${(0, utils_1.red)(name)}!` }))
+    .describe('Name of the field. Must be camelCased.');
+exports.zFieldPropertyType = zod_1.z
+    .string()
+    .min(1, 'Type of the field must not be empty')
+    .describe(`The type of the field. This should either be:
+* \`String\` or \`Int\` in case name is \`id\
+* \`String\`, \`Int\`, \`Float\` or \`DateTime\` for scalar fields
+* A model name for relation fields
+* An enum name for enum fields
+ 
+Note: If type ends with an \`?\`, the field is optional, else it is required.`);
+exports.zFieldPropertyDatabaseName = zod_1.z
+    .string()
+    .optional()
+    .describe('Mapping of the field to the database column. If not provided, we use the snakecase of `name` field.');
+exports.zFieldPropertyExcelName = zod_1.z
+    .string()
+    .optional()
+    .refine((val) => val === undefined || val === (0, utils_1.toExcelColumnName)(val), (val) => ({
+    message: `Excel column name "${(0, utils_1.red)(val ?? '')}" is not a valid Excel table name. It must start with a letter or underscore and can only contain letters, numbers, and underscores.`,
+}))
+    .describe('Mapping of the field to an Excel column name. If not provided, we use the `label` field.');
+exports.zFieldPropertyLabel = zod_1.z
+    .string()
+    .optional()
+    .describe('The human readable label/name of the field. Used for instance in generated forms to label fields.\n\nIf not provided, we use the `name` field.');
+exports.zFieldPropertyDescription = zod_1.z
+    .string()
+    .optional()
+    .describe('A helpful description of the field. Will be used as JSDoc documentation in the generated type.');
+// Flags
+exports.zFieldPropertyIsReadonly = zod_1.z
+    //
+    .boolean()
+    .optional()
+    .describe('If true, the field is readonly, ie. it cannot be changed by the user.');
+exports.zFieldPropertyIsUnique = zod_1.z
+    //
+    .boolean()
+    .optional()
+    .describe('If true, uniqueness is enforced for the field, ie no two items can have the same value for this field.');
+exports.zFieldPropertyHasIndex = zod_1.z
+    //
+    .boolean()
+    .optional()
+    .describe('If true, the repository will expose an index for the field.');
+exports.zFieldPropertyIsCreatedAt = zod_1.z
+    //
+    .boolean()
+    .optional()
+    .describe('If true, the field is automatically set to the current date and time when the item is created.');
+exports.zFieldPropertyIsUpdatedAt = zod_1.z
+    //
+    .boolean()
+    .optional()
+    .describe('If true, the field is automatically set to the current date and time when the item is updated.');
+exports.zFieldPropertyMaxLength = zod_1.z
+    //
+    .number()
+    .positive()
+    .int()
+    .optional()
+    .describe('If provided, the maximum length of the field. Only applicable for `String` fields.');
+exports.zFieldFaker = zod_1.z
+    //
+    .string()
+    .optional()
+    .describe('The faker function to use for the field. If neither faker nor seed is provided, we use the default faker function for the field type.');
+exports.zScalarValue = zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean(), zod_1.z.date()]);
+exports.zFieldSeed = exports.zScalarValue
+    .or(zod_1.z.array(exports.zScalarValue))
+    .optional()
+    .describe('The seed data for the field. If not provided, we use the faker function for the field type.');
+exports.zFieldPropertyPlaceholder = zod_1.z
+    //
+    .string()
+    .optional()
+    .describe('A generic placeholder that is used to pre-populate empty fields.');