@postxl/schema 1.7.0 → 1.8.1

package/dist/field/discriminated-union.js

@@ -134,6 +134,13 @@ const fieldDiscriminatedUnionTransformer = ({ fieldInput, model, projectSchema }
             });
             return zod_1.z.NEVER;
         }
+        if (f.kind === 'json') {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Discriminated union ${model.name}.${fieldInput.name} cannot contain JSON fields yet.`,
+            });
+            return zod_1.z.NEVER;
+        }
         return f;
     });
     const commonFields = new Map();

package/dist/field/field.d.ts

@@ -5,6 +5,7 @@ import * as Branded from './shared/brands';
 import { FieldDiscriminatedUnion, FieldDiscriminatedUnionEnriched } from './discriminated-union';
 import { FieldEnum, FieldEnumEnriched } from './enum';
 import { FieldId, FieldIdEnriched } from './id';
+import { FieldJson, FieldJsonEnriched } from './json';
 import { FieldRelation, FieldRelationEnriched } from './relation';
 import { FieldScalar, FieldScalarEnriched } from './scalar';
 /**
@@ -51,7 +52,7 @@ export declare const createFieldJSONDecoder: (params: {
     seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
 }>>, z.ZodPipe<z.ZodObject<{
     name: z.ZodString;
-    type: z.ZodUnion<readonly [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?">]>]>;
+    type: z.ZodUnion<readonly [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<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
     excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
@@ -67,7 +68,7 @@ export declare const createFieldJSONDecoder: (params: {
     placeholder: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodTransform<FieldScalarEnriched, {
     name: string;
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Bytes?" | "BigInt?";
     databaseName?: string | undefined;
     excelName?: string | undefined;
     label?: string | undefined;
@@ -81,6 +82,28 @@ export declare const createFieldJSONDecoder: (params: {
     faker?: string | undefined;
     seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
     placeholder?: string | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"Json">, z.ZodLiteral<"JSON">, z.ZodLiteral<"Json?">, z.ZodLiteral<"JSON?">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodOptional<z.ZodString>;
+    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>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<FieldJsonEnriched, {
+    name: string;
+    type: "Json" | "JSON" | "Json?" | "JSON?";
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    isReadonly?: boolean | undefined;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    placeholder?: string | undefined;
 }>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     name: z.ZodString;
     type: z.ZodUnion<[z.ZodLiteral<"DiscriminatedUnion">, z.ZodLiteral<"DiscriminatedUnion?">]>;
@@ -194,8 +217,8 @@ export declare const createFieldJSONDecoder: (params: {
     isReadonly?: boolean | undefined;
     isUnique?: boolean | undefined;
 }>>]>;
-export type FieldEnriched = FieldIdEnriched | FieldScalarEnriched | FieldRelationEnriched | FieldEnumEnriched | FieldDiscriminatedUnionEnriched;
-export type FieldEnrichedNativeDatabase = FieldIdEnriched | FieldScalarEnriched | FieldRelationEnriched | FieldEnumEnriched;
+export type FieldEnriched = FieldIdEnriched | FieldScalarEnriched | FieldJsonEnriched | FieldRelationEnriched | FieldEnumEnriched | FieldDiscriminatedUnionEnriched;
+export type FieldEnrichedNativeDatabase = FieldIdEnriched | FieldScalarEnriched | FieldJsonEnriched | FieldRelationEnriched | FieldEnumEnriched;
 export declare const zFieldJSONInput: (params: {
     modelNames: Model.ModelName[];
     enumNames: Enum.EnumName[];
@@ -211,7 +234,7 @@ export declare const zFieldJSONInput: (params: {
     seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
 }, z.core.$strip>, z.ZodObject<{
     name: z.ZodString;
-    type: z.ZodUnion<readonly [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?">]>]>;
+    type: z.ZodUnion<readonly [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<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
     excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
@@ -225,6 +248,17 @@ export declare const zFieldJSONInput: (params: {
     faker: z.ZodOptional<z.ZodString>;
     seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
     placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"Json">, z.ZodLiteral<"JSON">, z.ZodLiteral<"Json?">, z.ZodLiteral<"JSON?">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodOptional<z.ZodString>;
+    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>;
+    placeholder: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     name: z.ZodString;
     type: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
@@ -256,8 +290,8 @@ export declare const fieldTransformer: (fieldInput: FieldEnriched, model: {
         name: Model.ModelName;
         isReadonly?: boolean;
     }>;
-}, ctx: z.RefinementCtx) => FieldId | FieldScalar | FieldRelation | FieldEnum | FieldDiscriminatedUnion;
-export type FieldDatabaseNative = FieldId | FieldScalar | FieldRelation | FieldEnum;
+}, ctx: z.RefinementCtx) => FieldJson | FieldId | FieldScalar | FieldRelation | FieldEnum | FieldDiscriminatedUnion;
+export type FieldDatabaseNative = FieldId | FieldScalar | FieldJson | FieldRelation | FieldEnum;
 export declare function isFieldDatabaseNative(field: Field): field is FieldDatabaseNative;
 export type Field = FieldDatabaseNative | FieldDiscriminatedUnion;
 export type Fields<FIELD = Field> = Map<Branded.FieldName, FIELD>;

package/dist/field/field.js

@@ -7,6 +7,7 @@ const utils_1 = require("@postxl/utils");
 const discriminated_union_1 = require("./discriminated-union");
 const enum_1 = require("./enum");
 const id_1 = require("./id");
+const json_1 = require("./json");
 const relation_1 = require("./relation");
 const scalar_1 = require("./scalar");
 /*
@@ -15,6 +16,7 @@ const scalar_1 = require("./scalar");
   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
+  - json: a JSON field stored as database Json and typed as unknown
   - 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
@@ -31,6 +33,7 @@ const createFieldJSONDecoder = (params) => zod_1.z.union([
     //
     id_1.zFieldIdJSON.transform(id_1.fieldIdJSONTransformer),
     scalar_1.zFieldScalarJSON.transform(scalar_1.fieldScalarJSONTransformer),
+    json_1.zFieldJsonJSON.transform(json_1.fieldJsonJSONTransformer),
     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
@@ -42,6 +45,7 @@ const zFieldJSONInput = (params) => zod_1.z.union([
     //
     id_1.zFieldIdJSON,
     scalar_1.zFieldScalarJSON,
+    json_1.zFieldJsonJSON,
     (0, relation_1.createRelationJSONDecoder)(params),
     (0, enum_1.createEnumJSONDecoder)(params),
 ]);
@@ -52,6 +56,8 @@ const fieldTransformer = (fieldInput, model, projectSchema, ctx) => {
             return (0, id_1.fieldIdTransformer)({ fieldInput, model, projectSchema }, ctx);
         case 'scalar':
             return (0, scalar_1.fieldScalarTransformer)({ fieldInput, model, projectSchema }, ctx);
+        case 'json':
+            return (0, json_1.fieldJsonTransformer)({ fieldInput, model, projectSchema }, ctx);
         case 'discriminatedUnion':
             return (0, discriminated_union_1.fieldDiscriminatedUnionTransformer)({ fieldInput, model, projectSchema }, ctx);
         case 'relation':

package/dist/field/index.d.ts

@@ -3,6 +3,7 @@ export * from './defaults';
 export * from './enum';
 export * from './field';
 export * from './id';
+export * from './json';
 export * from './relation';
 export * from './scalar';
 export * from './shared/brands';

package/dist/field/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./defaults"), exports);
 __exportStar(require("./enum"), exports);
 __exportStar(require("./field"), exports);
 __exportStar(require("./id"), exports);
+__exportStar(require("./json"), exports);
 __exportStar(require("./relation"), exports);
 __exportStar(require("./scalar"), exports);
 __exportStar(require("./shared/brands"), exports);

package/dist/field/json.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { FieldCommon, FieldTransformer } from './shared/types';
+export type FieldKindJson = 'json';
+export declare const fieldKindJson: FieldKindJson;
+export type FieldJson = FieldCommon<FieldKindJson> & {
+    /**
+     * JSON fields are typed as unknown in generated model types by default.
+     */
+    type: 'unknown';
+    /**
+     * If true, the repository will expose an index for the field.
+     */
+    hasIndex: boolean;
+    generation: string;
+    /**
+     * A generic placeholder that is used to pre-populate empty fields.
+     */
+    placeholder: string;
+};
+/**
+ * JSON Schema for a json field.
+ */
+export declare const zFieldJsonJSON: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"Json">, z.ZodLiteral<"JSON">, z.ZodLiteral<"Json?">, z.ZodLiteral<"JSON?">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodOptional<z.ZodString>;
+    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>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FieldJsonJSON = z.infer<typeof zFieldJsonJSON>;
+export declare function fieldJsonJSONTransformer(fieldInput: FieldJsonJSON): FieldJsonEnriched;
+export type FieldJsonEnriched = Omit<FieldJson, 'modelName'>;
+export declare const zFieldJson: z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"Json">, z.ZodLiteral<"JSON">, z.ZodLiteral<"Json?">, z.ZodLiteral<"JSON?">]>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodOptional<z.ZodString>;
+    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>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<FieldJsonEnriched, {
+    name: string;
+    type: "Json" | "JSON" | "Json?" | "JSON?";
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    isReadonly?: boolean | undefined;
+    isUnique?: boolean | undefined;
+    hasIndex?: boolean | undefined;
+    placeholder?: string | undefined;
+}>>;
+export declare const fieldJsonTransformer: FieldTransformer<FieldKindJson, FieldJsonEnriched, FieldJson>;

package/dist/field/json.js

@@ -0,0 +1,92 @@
+"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.fieldJsonTransformer = exports.zFieldJson = exports.zFieldJsonJSON = exports.fieldKindJson = void 0;
+exports.fieldJsonJSONTransformer = fieldJsonJSONTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const Branded = __importStar(require("./shared/brands"));
+const Decoders = __importStar(require("./shared/decoders"));
+const utils_2 = require("./shared/utils");
+exports.fieldKindJson = 'json';
+const zDatabaseTypeJson = zod_1.z
+    .union([zod_1.z.literal('Json'), zod_1.z.literal('JSON'), zod_1.z.literal('Json?'), zod_1.z.literal('JSON?')])
+    .describe('The type of the field. This should be `Json`/`JSON` or `Json?`/`JSON?`.');
+/**
+ * JSON Schema for a json field.
+ */
+exports.zFieldJsonJSON = zod_1.z
+    .object({
+    name: Decoders.zFieldPropertyName,
+    type: zDatabaseTypeJson,
+    databaseName: Decoders.zFieldPropertyDatabaseName,
+    excelName: Decoders.zFieldPropertyExcelName,
+    label: Decoders.zFieldPropertyLabel,
+    description: Decoders.zFieldPropertyDescription,
+    isReadonly: Decoders.zFieldPropertyIsReadonly,
+    isUnique: Decoders.zFieldPropertyIsUnique,
+    hasIndex: Decoders.zFieldPropertyHasIndex,
+    placeholder: Decoders.zFieldPropertyPlaceholder,
+})
+    .strict();
+function fieldJsonJSONTransformer(fieldInput) {
+    const required = (0, utils_2.isFieldRequired)(fieldInput.type);
+    const label = fieldInput.label ?? (0, utils_1.toHumanReadable)(fieldInput.name);
+    return {
+        kind: exports.fieldKindJson,
+        type: 'unknown',
+        name: Branded.toFieldName(fieldInput.name),
+        databaseType: Branded.toDatabaseFieldType('Json'),
+        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 ?? false,
+        isRequired: required.isRequired,
+        isUnique: fieldInput.isUnique ?? false,
+        generation: '',
+        placeholder: fieldInput.placeholder ?? '{}',
+    };
+}
+exports.zFieldJson = exports.zFieldJsonJSON.transform(fieldJsonJSONTransformer);
+const fieldJsonTransformer = ({ fieldInput, model: { name: modelName }, }) => {
+    return {
+        ...fieldInput,
+        modelName,
+        kind: 'json',
+    };
+};
+exports.fieldJsonTransformer = fieldJsonTransformer;

package/dist/field/scalar.d.ts

@@ -57,7 +57,7 @@ type FieldScalarDateNoValidation = {
  */
 export declare const zFieldScalarJSON: z.ZodObject<{
     name: z.ZodString;
-    type: z.ZodUnion<readonly [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?">]>]>;
+    type: z.ZodUnion<readonly [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<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
     excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
@@ -80,7 +80,7 @@ export type FieldScalarEnriched = Omit<FieldCommon<FieldKindScalar>, 'modelName'
 };
 export declare const zFieldScalar: z.ZodPipe<z.ZodObject<{
     name: z.ZodString;
-    type: z.ZodUnion<readonly [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?">]>]>;
+    type: z.ZodUnion<readonly [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<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
     excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
@@ -96,7 +96,7 @@ export declare const zFieldScalar: z.ZodPipe<z.ZodObject<{
     placeholder: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodTransform<FieldScalarEnriched, {
     name: string;
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Bytes?" | "BigInt?";
     databaseName?: string | undefined;
     excelName?: string | undefined;
     label?: string | undefined;

package/dist/field/scalar.js

@@ -50,7 +50,6 @@ const zDatabaseType = zod_1.z
     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?')),
 ])
@@ -73,8 +72,6 @@ function databaseTypeToFieldTypeScalar(input, ctx) {
         case 'Int':
         case 'Int?':
             return Branded.toScalarType('number');
-        case 'Json':
-        case 'Json?':
         case 'Bytes':
         case 'Bytes?':
         case 'BigInt':
@@ -117,7 +114,6 @@ const defaultPlaceholders = {
     Decimal: () => '1234.56',
     Float: () => '1234.56',
     Int: () => '1234',
-    Json: () => '{}',
     Bytes: () => '1234',
     BigInt: () => '1234',
 };
@@ -126,10 +122,12 @@ function fieldScalarJSONTransformer(fieldInput, ctx) {
     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 scalarDatabaseType = zDatabaseType.parse(required.type);
+    const databaseType = Branded.toDatabaseFieldType(scalarDatabaseType);
+    const type = databaseTypeToFieldTypeScalar(scalarDatabaseType, ctx);
     const label = fieldInput.label ?? (0, utils_1.toHumanReadable)(fieldInput.name);
-    const placeholder = fieldInput.placeholder ?? defaultPlaceholders[databaseType](label);
+    const placeholderFactory = defaultPlaceholders[scalarDatabaseType];
+    const placeholder = fieldInput.placeholder ?? placeholderFactory?.(label) ?? `${label} here...`;
     return {
         type,
         kind: exports.fieldKindScalar,

package/dist/field/shared/utils.js

@@ -40,6 +40,8 @@ function getFieldType(field) {
             return field.databaseType;
         case 'scalar':
             return field.databaseType;
+        case 'json':
+            return field.databaseType;
         case 'discriminatedUnion':
             return 'DiscriminatedUnion';
         case 'relation':

package/dist/model/model.json-decoder.d.ts

@@ -37,6 +37,7 @@ export declare const zModelJSON: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.Z
     defaultField: z.ZodOptional<z.ZodString>;
     labelField: z.ZodOptional<z.ZodString>;
     keyField: z.ZodOptional<z.ZodString>;
+    defaultSort: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>;
     indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>>;
     seed: z.ZodOptional<z.ZodArray<z.ZodAny>>;
     source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

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

@@ -93,6 +93,9 @@ The label field must be a string field. If not provided, the \`name\` field is u
         .optional().describe(`The name of the field that is used as the key (unique identifier) for the entity.
 The key field must be a scalar string field. If not provided, the fallback order is: \`key\`, \`excelKey\`, \`slug\`, then \`id\`.
 The key field is used in navigation, Excel import, and other places where a human-readable identifier is needed.`),
+    defaultSort: zod_1.z.array(brands_1.zFieldName).optional()
+        .describe(`Default sort order for admin views when no explicit sort is provided.
+Each entry references a field name and is applied ascending in the given order.`),
     indexes: zod_1.z
         //
         .array(zod_1.z.array(brands_1.zFieldName).min(2, { error: 'Index must have at least 2 fields' }))

package/dist/model/model.transformer.d.ts

@@ -12,6 +12,7 @@ export declare function modelJSONTransformer(input: ModelJSON, ctx: z.Refinement
     defaultFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     labelFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     keyFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
+    defaultSort: (string & z.core.$brand<"PXL.FieldName">)[] | undefined;
     isReadonly: boolean;
     excelName: string;
     description: string;
@@ -91,10 +92,11 @@ declare function addDefaults({ description, fields, standardFields, seed, faker,
     defaultField?: string | undefined;
     labelField?: string | undefined;
     keyField?: string | undefined;
+    defaultSort?: (string & z.core.$brand<"PXL.FieldName">)[] | undefined;
     source?: Record<string, unknown> | undefined;
 };
 type WithDefaults = ReturnType<typeof addDefaults>;
-declare function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, keyField, ...input }: WithDefaults): {
+declare function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, keyField, defaultSort, ...input }: WithDefaults): {
     name: string & z.core.$brand<"PXL.ModelName">;
     schema: (string & z.core.$brand<"PXL.DatabaseSchemaName">) | undefined;
     databaseName: string & z.core.$brand<"PXL.DatabaseModelName">;
@@ -102,6 +104,7 @@ declare function brandModel({ name, schema, databaseName, standardFields, defaul
     defaultFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     labelFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     keyFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
+    defaultSort: (string & z.core.$brand<"PXL.FieldName">)[] | undefined;
     isReadonly: boolean;
     excelName: string;
     description: string;
@@ -153,6 +156,7 @@ declare function combineFields({ fields, standardFields, ...model }: BrandedMode
     defaultFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     labelFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
     keyFieldName: (string & z.core.$brand<"PXL.FieldName">) | undefined;
+    defaultSort: (string & z.core.$brand<"PXL.FieldName">)[] | undefined;
     isReadonly: boolean;
     excelName: string;
     description: string;

package/dist/model/model.transformer.js

@@ -65,7 +65,7 @@ function addDefaults({ description, fields, standardFields, seed, faker, ...inpu
         },
     };
 }
-function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, keyField, ...input }) {
+function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, keyField, defaultSort, ...input }) {
     return {
         ...input,
         name: (0, model_brands_1.toModelName)(name),
@@ -75,6 +75,7 @@ function brandModel({ name, schema, databaseName, standardFields, defaultField,
         defaultFieldName: defaultField ? Field.toFieldName(defaultField) : undefined,
         labelFieldName: labelField ? Field.toFieldName(labelField) : undefined,
         keyFieldName: keyField ? Field.toFieldName(keyField) : undefined,
+        defaultSort: defaultSort?.map((fieldName) => Field.toFieldName(fieldName)),
     };
 }
 function combineFields({ fields, standardFields, ...model }, ctx) {

package/dist/model/model.types.d.ts

@@ -21,6 +21,11 @@ export type Model = {
      * Always defined since id field is always present.
      */
     keyField: Field.FieldDatabaseNative;
+    /**
+     * Default sort order used by generated admin views when no explicit sort is provided.
+     * Entries are field names sorted ascending in the given order.
+     */
+    defaultSort: Field.FieldName[];
     indexes: ModelIndex[];
     seed: Seed[];
     /**

package/dist/project-schema/project-schema.json-decoder.d.ts

@@ -108,6 +108,7 @@ export declare const zProjectSchemaJSON: z.ZodPipe<z.ZodTransform<unknown, unkno
         defaultField: z.ZodOptional<z.ZodString>;
         labelField: z.ZodOptional<z.ZodString>;
         keyField: z.ZodOptional<z.ZodString>;
+        defaultSort: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>;
         indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>>;
         seed: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

package/dist/project-schema/project-schema.transformer.d.ts

@@ -87,6 +87,7 @@ export declare const zProjectSchema: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown,
         defaultField: z.ZodOptional<z.ZodString>;
         labelField: z.ZodOptional<z.ZodString>;
         keyField: z.ZodOptional<z.ZodString>;
+        defaultSort: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>;
         indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">>>>;
         seed: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -191,6 +192,7 @@ export declare const zProjectSchema: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown,
         defaultField?: string | undefined;
         labelField?: string | undefined;
         keyField?: string | undefined;
+        defaultSort?: (string & z.core.$brand<"PXL.FieldName">)[] | undefined;
         indexes?: (string & z.core.$brand<"PXL.FieldName">)[][] | undefined;
         seed?: any[] | undefined;
         source?: Record<string, unknown> | undefined;

package/dist/project-schema/project-schema.transformer.js

@@ -275,7 +275,15 @@ function decodeFields({ modelsArray, ...projectSchema }, ctx) {
 function transformModels(projectSchema, ctx) {
     const models = new Map();
     for (const inputModelName of projectSchema.modelNames) {
-        const model = transformModel(projectSchema.models.get(inputModelName), projectSchema, ctx);
+        const inputModel = projectSchema.models.get(inputModelName);
+        if (!inputModel) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Model ${inputModelName} is missing after field decoding`,
+            });
+            return zod_1.z.NEVER;
+        }
+        const model = transformModel(inputModel, projectSchema, ctx);
         models.set(model.name, model);
     }
     const { auth, ...remainingProjectSchema } = projectSchema;
@@ -299,6 +307,7 @@ function transformModel(model, projectSchema, ctx) {
     const defaultField = extractDefaultField(model, fields, ctx);
     const labelField = extractLabelField(model, fields, ctx);
     const keyField = extractKeyField(model, fields, idField, ctx);
+    const defaultSort = extractDefaultSort(model, fields, ctx);
     const { defaultFieldName, labelFieldName, keyFieldName, auth, ...remainingModel } = model;
     return {
         ...remainingModel,
@@ -308,6 +317,7 @@ function transformModel(model, projectSchema, ctx) {
         defaultField,
         labelField,
         keyField,
+        defaultSort,
         idField,
     };
 }
@@ -438,9 +448,15 @@ function extractLabelField({ labelFieldName, ...model }, fields, ctx) {
         return zod_1.z.NEVER;
     }
     if (labelField.kind !== 'scalar' && labelField.kind !== 'id') {
+        const fieldType = Field.getFieldType(labelField);
+        const hint = labelField.kind === 'enum'
+            ? ` Enum fields cannot be used as label fields.`
+            : labelField.kind === 'relation'
+                ? ` Relation fields cannot be used as label fields.`
+                : '';
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
-            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type ${Field.getFieldType(labelField)}!`,
+            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type \`${fieldType}\`.${hint}`,
         });
         return zod_1.z.NEVER;
     }
@@ -448,7 +464,7 @@ function extractLabelField({ labelFieldName, ...model }, fields, ctx) {
     if (type !== 'string') {
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
-            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type ${type}!`,
+            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type \`${type}\`.`,
         });
         return zod_1.z.NEVER;
     }
@@ -522,6 +538,49 @@ function extractKeyFieldFromFallbacks(fields, idField) {
     // id field is always present and is always a string
     return idField;
 }
+const defaultSortFallbackCandidates = [
+    Field.toFieldName('order'),
+    Field.toFieldName('sequence'),
+    Field.toFieldName('count'),
+    Field.toFieldName('name'),
+    Field.toFieldName('label'),
+    Field.toFieldName('id'),
+];
+function extractDefaultSort(model, fields, ctx) {
+    const idFieldName = Field.standardFieldName_id;
+    const defaultSort = model.defaultSort;
+    if (defaultSort && defaultSort.length > 0) {
+        const result = [];
+        const seen = new Set();
+        for (const fieldName of defaultSort) {
+            if (!fields.has(fieldName)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Default sort field ${fieldName} is not defined in model ${model.name}!`,
+                });
+                return zod_1.z.NEVER;
+            }
+            if (!seen.has(fieldName)) {
+                seen.add(fieldName);
+                result.push(fieldName);
+            }
+        }
+        if (!seen.has(idFieldName) && fields.has(idFieldName)) {
+            result.push(idFieldName);
+        }
+        return result;
+    }
+    const fallbacks = [];
+    for (const candidate of defaultSortFallbackCandidates) {
+        if (fields.has(candidate)) {
+            fallbacks.push(candidate);
+        }
+    }
+    if (!fallbacks.includes(idFieldName) && fields.has(idFieldName)) {
+        fallbacks.push(idFieldName);
+    }
+    return fallbacks;
+}
 function isStringScalarField(field) {
     return field.kind === 'scalar' && field.type === 'string';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/schema",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Decoders for PXL Schema definitions and validation for PXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -36,7 +36,7 @@
     "directory": "packages/schema"
   },
   "dependencies": {
-    "@postxl/utils": "^1.3.4"
+    "@postxl/utils": "^1.4.0"
   },
   "devDependencies": {},
   "wallaby": {