@postxl/generator 0.72.0 → 0.73.1

package/dist/generator.js

@@ -404,6 +404,20 @@ function generate(_a) {
             }
         }
         yield lock.writeToProjectRoot(root, { dryRun: false });
+        // NOTE: Detached mode tells whether any of the UTF-8 files were detached.
+        //       We use this in CI template tests.
+        const isNoDetachedMode = process.env.POSTXL_NO_DETACHED_MODE === 'true';
+        if (isNoDetachedMode) {
+            console.log(`No detached mode enabled. Checking that all files are managed!`);
+            return;
+        }
+        if (isNoDetachedMode) {
+            const detachedFiles = results.filter((result) => { var _a; return result.status === 'skip' && !Buffer.isBuffer((_a = result.disk) === null || _a === void 0 ? void 0 : _a.content); });
+            if (detachedFiles.length > 0) {
+                console.log(`Detached files found: ${detachedFiles.map((f) => f.path).join(', ')}`);
+            }
+            process.exit(1);
+        }
         // NOTE: Lastly we generate the log of the changes.
         const log = lock_1.ConsoleUtils.getFilesChangelog(results.map((result) => {
             if (result.status === 'write') {

package/dist/generators/models/export/encoder.generator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelExportEncoder = void 0;
 const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
 const types_1 = require("../../../lib/schema/types");
 /**
  * Creates an encoder for the Seed Excel template.
@@ -13,15 +14,13 @@ function generateModelExportEncoder({ model, meta }) {
         [meta.import.decoder.location.import]: [meta.import.decoder.rowDecoderName],
     });
     const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural } = meta;
+    const fieldEncoders = generateFieldEncoders({ model });
     /* prettier-ignore */
     return `
     import * as z from 'zod'
 
-    import { capitalizeKeys } from '@postxl/runtime'
-
     ${imports.generate()}
 
-
     /**
      * The type for rows in the ${userFriendly} table
      */
@@ -31,7 +30,9 @@ function generateModelExportEncoder({ model, meta }) {
     /**
      * Converts a ${userFriendly} to an Excel row
      */
-    export const ${itemEncoderFunctionName} = (item: ${model.typeName}): ${encodedExcelType} => capitalizeKeys(item)
+    export const ${itemEncoderFunctionName} = (item: ${model.typeName}): ${encodedExcelType} => ({
+      ${fieldEncoders.join(',\n')}
+    })
 
     /**
      * Converts a list of ${userFriendlyPlural} to an Excel table
@@ -40,3 +41,11 @@ function generateModelExportEncoder({ model, meta }) {
   `;
 }
 exports.generateModelExportEncoder = generateModelExportEncoder;
+function generateFieldEncoders({ model }) {
+    const fieldEncoders = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        fieldEncoders.push(`"${fieldMeta.excelColumnName}": item.${field.name}`);
+    }
+    return fieldEncoders;
+}

package/dist/generators/models/import/decoder.generator.js

@@ -17,11 +17,10 @@ function generateModelImportDecoder({ model, meta }) {
     });
     const { userFriendlyName: userFriendly, internalSingularNameCapitalized: singularCapitalized } = meta;
     const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
+    const fieldTransformers = generateFieldTransformers({ model });
     return `
 import * as z from 'zod'
 
-import { uncapitalizeKeys } from '@postxl/runtime'
-
 ${imports.generate()}
 
 /**
@@ -52,7 +51,10 @@ const blank${singularCapitalized}RowDecoder = z
 export const ${tableImportDecoder} = z
   .array(
     blank${singularCapitalized}RowDecoder
-    .or(${meta.import.decoder.rowDecoderName}.transform(uncapitalizeKeys))
+    .or(${meta.import.decoder.rowDecoderName}
+      .transform(item => ({
+        ${fieldTransformers.join(',\n')}
+      })))
   )
   .transform((items) => items.filter(Boolean) as ${model.typeName}[])`;
 }
@@ -63,11 +65,11 @@ function generateFieldDecoders({ model, meta, imports, }) {
     for (const field of model.fields) {
         const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
         const optionalModifier = field.attributes.isUpdatedAt || field.attributes.isCreatedAt ? '.optional()' : '';
-        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: excelNullOrBlankDecoder${optionalModifier}`);
+        blankFieldDecoders.push(`'${fieldMeta.excelColumnName}': excelNullOrBlankDecoder${optionalModifier}`);
         switch (field.kind) {
             case 'id': {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
-                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                fieldDecoders.push(`'${fieldMeta.excelColumnName}': ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
                     nullable: false,
                     imports,
@@ -75,7 +77,7 @@ function generateFieldDecoders({ model, meta, imports, }) {
                 break;
             }
             case 'scalar': {
-                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                fieldDecoders.push(`'${fieldMeta.excelColumnName}': ${toExcelDecoder({
                     tsTypeName: field.tsTypeName,
                     nullable: !field.isRequired,
                     imports,
@@ -86,7 +88,7 @@ function generateFieldDecoders({ model, meta, imports, }) {
                 const refModel = field.relationToModel;
                 const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
                 imports.addImport({ items: [refMeta.types.toBrandedIdTypeFnName], from: refMeta.types.importPath });
-                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                fieldDecoders.push(`'${fieldMeta.excelColumnName}': ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
                     nullable: !field.isRequired,
                     imports,
@@ -98,7 +100,7 @@ function generateFieldDecoders({ model, meta, imports, }) {
                 break;
             }
             case 'enum': {
-                fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([
+                fieldDecoders.push(`'${fieldMeta.excelColumnName}': z.enum([
             ${field.enumerator.values.map((v) => `'${v}'`).join(', ')}
           ])${field.isRequired ? '' : '.nullable()'}${optionalModifier}`);
                 break;
@@ -136,3 +138,11 @@ function toExcelDecoder({ tsTypeName, nullable, imports, }) {
             throw new Error('Unknown type');
     }
 }
+function generateFieldTransformers({ model }) {
+    const fieldTransformers = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        fieldTransformers.push(`${field.name}: item['${fieldMeta.excelColumnName}']`);
+    }
+    return fieldTransformers;
+}

package/dist/generators/models/react/context.generator.js

@@ -2,23 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelContext = void 0;
 const imports_1 = require("../../../lib/imports");
-const string_1 = require("../../../lib/utils/string");
 /**
  * Utility component that generates the definition of the React context for a given model.
  */
 function generateModelContext({ model, meta }) {
-    const queryName = (0, string_1.toCamelCase)(model.name);
     const imports = imports_1.ImportsGenerator.from(meta.react.folderPath).addTypeImport({
-        items: [model.typeName, model.brandedIdType],
         from: meta.types.importPath,
+        items: [model.typeName, model.brandedIdType],
     });
     const resultMapTypeDefinition = `Map<${model.brandedIdType}, ${model.typeName}>`;
     return `
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import React, { useMemo } from 'react'
+import { useMemo } from 'react'
 
 import { trpc } from '@lib/trpc'
-import { filterMap, mapMap } from '@postxl/runtime'
 
 ${imports.generate()}
 
@@ -32,17 +28,17 @@ type ProviderHookType = {
  * A React utility hook to access the model data in the generated forms.
  */
 export const ${meta.react.context.hookFnName} = (): ProviderHookType => {
-	const ${queryName} = trpc.${meta.trpc.getMap.reactQueryMethod}.useQuery()
+	const dataQuery = trpc.${meta.trpc.getMap.reactQueryMethod}.useQuery()
 
 	const value = useMemo<ProviderHookType>(() => {
-		const data: ${resultMapTypeDefinition} = ${queryName}.data ?? new ${resultMapTypeDefinition}()
+		const data: ${resultMapTypeDefinition} = dataQuery.data ?? new ${resultMapTypeDefinition}()
 
 		return {
-			ready: ${queryName}.isLoading === false,
+			ready: dataQuery.isLoading === false,
 			map: data,
 			list: Array.from(data.values())
 		}
-	}, [${queryName}.isLoading, ${queryName}.data])
+	}, [dataQuery.isLoading, dataQuery.data])
 
 	return value
 }

package/dist/generators/models/react/modals.generator.js

@@ -574,7 +574,7 @@ function getFormFieldComponents({ model, testIdCollector, }) {
             continue;
         }
         const formikFieldName = getFormikFieldName(field.name);
-        const label = StringUtils.toPascalCase(field.name);
+        const label = field.attributes.label;
         switch (field.kind) {
             case 'id': {
                 // NOTE: We never show the ID field in the form even if it's in the type signature of the form input.

package/dist/generators/models/view/service.generator.js

@@ -5,9 +5,7 @@ const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const fields_1 = require("../../../lib/schema/fields");
 const types_1 = require("../../../lib/schema/types");
-const types_2 = require("../../../lib/types");
 const ast_1 = require("../../../lib/utils/ast");
-const jsdoc_1 = require("../../../lib/utils/jsdoc");
 /**
  * Generates view business logic for a given model.
  * The view  logic exposes all information and links of a model. See template's readme for more info.
@@ -20,91 +18,64 @@ function generateModelBusinessLogicView({ model, meta }) {
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType), (0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
         [schemaMeta.view.serviceLocation.path]: schemaMeta.view.serviceClassName,
     });
-    /**
-     * The name of the variable that holds the central business logic service instance.
-     * Instead of injecting a repository instance for each model, we inject this single instance
-     * which then provides access to all models' business logic.
-     */
-    const viewServiceClassName = 'viewService';
-    const constructorParameters = [
-        `public readonly data: ${meta.data.repository.className}`,
-        `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.view.serviceClassName}`,
-    ];
-    /**
-     * Variable names and their definitions indexed by the name of the relation they represent.
-     */
-    const variables = new Map();
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        const refModel = relation.relationToModel;
-        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        const variableGetter = `await this.${viewServiceClassName}.${refMeta.view.serviceVariableName}.get(itemRaw.${relation.name})`;
-        const variablePresenceCheck = `
-      if (!${relation.relationFieldName}) {
-        throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
-      }
-      `;
-        const relationVariableName = relation.relationFieldName;
-        const relationVariableDefinition = relation.isRequired
-            ? `${variableGetter};${variablePresenceCheck}`
-            : `itemRaw.${relation.name} !== null ? ${variableGetter} : null`;
-        variables.set(relation.name, {
-            variableName: relationVariableName,
-            variableDefinition: `const ${relationVariableName} = ${relationVariableDefinition}`,
-        });
-        if (relation.relationToModel.typeName !== model.typeName) {
-            imports.addImport({ from: refMeta.types.importPath, items: [refMeta.types.toBrandedIdTypeFnName] });
-            imports.addTypeImport({ from: refMeta.types.importPath, items: [refModel.brandedIdType, refMeta.types.typeName] });
-        }
-    }
-    const hasLinkedItems = variables.size > 0;
-    if (hasLinkedItems) {
-        // NOTE: If we need to generate the linked item type, we need to import the enum types.
-        for (const enumField of (0, fields_1.getEnumFields)(model)) {
-            const enumMeta = (0, meta_1.getEnumMetadata)(enumField);
-            imports.addTypeImport({ from: enumMeta.types.importPath, items: [enumField.typeName] });
+    const compareFnBlock = (0, ast_1.createSwitchStatement)({
+        field: 'field',
+        cases: (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => ({
+            match: `"${f.name}"`,
+            block: `return (a[field] || '').localeCompare(b[field] || '')`,
+        })),
+        defaultBlock: 'return 0',
+    });
+    const stringFieldFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => {
+        return {
+            match: `"${f.name}"`,
+            block: `
+        if (typeof value !== 'string') {
+          return false
         }
-    }
-    const linkedItemsGetterFn = `
-    /**
-     * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
-     * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
-     */
-    public async getLinkedItem(id: ${model.brandedIdType}): Promise<${meta.types.linkedTypeName} | null> {
-      const itemRaw = await this.data.get(id)
-      if (!itemRaw) {
-        return null
-      }
 
-      ${[...variables.values()].map((r) => r.variableDefinition).join('\n')}
-      
-      const item: ${meta.types.linkedTypeName} = {
-        ${model.fields
-        .map((f) => {
-        if (f.kind !== 'relation') {
-            return `${f.name}: itemRaw.${f.name}`;
+        switch (operator) {
+          case 'contains': {
+            return (item[field] || '').toLowerCase().includes(value.toLowerCase())
+          }
+          default: {
+            return false
+          }
         }
-        const linkedRel = variables.get(f.name);
-        if (!linkedRel) {
-            throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
+      `,
+        };
+    });
+    const numberFieldsFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'number' }).map((f) => {
+        return {
+            match: `"${f.name}"`,
+            block: `
+        const toCompare = item[field]
+        if (typeof value !== 'number' || toCompare === null) {
+          return false
         }
-        return `${linkedRel.variableName}`;
-    })
-        .join(',\n')}
-      }
 
-      return item
-    }
-  `;
-    const linkedTypeDefinition = `
-    export type ${meta.types.linkedTypeName} = { 
-      ${model.fields
-        .map((f) => `
-            ${(0, jsdoc_1.getFieldComment)(f)}
-            ${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}
-          `)
-        .join('\n')}
-    }
-  `;
+        switch (operator) {
+          case 'eq': {
+            return item[field] === value
+          }
+          case 'gt': {
+            return toCompare > value
+          }
+          case 'lt': {
+            return toCompare < value
+          }
+          default: {
+            return false
+          }
+        }
+      `,
+        };
+    });
+    const filterFnBlock = (0, ast_1.createSwitchStatement)({
+        field: 'field',
+        cases: [...stringFieldFilters, ...numberFieldsFilters],
+        defaultBlock: 'return false',
+    });
     return /* ts */ `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import z from 'zod'
@@ -113,8 +84,6 @@ import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
 ${imports.generate()}
 
-${hasLinkedItems ? linkedTypeDefinition : ''}
-
 /**
  * Cursor decoder.
  */
@@ -144,7 +113,11 @@ type FilterOperator = z.infer<typeof ${meta.view.filterOperatorDecoder}>
 
 @Injectable()
 export class ${meta.view.serviceClassName} {
-  constructor(${constructorParameters.join(',\n')}) {}
+  constructor(
+    public readonly data: ${meta.data.repository.className},
+    @Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) 
+        private readonly viewService: ${schemaMeta.view.serviceClassName}
+  ) {}
 
   /**
    * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
@@ -154,8 +127,6 @@ export class ${meta.view.serviceClassName} {
     return this.data.get(id)
   }
 
-  ${hasLinkedItems ? linkedItemsGetterFn : ''}
-
   /**
    * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
@@ -192,68 +163,13 @@ export class ${meta.view.serviceClassName} {
 
 // Utility Functions
 
-${_createModelCompareFn({ model })}
-
-${_createModelFilterFn({ model })}
-`;
-}
-exports.generateModelBusinessLogicView = generateModelBusinessLogicView;
 /**
- * Generates a utility filter function for the given model that can be used to filter out instances
- * of a model using a given operator on a given field.
+ * Compares two ${model.typeName} instances by the given field.
  */
-function _createModelFilterFn({ model }) {
-    const stringFieldFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => {
-        return {
-            match: `"${f.name}"`,
-            block: `
-        if (typeof value !== 'string') {
-          return false
-        }
-
-        switch (operator) {
-          case 'contains': {
-            return (item[field] || '').toLowerCase().includes(value.toLowerCase())
-          }
-          default: {
-            return false
-          }
-        }
-      `,
-        };
-    });
-    const numberFieldsFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'number' }).map((f) => {
-        return {
-            match: `"${f.name}"`,
-            block: `
-        const toCompare = item[field]
-        if (typeof value !== 'number' || toCompare === null) {
-          return false
-        }
+function compare(a: ${model.typeName}, b: ${model.typeName}, field: keyof ${model.typeName}) {
+  ${compareFnBlock}
+}
 
-        switch (operator) {
-          case 'eq': {
-            return item[field] === value
-          }
-          case 'gt': {
-            return toCompare > value
-          }
-          case 'lt': {
-            return toCompare < value
-          }
-          default: {
-            return false
-          }
-        }
-      `,
-        };
-    });
-    const fnBlock = (0, ast_1.createSwitchStatement)({
-        field: 'field',
-        cases: [...stringFieldFilters, ...numberFieldsFilters],
-        defaultBlock: 'return false',
-    });
-    return `
 /**
  * Filters the given ${model.typeName} by the given field, using provided operator and value.
  */
@@ -263,52 +179,8 @@ function filterFn(
   operator: FilterOperator, 
   value: string | number
 ): boolean {
-  ${fnBlock}
+  ${filterFnBlock}
 }
 `;
 }
-/**
- * Returns a utility compare function that lets you compare two instances of a given model
- * by a given field.
- */
-function _createModelCompareFn({ model }) {
-    const stringFieldComparators = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => {
-        return {
-            match: `"${f.name}"`,
-            block: `
-        return (a[field] || '').localeCompare(b[field] || '')
-      `,
-        };
-    });
-    const fnBlock = (0, ast_1.createSwitchStatement)({
-        field: 'field',
-        cases: [...stringFieldComparators],
-        defaultBlock: 'return 0',
-    });
-    return `
-/**
- * Compares two ${model.typeName} instances by the given field.
- */
-function compare(a: ${model.typeName}, b: ${model.typeName}, field: keyof ${model.typeName}) {
-  ${fnBlock}
-}
-
-  `;
-}
-/**
- * Converts a field to a TypeScript type definition with linked fields.
- */
-function getLinkedFieldType(f) {
-    switch (f.kind) {
-        case 'enum':
-            return `${f.name}: ${f.typeName}`;
-        case 'relation':
-            return `${f.relationFieldName}: ${f.relationToModel.typeName}`;
-        case 'id':
-            return `${f.name}: ${f.model.brandedIdType}`;
-        case 'scalar':
-            return `${f.name}: ${f.tsTypeName}`;
-        default:
-            throw new types_2.ExhaustiveSwitchCheck(f);
-    }
-}
+exports.generateModelBusinessLogicView = generateModelBusinessLogicView;

package/dist/lib/attributes.d.ts

@@ -81,10 +81,21 @@ export type FieldAttributes = {
      */
     maxLength?: number;
     /**
-     * Schema tag: `@@Label()`
+     * Schema tag: `@@IsNameField()`
      * The field that should be used as the default label for the model.
+     *
+     * If this is set, the repository will verify that exactly one record has this field set to true - and use it as the default label.
+     *
+     * If this attribute is set, this field will be used in the code/UI as the field that specifies the model's name. If not provided, we check for the existence of the`name` field. If that is not found, we use the `id` field as the name field.
+     */
+    isNameField?: boolean;
+    /**
+     * Schema tag: `@@Label("Label")`
+     * The human readable label/name of the field.
+     *
+     * If not provided, we use the field name.
      */
-    isLabel?: boolean;
+    label: string;
 };
 export type EnumAttributes = {
     /**

package/dist/lib/meta.js

@@ -402,7 +402,7 @@ function getFieldMetadata({ field }) {
         tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
         getByForeignKeyMethodFnName: Types.toFunctionName(`getItemsFor${PascalCase}`),
         getByForeignKeyIdsMethodFnName: Types.toFunctionName(`getIdsFor${PascalCase}`),
-        excelColumnName: (0, string_1.toPascalCase)(field.name),
+        excelColumnName: field.attributes.label,
     };
 }
 exports.getFieldMetadata = getFieldMetadata;

package/dist/lib/schema/schema.d.ts

@@ -284,9 +284,9 @@ export type FieldScalar = Prettify<Omit<FieldCore, 'name'> & {
 export type FieldId = Prettify<Omit<FieldCore, 'name'> & {
     kind: 'id';
     /**
-     * Name of the field and variable (e.g. id)
+     * Name of the field and variable (must be `id`)
      */
-    name: Types.FieldName;
+    name: Types.IdFieldName;
     /**
      * Model that this ID field identifies.
      */
@@ -314,9 +314,9 @@ export type FieldId = Prettify<Omit<FieldCore, 'name'> & {
 export declare const isFieldId: (field: Field) => field is Prettify<Omit<FieldCore, "name"> & {
     kind: 'id';
     /**
-     * Name of the field and variable (e.g. id)
+     * Name of the field and variable (must be `id`)
      */
-    name: Types.FieldName;
+    name: Types.IdFieldName;
     /**
      * Model that this ID field identifies.
      */

package/dist/lib/schema/types.d.ts

@@ -71,6 +71,16 @@ export declare const isAnnotatedTypeName: (t: string | AnnotatedTypeName) => t i
 export type FieldName = string & {
     readonly ___type: 'FieldName';
 };
+/**
+ * Brands a raw string to an IdFieldName identifier.
+ */
+export declare const ID_FIELD_NAME: IdFieldName;
+/**
+ * The name of the id field. Must be `id`.
+ */
+export type IdFieldName = 'id' & {
+    readonly ___type: 'FieldName';
+};
 /**
  * Brands a raw string to a FieldName identifier.
  */

package/dist/lib/schema/types.js

@@ -1,7 +1,7 @@
 "use strict";
 // MARK: - Generated content related types
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPackageName = exports.toPath = exports.toBackendModulePath = exports.toModuleLocation = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toFunctionName = exports.toEnumName = exports.toFieldName = exports.isAnnotatedTypeName = exports.toAnnotatedTypeName = exports.toTypeName = exports.toModelName = exports.toDiscriminantName = exports.toClassName = void 0;
+exports.toPackageName = exports.toPath = exports.toBackendModulePath = exports.toModuleLocation = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toFunctionName = exports.toEnumName = exports.toFieldName = exports.ID_FIELD_NAME = exports.isAnnotatedTypeName = exports.toAnnotatedTypeName = exports.toTypeName = exports.toModelName = exports.toDiscriminantName = exports.toClassName = void 0;
 /**
  * Converts a raw string to a branded ClassName.
  */
@@ -35,6 +35,10 @@ exports.toAnnotatedTypeName = toAnnotatedTypeName;
  */
 const isAnnotatedTypeName = (t) => typeof t === 'object' && t.kind === 'TypeName';
 exports.isAnnotatedTypeName = isAnnotatedTypeName;
+/**
+ * Brands a raw string to an IdFieldName identifier.
+ */
+exports.ID_FIELD_NAME = 'id';
 /**
  * Brands a raw string to a FieldName identifier.
  */

package/dist/lib/utils/error.js

@@ -34,7 +34,6 @@ function extractNestedErrors(value) {
  * As a fallback, it returns a JSON string representation of the error.
  */
 function formatZodError(e) {
-    console.log(e);
     const formatted = e.format();
     if (typeof formatted === 'string') {
         return formatted;

package/dist/prisma/attributes.js

@@ -138,7 +138,8 @@ function getFieldAttributes(field) {
         ignore: blankStringBooleanDecoder,
         description: zod_1.default.string().optional(),
         isDefault: blankStringBooleanDecoder,
-        label: blankStringBooleanDecoder,
+        isNameField: blankStringBooleanDecoder,
+        label: zod_1.default.string().optional(),
         example: examplesDecoder,
         examples: examplesDecoder,
         maxLength: zod_1.default
@@ -148,7 +149,7 @@ function getFieldAttributes(field) {
         readonly: blankStringBooleanDecoder,
     })
         .transform((obj) => {
-        var _a;
+        var _a, _b;
         if (isPrismaIgnored && !obj.ignore) {
             throw new Error(`Field ${field.name} is ignored by Prisma, but is missing the "ignore" PostXL attribute!`);
         }
@@ -156,11 +157,12 @@ function getFieldAttributes(field) {
             ignore: obj.ignore,
             description: obj.description,
             isDefaultField: obj.isDefault,
-            isLabel: obj.label,
+            isNameField: obj.isNameField,
+            label: (_a = obj.label) !== null && _a !== void 0 ? _a : (0, string_1.toPascalCase)(field.name),
             examples: obj.examples || obj.example,
             maxLength: obj.maxLength,
             isReadonly: obj.readonly || field.isGenerated || field.isUpdatedAt || field.name === 'createdAt' || field.isId,
-            isUpdatedAt: (_a = field.isUpdatedAt) !== null && _a !== void 0 ? _a : false,
+            isUpdatedAt: (_b = field.isUpdatedAt) !== null && _b !== void 0 ? _b : false,
             isCreatedAt: field.name === 'createdAt',
         };
     });

package/dist/prisma/parse.js

@@ -226,7 +226,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         }
         if (dmmfField.isId) {
             const isGeneratedField = isAutoIncrementField(dmmfField) || isUUIDField(dmmfField);
-            const _field = Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+            const _field = Object.assign(Object.assign({ kind: 'id' }, shared), { name: Types.ID_FIELD_NAME, isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
             return _field;
         }
         if (dmmfField.kind === 'scalar') {
@@ -257,7 +257,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
     })
         .filter((field) => !isFieldIgnored({ field }));
-    const { idField, defaultField, nameField, createdAtField, updatedAtField } = validateFields({ fields, model: core });
+    const { idField, defaultField, nameField, createdAtField, updatedAtField } = getTaggedFields({ fields, model: core });
     return Object.assign(Object.assign({}, core), { idField,
         defaultField,
         nameField,
@@ -268,61 +268,60 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         references: [] });
 }
 /**
- * Checks that there is exactly one id field and that there is at most one default field.
+ * Returns special fields that are tagged with special attributes.
  */
-function validateFields({ fields, model: { name } }) {
+function getTaggedFields({ fields, model: { name }, }) {
     var _a;
     let idField = undefined;
     let createdAtField = undefined;
     let updatedAtField = undefined;
-    let labelField = undefined;
     let nameField = undefined;
+    let isNameField = undefined;
     let defaultField = undefined;
     for (const field of fields) {
         const fieldName = (0, logger_1.highlight)(`${name}.${field.name}`);
         switch (field.kind) {
+            case 'id': {
+                if (idField) {
+                    (0, error_1.throwError)(`${fieldName} has multiple id fields - ${idField.name} and ${field.name}`);
+                }
+                idField = field;
+                break;
+            }
             case 'scalar':
                 if (field.name === 'name') {
                     nameField = field;
                 }
+                if (field.attributes.isNameField) {
+                    if (isNameField != null) {
+                        (0, error_1.throwError)(`${fieldName} has multiple name fields - ${isNameField.name} and ${field.name}`);
+                    }
+                    isNameField = field;
+                }
                 if (field.attributes.isCreatedAt) {
-                    if (createdAtField) {
-                        (0, error_1.throwError)(`${fieldName} has multiple createdAt fields`);
+                    if (createdAtField != null) {
+                        (0, error_1.throwError)(`${fieldName} has multiple createdAt fields - ${createdAtField.name} and ${field.name}`);
                     }
                     createdAtField = field;
                 }
                 if (field.attributes.isUpdatedAt) {
-                    if (updatedAtField) {
-                        (0, error_1.throwError)(`${fieldName} has multiple updatedAt fields`);
+                    if (updatedAtField != null) {
+                        (0, error_1.throwError)(`${fieldName} has multiple updatedAt fields - ${updatedAtField.name} and ${field.name}`);
                     }
                     updatedAtField = field;
                 }
-                break;
-            case 'id':
-                if (idField) {
-                    (0, error_1.throwError)(`${fieldName} has multiple id fields`);
+                if (field.attributes.isDefaultField) {
+                    if (defaultField != null) {
+                        (0, error_1.throwError)(`${fieldName} has multiple default fields - ${defaultField.name} and ${field.name}`);
+                    }
+                    defaultField = field;
                 }
-                idField = field;
                 break;
             case 'relation':
                 break;
             case 'enum':
                 break;
         }
-        //handle default case
-        if (field.attributes.isDefaultField && field.kind === 'scalar') {
-            if (defaultField !== undefined) {
-                (0, error_1.throwError)(`${fieldName} has multiple default fields`);
-            }
-            defaultField = field;
-        }
-        //handle name field
-        if (field.attributes.isLabel) {
-            if (labelField !== undefined) {
-                (0, error_1.throwError)(`${fieldName} has multiple name fields`);
-            }
-            labelField = field;
-        }
     }
     if (!idField) {
         (0, error_1.throwError)(`Model ${(0, logger_1.highlight)(name)} does not have an id field`);
@@ -330,7 +329,7 @@ function validateFields({ fields, model: { name } }) {
     return {
         idField,
         defaultField,
-        nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField,
+        nameField: (_a = isNameField !== null && isNameField !== void 0 ? isNameField : nameField) !== null && _a !== void 0 ? _a : idField,
         createdAtField,
         updatedAtField,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.72.0",
+  "version": "0.73.1",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -41,7 +41,6 @@
     "prisma": "5.8.1"
   },
   "scripts": {
-    "test:generators": "./scripts/test-generators.sh",
     "test:setup": "./scripts/test-setup.sh",
     "test:jest": "jest",
     "test:watch": "jest --watch",