@postxl/generator 0.33.4 → 0.34.0

package/dist/generators/models/businesslogic.generator.js

@@ -28,6 +28,7 @@ const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
 const Types = __importStar(require("../../lib/schema/types"));
+const ast_1 = require("../../lib/utils/ast");
 const repository_generator_1 = require("./repository.generator");
 /**
  * Generates business logic for a given model.
@@ -188,72 +189,114 @@ export class ${meta.businessLogic.serviceClassName} {
    * Deletes the ${meta.userFriendlyName} with the given id.
    * 
    * Note: This does NOT delete any linked items. 
-   * If the items is a dependency of another item, the deletion will fail!
+   * If the item is a dependency of another item, the deletion will fail!
    */
   public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
     return this.${modelRepositoryVariableName}.delete(id)
   }
 }
 
-const compare = (a: ${model.typeName}, b: ${model.typeName}, field: keyof ${model.typeName}) => {
-  switch (field) {
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-      return (a[field] || '').localeCompare(b[field] || '')`}
-    default:
-      return 0
-  }
+// Utility Functions
+
+${_createModelCompareFn({ model })}
+
+${_createModelFilterFn({ model })}
+`;
 }
+exports.generateModelBusinessLogic = generateModelBusinessLogic;
+/**
+ * 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.
+ */
+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
+        }
 
-const filterFn = (item: ${model.typeName}, field: keyof ${model.typeName}, operator: FilterOperator, value: string | number): boolean => {
-  switch (field) {
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-            {
-              if (typeof value !== 'string') return false
-              switch (operator) {
-                case 'contains': {
-                  return (item[field] || '').toLowerCase().includes(value.toLowerCase())
-                }
-                default:
-                  return false
-              }
-            }`}
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'number').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'number')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-            {
-              const toCompare = item[field]
-              if (typeof value !== 'number' || toCompare === null) return false
-              switch (operator) {
-                case 'eq': {
-                  return item[field] === value
-                }
-                case 'gt': {
-                  return toCompare > value
-                }
-                case 'lt': {
-                  return toCompare < value
-                }
-                default:
-                  return false
-              }
-            }`}
-    default:
-      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
+        }
+
+        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.
+ */
+function filterFn(
+  item: ${model.typeName}, 
+  field: keyof ${model.typeName}, 
+  operator: FilterOperator, 
+  value: string | number
+): boolean {
+  ${fnBlock}
 }
 `;
 }
-exports.generateModelBusinessLogic = generateModelBusinessLogic;
+/**
+ * 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}
+}
+
+  `;
+}

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

@@ -52,6 +52,9 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
     () => createTypedForm<CreateInputData>().with({ ${(() => {
         const components = new Set();
         for (const field of fields.values()) {
+            if (field.attributes.isReadonly) {
+                continue;
+            }
             switch (field.kind) {
                 case 'enum': {
                     const enumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
@@ -79,7 +82,7 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
       <Typed.Formik
         initialValues={{
 					${fields
-        .filter((f) => f.kind !== 'id')
+        .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
         .map((field) => `${getFormikFieldName(field.name)}: null,`)
         .join('\n')}
 				}}
@@ -195,6 +198,7 @@ export const ${components.modals.editComponentName} = ({
       <Typed.Formik
         initialValues={{
 					${fields
+        .filter((f) => !f.attributes.isReadonly)
         .map((field) => {
         switch (field.kind) {
             case 'enum':
@@ -387,6 +391,9 @@ function getFormImports({ model, meta }) {
 function getCreateFormInputFields({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         switch (field.kind) {
             case 'id':
                 continue;
@@ -407,12 +414,13 @@ function getCreateFormInputFields({ model }) {
 }
 function getFormikCreateMutationData({ model: { fields } }) {
     return fields
+        .filter((f) => !f.attributes.isReadonly)
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {
             case 'id':
             case 'scalar':
-                // NOTE: Create methods generate the ID field upon submision.
+                // NOTE: Create methods generate the ID field upon submission.
                 if (field.kind === 'id') {
                     return '';
                 }
@@ -454,6 +462,9 @@ function getFormikCreateMutationData({ model: { fields } }) {
 function getEditFormInputFields({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         switch (field.kind) {
             case 'id':
                 continue;
@@ -489,6 +500,7 @@ function getEditFormInputFields({ model }) {
 }
 function getEditFormikMutationData({ model: { fields } }) {
     return fields
+        .filter((f) => !f.attributes.isReadonly)
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {
@@ -520,11 +532,15 @@ function getFormFieldComponents({ model }) {
     var _a;
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        // By default, we hide generated fields like createdAt, updatedAt, deletedAt.
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         const formikFieldName = getFormikFieldName(field.name);
         const label = StringUtils.toPascalCase(field.name);
         switch (field.kind) {
             case 'id': {
-                // NOTE: We never show the ID field in the form even if it's in the type signiture of the form input.
+                // NOTE: We never show the ID field in the form even if it's in the type signature of the form input.
                 break;
             }
             case 'scalar': {
@@ -604,7 +620,7 @@ function getFormFieldComponents({ model }) {
 function getFormikValidationCases({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
-        if (field.kind === 'id') {
+        if (field.kind === 'id' || field.attributes.isReadonly) {
             continue;
         }
         const formikFieldName = getFormikFieldName(field.name);

package/dist/generators/models/repository.generator.js

@@ -27,7 +27,7 @@ function generateRepository({ model, meta }) {
         items: [meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,
     });
-    // NOTE: We first generate different parts of the code responisble for a particular task
+    // NOTE: We first generate different parts of the code responsible for a particular task
     //   and then we combine them into the final code block.
     //
     // Based on the model, the repository is generated slightly differently:
@@ -132,36 +132,6 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   public count(): number {
     return this.data.size
   }
-
-  /**${(0, jsdoc_1.convertToJsDocComments)([
-        `Checks that item has the ${idField.name} field.`,
-        `In case none exists, ${idBlocks.verifyFunctionComment}`,
-        uniqueStringFieldsBlocks.verifyFunctionComment,
-        maxLengthBlocks.verifyFunctionComment,
-    ])}
-  */
-
-  private verifyItem(item: ${idBlocks.verifyFunctionParameterType}): ${model.typeName} {
-    ${idBlocks.verifyCode}
-
-    ${maxLengthBlocks.verifyCode.join('\n')}
-
-    ${uniqueStringFieldsBlocks.verifyCode.join('\n')}
-
-    return {
-      ${idField.name},
-      ${[...model.fields.values()]
-        .filter((f) => f.kind !== 'id')
-        .map((f) => `${f.name}: item.${f.name}`)
-        .join(',\n')}
-    }
-  }
-
-  private toCreateItem(item: ${model.typeName}) {
-    return {
-      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
-    }
-  }
   
   ${mainBlocks.createCode}
 
@@ -247,9 +217,35 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         return this.init()
       }`,
         createCode: `  
+      ${(0, jsdoc_1.jsDocComment)([
+            `Checks that item has the ${model.idField.name} field.`,
+            `In case none exists, ${blocks.idBlocks.verifyFunctionComment}`,
+            blocks.uniqueStringFieldsBlocks.verifyFunctionComment,
+            blocks.maxLengthBlocks.verifyFunctionComment,
+        ])}
+      private verifyItem(item: ${blocks.idBlocks.verifyFunctionParameterType}): ${model.name} {
+        ${blocks.idBlocks.verifyCode}
+    
+        ${blocks.maxLengthBlocks.verifyCode.join('\n')}
+    
+        ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
+    
+        return {
+          ${model.idField.name},
+          ${model.fields
+            .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
+            .map((f) => `${f.name}: item.${f.name}`)
+            .join(',\n')},
+            ${model.createdAtField ? `${model.createdAtField.sourceName}: new Date(),` : ''}
+            ${model.updatedAtField ? `${model.updatedAtField.sourceName}: new Date(),` : ''}  
+        }
+      }
+
       // Non-mocked version is async - so we keep type-compatible signatures for create() and createWithId() 
       // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
-      public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {  
+      public async create(
+        item: ${methodTypeSignatures.create.parameters[0]}
+      ): ${methodTypeSignatures.create.returnType} {  
         const newItem = await Promise.resolve(this.verifyItem(item))
     
         this.set(newItem)
@@ -281,7 +277,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
         
         const newItem = await Promise.resolve({ ...existingItem, ...item })
-        
+        ${model.updatedAtField ? `newItem.${model.updatedAtField.name} = new Date()` : ''}
+
         this.remove(existingItem)
         this.set(newItem)
     
@@ -371,7 +368,42 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       }
     `,
         createCode: `
-      public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {    
+      ${(0, jsdoc_1.jsDocComment)([
+            `Checks that item has the ${idField.name} field.`,
+            `In case none exists, ${blocks.idBlocks.verifyFunctionComment}`,
+            blocks.uniqueStringFieldsBlocks.verifyFunctionComment,
+            blocks.maxLengthBlocks.verifyFunctionComment,
+        ])}
+      private verifyItem(
+        item: ${blocks.idBlocks.verifyFunctionParameterType}
+      ): ${blocks.idBlocks.createFunctionParameterType} {
+        ${blocks.idBlocks.verifyCode}
+    
+        ${blocks.maxLengthBlocks.verifyCode.join('\n')}
+    
+        ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
+    
+        return {
+          ${idField.name},
+          ${model.fields
+            .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
+            .map((f) => `${f.name}: item.${f.name}`)
+            .join(',\n')}
+        }
+      }
+    
+      private toCreateItem(item: ${blocks.idBlocks.createFunctionParameterType}) {
+        return {
+          ${model.fields
+            .filter((f) => !f.attributes.isReadonly)
+            .map((f) => `${f.sourceName}: item.${f.name}`)
+            .join(',\n')},
+        }
+      }
+
+      public async create(
+        item: ${methodTypeSignatures.create.parameters[0]}
+      ): ${methodTypeSignatures.create.returnType} {    
         const newItem = this.${decoderFunctionName}(
           await this.db.${meta.data.repository.getMethodFnName}.create({
             data: this.toCreateItem(this.verifyItem(item)),
@@ -387,11 +419,19 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         
         await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: newItems.map(i => this.toCreateItem(i)) })
         
-        for (const item of newItems) {
+        const dbItems = await this.db.${meta.data.repository.getMethodFnName}.findMany({ 
+          where: { 
+            ${model.idField.sourceName}: { in: newItems.map(i => i.${model.idField.name}) } 
+          } 
+        })
+
+        const result = dbItems.map((item) => this.${decoderFunctionName}(item))
+
+        for (const item of result) {
           this.set(item)
         }
         
-        return newItems
+        return result
       }`,
         // prettier-ignore
         updateCode: `
@@ -411,8 +451,8 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
               ${idField.sourceName}: item.${idField.name},
             },
             data: {
-              ${[...model.fields.values()]
-            .filter((f) => f.kind !== 'id')
+              ${Array.from(model.fields.values())
+            .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
             .map((f) => f.isRequired
             ? `${f.sourceName}: item.${f.name} ?? existingItem.${f.name}`
             : `${f.sourceName}: item.${f.name}`)
@@ -442,7 +482,9 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       /**
        * Utility function that converts a given Database object to a TypeScript model instance
        */
-      private ${decoderFunctionName}(item: Pick<DbType, ${Array.from(model.fields.values()).map((f) => `'${f.sourceName}'`).join(' | ')}>): ${model.typeName} {
+      private ${decoderFunctionName}(
+        item: Pick<DbType, ${Array.from(model.fields.values()).map((f) => `'${f.sourceName}'`).join(' | ')}>
+      ): ${model.typeName} {
         return ${meta.types.zodDecoderFnName}.parse({
           ${Array.from(model.fields.values()).map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
         })
@@ -507,6 +549,7 @@ function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
       }
       const ${idField.name} = ${meta.types.toBrandedIdTypeFnName}(item.${idField.name})`,
         setCode: '',
+        createFunctionParameterType: model.typeName,
     };
 }
 /**
@@ -514,6 +557,8 @@ function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
  * Given chunks make sure that the id is unique if provided or generate a new one if not.
  */
 function _generateIdBlock_Int({ idField, model, meta, }) {
+    const generatedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
+    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly);
     return {
         libraryImports: '',
         generateNextIdFunctionName: `
@@ -523,8 +568,14 @@ function _generateIdBlock_Int({ idField, model, meta, }) {
       }`,
         initCode: `this.currentMaxId = (await this.db.${meta.data.repository.getMethodFnName}.aggregate({ _max: { ${idField.sourceName}: true } }))._max.${idField.sourceName} ?? 0`,
         verifyFunctionComment: 'the id is generated by increasing the highest former id and assigned to the item.',
-        verifyFunctionParameterType: `(Omit<${model.typeName}, '${idField.name}'> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+        // prettier-ignore
+        verifyFunctionParameterType: `(Omit<${model.typeName}, ${generatedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
         verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+        createFunctionParameterType: 
+        // NOTE: In case we have readonly fields, we need to omit them from the create function.
+        readonlyFields.length === 0
+            ? model.typeName
+            : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
         setCode: `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }`,
     };
 }
@@ -533,6 +584,8 @@ function _generateIdBlock_Int({ idField, model, meta, }) {
  * It allows you to provide a custom id or generates a new one if not.
  */
 function _generateIdBlock_UUID({ idField, model, meta, }) {
+    const dbGeneratedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
+    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly);
     return {
         libraryImports: `import { randomUUID } from 'crypto'`,
         generateNextIdFunctionName: `
@@ -541,8 +594,14 @@ function _generateIdBlock_UUID({ idField, model, meta, }) {
       }`,
         initCode: '',
         verifyFunctionComment: 'a new UUID is generated and assigned to the item.',
-        verifyFunctionParameterType: `(Omit<${model.typeName}, '${idField.name}'> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+        // prettier-ignore
+        verifyFunctionParameterType: `(Omit<${model.typeName}, ${dbGeneratedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
         verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+        createFunctionParameterType: 
+        // NOTE: In case we have readonly fields, we need to omit them from the create function.
+        readonlyFields.length === 0
+            ? model.typeName
+            : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
         setCode: '',
     };
 }

package/dist/generators/models/route.generator.js

@@ -77,7 +77,7 @@ export const ${meta.trpc.routerName} = router({
 exports.generateRoute = generateRoute;
 function getCreateMethod({ model: { fields }, meta }) {
     const parameters = fields
-        .filter((f) => f.kind !== 'id')
+        .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
         .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`)
         .join(',');
     return `
@@ -89,6 +89,7 @@ function getCreateMethod({ model: { fields }, meta }) {
 }
 function getUpdateMethod({ model: { fields }, meta }) {
     const parameters = fields
+        .filter((f) => !f.attributes.isReadonly)
         .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field, allowAnyOptionalField: field.kind !== 'id' })}`)
         .join(',');
     return `update: procedure

package/dist/lib/attributes.d.ts

@@ -30,19 +30,44 @@ export type ModelAttributes = {
 export type FieldAttributes = {
     /**
      * Schema tag: ´@@Ignore()`
+     *
+     * Field will be ignored by the generator and not be exposed from the database.
      */
     ignore: boolean;
+    /**
+     * Schema tag: ´@@Readonly()`
+     *
+     * Field is generated by the database and shall not be edited by the user. It is readable though.
+     */
+    isReadonly: boolean;
+    /**
+     * Derived from Prisma's @updatedAt attribute.
+     *
+     * Field represents the last time the record was updated.
+     */
+    isUpdatedAt: boolean;
+    /**
+     * Automatically set is field name is "createdAt".
+     * Field represents the time the record was created.
+     */
+    isCreatedAt: boolean;
     /**
      * Schema tag: ´@@Description("Description of the field")`
+     *
+     * The description that is generated as a JSDoc comment in the code.
      */
     description?: string;
     /**
-     * Schema tag: ´@@Examples("Example1", "Example2")`
+     * Schema tag: ´@@Examples("Example1", "Example2")` or `@@Example("Example1")`
+     *
+     * Examples that are generated as a JSDoc comment in the code and used as seed/test data.
      */
-    examples?: (string | number | boolean)[];
+    examples?: (string | number | boolean | null)[];
     /**
      * Schema tag: ´@@DefaultField()`
      * The property of the model that identifies the default row.
+     *
+     * If this is set, the repository will verify that exactly one record has this field set to true - and use it as the default record.
      */
     isDefaultField?: boolean;
     /**

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

@@ -1,17 +1,20 @@
 import { Field, FieldEnum, FieldRelation, FieldScalar } from './schema';
 /**
  * The default field of the model.
- * Note: A model can only have one or no default field!
- * This is enforced by the schema validation.
+ *
+ * NOTE: A model can only have one or no default field! We enforce this by schema validation.
  */
 export declare const getDefaultField: ({ fields }: {
     fields: Field[];
 }) => FieldScalar | undefined;
 /**
- * List of all scalar fields of the model (excluding foreing keys and the id)
+ * List of all scalar fields of the model (excluding foreing keys and the id).
+ *
+ * If you provide an optional `tsTypeName` parameter, only scalar fields of that type are returned.
  */
-export declare const getScalarFields: ({ fields }: {
+export declare const getScalarFields: ({ fields, tsTypeName }: {
     fields: Field[];
+    tsTypeName?: string | undefined;
 }) => FieldScalar[];
 /**
  * List of all relation fields of the model.

package/dist/lib/schema/fields.js

@@ -3,15 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMaxLengthStringField = exports.isUniqueStringField = exports.getDefaultValueForType = exports.getEnumFields = exports.getRelationFields = exports.getScalarFields = exports.getDefaultField = void 0;
 /**
  * The default field of the model.
- * Note: A model can only have one or no default field!
- * This is enforced by the schema validation.
+ *
+ * NOTE: A model can only have one or no default field! We enforce this by schema validation.
  */
 const getDefaultField = ({ fields }) => fields.find((f) => f.attributes.isDefaultField);
 exports.getDefaultField = getDefaultField;
 /**
- * List of all scalar fields of the model (excluding foreing keys and the id)
+ * List of all scalar fields of the model (excluding foreing keys and the id).
+ *
+ * If you provide an optional `tsTypeName` parameter, only scalar fields of that type are returned.
  */
-const getScalarFields = ({ fields }) => fields.filter((f) => f.kind === 'scalar');
+const getScalarFields = ({ fields, tsTypeName }) => {
+    if (tsTypeName) {
+        return fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === tsTypeName);
+    }
+    return fields.filter((f) => f.kind === 'scalar');
+};
 exports.getScalarFields = getScalarFields;
 /**
  * List of all relation fields of the model.

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

@@ -148,6 +148,14 @@ export type ModelFields = {
      * The id field of the model
      */
     idField: FieldId;
+    /**
+     * The field of the model that identifies when the entry was created.
+     */
+    createdAtField?: FieldScalar;
+    /**
+     * The field of the model that identifies when the entry was last updated.
+     */
+    updatedAtField?: FieldScalar;
     /**
      * The property of the model that identifies the default row.
      */

package/dist/lib/utils/ast.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A collection of utility functions that let you more easily write TypeScript code.
+ */
+/**
+ * Utility function that lets you easily create a TypeScript switch statement.
+ */
+export declare function createSwitchStatement({ field, cases, defaultBlock, }: {
+    /**
+     * The variable name to switch on.
+     */
+    field: string;
+    /**
+     * The cases to switch on.
+     */
+    cases: {
+        /**
+         * The value to match.
+         */
+        match: string;
+        /**
+         * The body of the switch case.
+         */
+        block: string;
+    }[];
+    /**
+     * The execution block of the default case.
+     */
+    defaultBlock?: string;
+}): string;

package/dist/lib/utils/ast.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * A collection of utility functions that let you more easily write TypeScript code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwitchStatement = void 0;
+/**
+ * Utility function that lets you easily create a TypeScript switch statement.
+ */
+function createSwitchStatement({ field, cases, defaultBlock, }) {
+    const _cases = cases.map(_createSwitchCase).join('\n');
+    const _default = defaultBlock ? `default: {\n${defaultBlock}\n}` : '';
+    return `
+switch (${field}) {
+	${_cases}
+	${_default}
+}
+	`;
+}
+exports.createSwitchStatement = createSwitchStatement;
+function _createSwitchCase({ match, block, }) {
+    return `case ${match}: {\n${block}\n}`;
+}

package/dist/lib/utils/jsdoc.d.ts

@@ -1,4 +1,4 @@
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
-export declare function convertToJsDocComments(comments: string[]): string;
+export declare function jsDocComment(lines: string[]): string;

package/dist/lib/utils/jsdoc.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToJsDocComments = void 0;
+exports.jsDocComment = void 0;
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
-function convertToJsDocComments(comments) {
-    return comments
+function jsDocComment(lines) {
+    const _lines = lines
         .filter((c) => c !== '')
         .map((c) => `\n   * ${c}`)
         .join('');
+    return `/**${_lines}\n   */`;
 }
-exports.convertToJsDocComments = convertToJsDocComments;
+exports.jsDocComment = jsDocComment;

package/dist/prisma/attributes.js

@@ -4,9 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldAttributes = exports.getEnumAttributes = exports.getModelAttributes = exports.parseArgumentToStringOrStringArray = exports.parseAttributesFromDocumentation = void 0;
-const remeda_1 = require("remeda");
-const string_1 = require("../lib/utils/string");
 const zod_1 = __importDefault(require("zod"));
+const string_1 = require("../lib/utils/string");
 /**
  * Parses attributes from a given string using provided prefix.
  */
@@ -113,31 +112,47 @@ exports.getEnumAttributes = getEnumAttributes;
  */
 function getFieldAttributes(field) {
     const attributes = parseAttributesFromDocumentation(field);
-    if (attributes.examples === undefined && attributes.example !== undefined) {
-        attributes.examples = attributes.example;
-    }
     // Prisma also has an "@ignore" attribute - see https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#ignore
     // we handle this the same way as our custom "ignore" attribute
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const isPrismaIgnored = field.isIgnored === true;
-    const isPXLIgnored = Object.hasOwn(attributes, 'ignore');
-    return {
-        ignore: isPrismaIgnored || isPXLIgnored,
-        description: attributes.description && (0, remeda_1.isString)(attributes.description) ? attributes.description : undefined,
-        isDefaultField: Object.hasOwn(attributes, 'isDefault'),
-        isLabel: Object.hasOwn(attributes, 'isLabel'),
-        examples: !attributes.examples
-            ? undefined
-            : Array.isArray(attributes.examples)
-                ? attributes.examples
-                : [attributes.examples],
-        maxLength: Object.hasOwn(attributes, 'maxLength')
-            ? (0, remeda_1.isString)(attributes.maxLength)
-                ? parseInt(attributes.maxLength, 10)
-                : (0, remeda_1.isNumber)(attributes.maxLength)
-                    ? attributes.maxLength
-                    : undefined
-            : undefined,
-    };
+    const exampleDecoder = zod_1.default.union([zod_1.default.string(), zod_1.default.number(), zod_1.default.boolean(), zod_1.default.null()]);
+    const examplesDecoder = exampleDecoder
+        .transform((obj) => [obj])
+        .or(zod_1.default.array(exampleDecoder))
+        .optional();
+    const decoder = zod_1.default
+        .object({
+        ignore: blankStringBooleanDecoder,
+        description: zod_1.default.string().optional(),
+        isDefault: blankStringBooleanDecoder,
+        label: blankStringBooleanDecoder,
+        example: examplesDecoder,
+        examples: examplesDecoder,
+        maxLength: zod_1.default
+            .number()
+            .or(zod_1.default.string().transform((s) => parseInt(s, 10)))
+            .optional(),
+        readonly: blankStringBooleanDecoder,
+    })
+        .transform((obj) => {
+        var _a;
+        return ({
+            ignore: obj.ignore || isPrismaIgnored,
+            description: obj.description,
+            isDefaultField: obj.isDefault,
+            isLabel: obj.label,
+            examples: obj.examples || obj.example,
+            maxLength: obj.maxLength,
+            isReadonly: obj.readonly || field.isGenerated || field.isUpdatedAt || field.name === 'createdAt',
+            isUpdatedAt: (_a = field.isUpdatedAt) !== null && _a !== void 0 ? _a : false,
+            isCreatedAt: field.name === 'createdAt',
+        });
+    });
+    const result = decoder.safeParse(attributes);
+    if (!result.success) {
+        throw new Error(`Field ${field.name} has invalid field attributes: ${result.error.toString()}`);
+    }
+    return result.data;
 }
 exports.getFieldAttributes = getFieldAttributes;

package/dist/prisma/parse.js

@@ -146,17 +146,21 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         (0, error_1.throwError)(`Investigate: Field ${shared.sourceName}.${shared.sourceName} is not scalar, enum nor relation.`);
     })
         .filter((field) => !isFieldIgnored({ field }));
-    const { idField, defaultField, nameField } = validateFields({ fields, model: core });
+    const { idField, defaultField, nameField, createdAtField, updatedAtField } = validateFields({ fields, model: core });
     return Object.assign(Object.assign({}, core), { idField,
         defaultField,
         nameField,
-        fields });
+        fields,
+        createdAtField,
+        updatedAtField });
 }
 /**
  * Checks that there is exactly one id field and that there is at most one default field.
  */
 function validateFields({ fields, model: { name } }) {
     let idField = undefined;
+    let createdAtField = undefined;
+    let updatedAtField = undefined;
     let nameField = undefined;
     let nameFieldFallback = undefined;
     let defaultField = undefined;
@@ -166,6 +170,18 @@ function validateFields({ fields, model: { name } }) {
                 if (field.name === 'name') {
                     nameFieldFallback = field;
                 }
+                if (field.attributes.isCreatedAt) {
+                    if (createdAtField) {
+                        throw new Error(`❌❌❌ Model ${name} has multiple createdAt fields`);
+                    }
+                    createdAtField = field;
+                }
+                if (field.attributes.isUpdatedAt) {
+                    if (updatedAtField) {
+                        throw new Error(`❌❌❌ Model ${name} has multiple updatedAt fields`);
+                    }
+                    updatedAtField = field;
+                }
                 break;
             case 'id':
                 if (idField) {
@@ -199,7 +215,7 @@ function validateFields({ fields, model: { name } }) {
     if (!nameField && nameFieldFallback) {
         nameField = nameFieldFallback;
     }
-    return { idField, defaultField, nameField };
+    return { idField, defaultField, nameField, createdAtField, updatedAtField };
 }
 function isAutoIncrementField(fieldDmmf) {
     if (fieldDmmf.default === undefined) {
@@ -232,9 +248,6 @@ function isUniqueField(fieldRaw) {
  * Tells whether the parsed schema should skip a given field.
  */
 function isFieldIgnored({ field }) {
-    if (field.name === 'createdAt' || field.name === 'updatedAt' || field.name === 'deletedAt') {
-        return true;
-    }
     if (Object.hasOwn(field.attributes, 'ignore') && field.attributes.ignore) {
         return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {