@postxl/generator 0.69.0 → 0.70.0

package/dist/generators/models/importexport-decoder.generator.js

@@ -5,17 +5,18 @@ const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const types_1 = require("../../lib/schema/types");
 const types_2 = require("../../lib/types");
+const zodPackageName = (0, types_1.toPackageName)('@postxl/zod');
 /**
  * Creates a decoder for the Seed Excel template.
  */
-function generateModelImportExportDecoder({ model, meta, schemaMeta, }) {
+function generateModelImportExportDecoder({ model, meta }) {
     const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
     const imports = imports_1.ImportsGenerator.from(decoderFilePath).addImports({
-        [schemaMeta.backendModules.common.importPath]: [schemaMeta.backendModules.common.functions.excelNullOrBlankDecoder],
+        [zodPackageName]: [(0, types_1.toFunctionName)('excelNullOrBlankDecoder')],
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
     });
     const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
-    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, schemaMeta, imports });
+    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
     return `
 import * as z from 'zod'
 
@@ -72,7 +73,7 @@ export const ${tableExportFunctionName} = (items: ${model.typeName}[]): ${excelT
   `;
 }
 exports.generateModelImportExportDecoder = generateModelImportExportDecoder;
-function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
+function generateFieldDecoders({ model, meta, imports, }) {
     const fieldDecoders = [];
     const blankFieldDecoders = [];
     for (const field of model.fields) {
@@ -84,20 +85,16 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: false,
                     imports,
-                    schemaMeta,
                 })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
                 break;
             }
             case 'scalar': {
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.tsTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: !field.isRequired,
                     imports,
-                    schemaMeta,
                 })}${optionalModifier}`);
                 break;
             }
@@ -107,10 +104,8 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
                 imports.addImport({ items: [refMeta.types.toBrandedIdTypeFnName], from: refMeta.types.importPath });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: !field.isRequired,
                     imports,
-                    schemaMeta,
                 })}
           .transform(
             (id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => 
@@ -131,50 +126,26 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
     }
     return { fieldDecoders, blankFieldDecoders };
 }
-function toExcelDecoder({ tsTypeName, 
-// We will use the DB type later when extending the number decoder
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-dbTypeName, nullable, imports, schemaMeta, }) {
+function toExcelDecoder({ tsTypeName, nullable, imports, }) {
     switch (tsTypeName) {
         case 'string': {
-            const decoder = schemaMeta.backendModules.common.functions[nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder'];
-            imports.addImport({ items: [decoder], from: schemaMeta.backendModules.common.importPath });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelStringNullableDecoder') : (0, types_1.toFunctionName)('excelStringDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
+            return decoder;
+        }
+        case 'boolean': {
+            const decoder = (0, types_1.toFunctionName)('excelBooleanDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
-        case 'boolean':
-            imports.addImport({
-                items: [schemaMeta.backendModules.common.functions.excelBooleanDecoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
-            return 'excelBooleanDecoder';
         case 'number': {
-            let decoder;
-            switch (dbTypeName) {
-                case 'Int':
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-                case 'BigInt':
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-                default:
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-            }
-            imports.addImport({
-                items: [decoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelNumberNullableDecoder') : (0, types_1.toFunctionName)('excelNumberDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
         case 'Date': {
-            const decoder = schemaMeta.backendModules.common.functions[nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder'];
-            imports.addImport({
-                items: [decoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelDateNullableDecoder') : (0, types_1.toFunctionName)('excelDateDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
         default:

package/dist/generators/models/repository.generator.d.ts

@@ -7,42 +7,3 @@ export declare function generateRepository({ model, meta }: {
     model: Model;
     meta: ModelMetaData;
 }): string;
-type FnSignature = {
-    /**
-     * A list of ordered TypeScript types where the first type in the list corresponds to the type of the
-     * first parameter and so on. Note that the parameters don't contain names, only types.
-     *
-     * @example
-     *
-     * ```
-     * function foo(a: string, b: number, c: boolean) {}
-     * // ['string', 'number', 'boolean']
-     * ```
-     */
-    parameters: string[];
-    /**
-     * The return type of the function.
-     */
-    returnType: string;
-    /**
-     * The JSDoc comment of the function.
-     */
-    jsDoc?: string[];
-};
-/**
- * Returns a collection of type signatures for the repository methods of a given model.
- */
-export declare function getRepositoryMethodsTypeSignatures({ model, meta }: {
-    model: Model;
-    meta: ModelMetaData;
-}): {
-    create: FnSignature;
-    createMany: FnSignature;
-    update: FnSignature;
-    updateMany: FnSignature;
-    upsert: FnSignature;
-    upsertMany: FnSignature;
-    delete: FnSignature;
-    deleteMany: FnSignature;
-};
-export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRepositoryMethodsTypeSignatures = exports.generateRepository = void 0;
+exports.generateRepository = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
@@ -21,35 +21,19 @@ function generateRepository({ model, meta }) {
             (0, types_1.toAnnotatedTypeName)(model.typeName),
             (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
             meta.types.toBrandedIdTypeFnName,
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.create),
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.update),
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.upsert),
+            meta.types.dto.create,
+            meta.types.dto.update,
+            meta.types.dto.upsert,
+            meta.types.dto.clone,
         ],
         [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
     });
-    // 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:
-    //  1.) if the model has a default field, the repository will have a public variable "defaultValue"
-    //      that is set and verified during init,
-    //  2.) if the model has a generated id, the repository will have a function "generateNextId" that
-    //      is used to generate the next id. The `create` and `createMany` functions will use this function
-    //      and allow being called with an id,
-    //  3.) unique string fields are ensured to be unique,
-    //  4.) max length string fields are ensured to not exceed their max length,
-    //  5.) index for fields marked with index or unique attribute,
-    //  6.) relations are indexed by the foreign key.
-    //
-    // The repository is generated differently based on whether the model is stored in the database or in memory.
-    // If the model is stored in the database, all CUD operations will result in a database call. If the model is
-    // stored in memory, all CUD operations will be performed in memory without any database calls.
     const idBlocks = generateIdBlocks({ model, meta });
     const defaultValueBlocks = generateDefaultBlocks({ model, meta });
     const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
     const maxLengthBlocks = generateMaxLengthBlocks({ model, meta });
     const validationBlocks = generateValidationBlocks({ model, meta });
-    const indexBlocks = generateIndexBlocks({ model, schemaMeta, meta, imports });
+    const indexBlocks = generateIndexBlocks({ model, imports });
     const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
     imports.addImports({
         [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
@@ -58,7 +42,6 @@ function generateRepository({ model, meta }) {
         [(0, types_1.toPackageName)('@postxl/runtime')]: [(0, types_1.toFunctionName)('format'), (0, types_1.toFunctionName)('pluralize')],
     });
     const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports });
-    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
     return `
 import { Injectable, Logger } from '@nestjs/common'
 ${idBlocks.libraryImports}
@@ -193,10 +176,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
   public async create(
-    { item, execution }: ${methodTypeSignatures.create.parameters[0]}
-  ): ${methodTypeSignatures.create.returnType} {
+    { item, execution }: { item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
     const mutationId = await execution.startCreateMutation({ 
       model: '${meta.actions.actionScopeConstType}', 
       createObject: item 
@@ -218,10 +201,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
   public async createMany(
-    {items, execution}: ${methodTypeSignatures.createMany.parameters[0]}
-  ): ${methodTypeSignatures.createMany.returnType} {
+    {items, execution}: { items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
     const mutationId = await execution.startCreateManyMutation({ 
       model: '${meta.actions.actionScopeConstType}', 
       createObjects: items 
@@ -256,10 +239,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
   
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
   public async update(
-    { item, execution }: ${methodTypeSignatures.update.parameters[0]}
-  ): ${methodTypeSignatures.update.returnType} {
+    { item, execution }: { item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
     const existingItem = await this.get(item.${idField.name})
     if (!existingItem) {
       throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
@@ -303,10 +286,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
   
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
   public async updateMany(
-    { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
-  ): ${methodTypeSignatures.updateMany.returnType} {
+    { items, execution }: { items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
     const result: ${model.typeName}[] = []
     for (const item of items) {
       try {
@@ -319,10 +302,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     return result
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
   public async upsert(
-    { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
-  ): ${methodTypeSignatures.upsert.returnType} {
+    { item, execution }: { item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
     const existingItem = item.${model.idField.name} ? (await this.get(item.${model.idField.name})) : null
     if (existingItem) {
       return this.update({ item: item as ${meta.types.dto.update}, execution })
@@ -331,10 +314,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
   public async upsertMany(
-    { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
-  ): ${methodTypeSignatures.upsertMany.returnType} {
+    { items, execution }: { items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
     const result: ${model.typeName}[] = []
     for (const item of items) {
       try {
@@ -347,10 +330,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     return result
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
   public async delete(
-    { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
-  ): ${methodTypeSignatures.delete.returnType} {
+    { id, execution }: { id: ${model.brandedIdType}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.brandedIdType}> {
     const existingItem = await this.get(id)
     if (!existingItem) {
       throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
@@ -374,10 +357,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     }
   }
 
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
   public async deleteMany(
-    { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
-  ): ${methodTypeSignatures.deleteMany.returnType} {
+    { ids, execution }: { ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.brandedIdType}[]> {
     const deletedIds: ${model.brandedIdType}[] = []
     for (const id of ids) {
       try {
@@ -390,6 +373,23 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     return deletedIds 
   }
 
+  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} shallow clone and returns it.`])}
+  public async clone({ id, item, execution }: {
+    id: ${model.brandedIdType}
+    item: (item: ${model.typeName}) => ${meta.types.dto.clone},
+    execution: ${schemaMeta.actions.execution.interface}
+  }): Promise<${model.typeName}> {
+    const source = await this.get(id)
+    if (!source) {
+      throw new Error(\`${meta.userFriendlyName} with id \${id} not found\`)
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { id: _, ...data } = { ...source, ...item(source) }
+
+    return await this.create({ item: data, execution })
+  }
+
   ${relationsBlocks.getterFunctions.join('\n')}
 
   ${maxLengthBlocks.ensureMaxLengthFunctions.join('\n')}
@@ -593,139 +593,67 @@ function generateSharedRootUserBlocks({ model, meta, imports, }) {
 function generateIdBlocks({ model, meta }) {
     const idField = model.idField;
     if (!idField.isGenerated) {
-        return _generateIdBlocks_NoGeneration({ idField, model, meta });
+        return {
+            libraryImports: '',
+            generateNextIdFunctionName: '',
+            initCode: '',
+            verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
+            verifyFunctionParameterType: meta.types.dto.create,
+            verifyCode: `
+        if (item.${idField.name} === undefined) {
+          throw new Error('Id field ${idField.name} is required!')
+        }
+        const ${idField.name} = ${meta.types.toBrandedIdTypeFnName}(item.${idField.name})`,
+            setCode: '',
+            createFunctionParameterType: model.typeName,
+        };
     }
     if (idField.schemaType === 'Int') {
-        return _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 && f.kind !== 'id');
+        return {
+            libraryImports: '',
+            generateNextIdFunctionName: `
+          protected currentMaxId = 0
+          public generateNextId(): ${model.brandedIdType} {
+            return ${meta.types.toBrandedIdTypeFnName}(++this.currentMaxId)
+          }`,
+            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.',
+            // 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 }`,
+        };
     }
     if (idField.schemaType === 'String') {
-        return _generateIdBlock_UUID({ idField, model, meta });
-    }
-    throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
-}
-/**
- * Returns a collection of type signatures for the repository methods of a given model.
- */
-// NOTE: We export this function as an interface simplification to the repository generator. Internally, we
-//   use the same functions as the ones used in this function which we don't want to expose.
-function getRepositoryMethodsTypeSignatures({ model, meta }) {
-    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    return {
-        create: {
-            jsDoc: [`Creates a new ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        createMany: {
-            jsDoc: [`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        update: {
-            jsDoc: [`Updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        updateMany: {
-            jsDoc: [`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        upsert: {
-            jsDoc: [`Creates or updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        upsertMany: {
-            jsDoc: [`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        delete: {
-            jsDoc: [`Deletes a ${meta.userFriendlyName} and returns its id.`],
-            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.brandedIdType}>`,
-        },
-        deleteMany: {
-            jsDoc: [`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`],
-            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.brandedIdType}[]>`,
-        },
-    };
-}
-exports.getRepositoryMethodsTypeSignatures = getRepositoryMethodsTypeSignatures;
-/**
- * Generates the id block code chunks for a model that requires an ID field to be manually
- * supplied to the create function.
- */
-function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
-    return {
-        libraryImports: '',
-        generateNextIdFunctionName: '',
-        initCode: '',
-        verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
-        verifyFunctionParameterType: meta.types.dto.create,
-        verifyCode: `
-      if (item.${idField.name} === undefined) {
-        throw new Error('Id field ${idField.name} is required!')
-      }
-      const ${idField.name} = ${meta.types.toBrandedIdTypeFnName}(item.${idField.name})`,
-        setCode: '',
-        createFunctionParameterType: model.typeName,
-    };
-}
-/**
- * Generates the id block code chunks for a model that has an integer id field.
- * 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 && f.kind !== 'id');
-    return {
-        libraryImports: '',
-        generateNextIdFunctionName: `
-      protected currentMaxId = 0
-      public generateNextId(): ${model.brandedIdType} {
-        return ${meta.types.toBrandedIdTypeFnName}(++this.currentMaxId)
-      }`,
-        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.',
-        // 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 }`,
-    };
-}
-/**
- * Generates the id block code chunks for a model that has a UUID id field.
- * 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 && f.kind !== 'id');
-    return {
-        libraryImports: `import { randomUUID } from 'crypto'`,
-        generateNextIdFunctionName: `
+        const dbGeneratedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
+        const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly && f.kind !== 'id');
+        return {
+            libraryImports: `import { randomUUID } from 'crypto'`,
+            generateNextIdFunctionName: `
       public generateNextId(): ${model.brandedIdType} {
         return ${meta.types.toBrandedIdTypeFnName}(randomUUID())
       }`,
-        initCode: '',
-        verifyFunctionComment: 'a new UUID is generated and assigned to the item.',
-        // 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: '',
-    };
+            initCode: '',
+            verifyFunctionComment: 'a new UUID is generated and assigned to the item.',
+            // 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: '',
+        };
+    }
+    throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
 }
 /**
  * Returns the code chunks that define the default value property and its initialization.
@@ -900,10 +828,10 @@ function generateValidationBlocks({ model }) {
     }
     return result;
 }
-function generateIndexBlocks({ model, imports, schemaMeta, }) {
+function generateIndexBlocks({ model, imports }) {
     const indexes = model.attributes.index ? [getIndexDefinition({ fieldNames: model.attributes.index, model })] : [];
     if (indexes.length > 0) {
-        imports.addTypeImport({ items: [(0, types_1.toTypeName)('NestedMap')], from: schemaMeta.backendModules.common.importPath });
+        imports.addTypeImport({ from: (0, types_1.toPackageName)('@postxl/runtime'), items: [(0, types_1.toTypeName)('NestedMap')] });
     }
     const result = {
         nestedMapDeclarations: [],

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

@@ -8,9 +8,9 @@ const types_1 = require("../../lib/schema/types");
  */
 function generateRoute({ model, meta }) {
     const { idField, defaultField } = model;
-    const { scopeName, dataRepositoryVariableName } = meta.update;
+    const { scopeName } = meta.update;
     const defaultValueMethod = `
-    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
+    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.data.defaultValue),
   `;
     const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
         [meta.types.importPath]: [
@@ -27,7 +27,7 @@ function generateRoute({ model, meta }) {
     });
     return /* ts */ `
 import { z } from 'zod'
-import { procedure, router } from '../trpc'
+import { authMiddleware, procedure, router } from '../trpc'
 
 ${imports.generate()}
 
@@ -64,18 +64,22 @@ export const ${meta.trpc.routerName} = router({
     }),
 
     create: procedure
+      .use(authMiddleware)
       .input(${meta.update.createInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "create", payload: input})),
     
     update: procedure
+      .use(authMiddleware)
       .input(${meta.update.updateInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "update", payload: input})),
 
     upsert: procedure
+      .use(authMiddleware)
       .input(${meta.update.upsertInputDecoder})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsert", payload: input})),
 
     delete: procedure
+      .use(authMiddleware)
       .input(${meta.types.zodDecoderFnNames.id})
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "delete", payload: input})),
 })

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

@@ -53,8 +53,6 @@ export type ${meta.types.typeName} = {
         .join('\n')}
 }
 
-
-
 /**
  * Branded Id type that should be used to identify an instance of a ${meta.userFriendlyName}.
  */
@@ -95,6 +93,33 @@ export type ${meta.types.dto.update} = ${schemaMeta.types.dto.update}<${meta.typ
  * Data transfer object for upserting a new or existing ${meta.userFriendlyName} instance.
  */
 export type ${meta.types.dto.upsert} = ${schemaMeta.types.dto.upsert}<${meta.types.typeName}, ${model.brandedIdType}>
+
+/**
+ * Data transfer object for cloning a new ${meta.userFriendlyName} instance.
+ */
+export type ${meta.types.dto.clone} = { 
+  ${model.fields
+        .map((f) => {
+        const type = (0, typescript_1.getFieldType)(f);
+        // NOTE: ID field is always required to resolve the source.
+        if (f.kind === 'id') {
+            return `${f.name}: ${type}`;
+        }
+        if (f.isUnique) {
+            // NOTE: `unique` fields require a new value.
+            if (f.isRequired) {
+                return `${f.name}: ${type}`;
+            }
+            return `${f.name}: ${type} | null`;
+        }
+        // NOTE: Non-unique fields can be copied from the source.
+        if (f.isRequired) {
+            return `${f.name}?: ${type}`;
+        }
+        return `${f.name}?: ${type} | null`;
+    })
+        .join(', ')} 
+}
 `;
 }
 exports.generateModelTypes = generateModelTypes;