@postxl/generator 0.69.0 → 0.69.1

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,29 +21,13 @@ 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 });
@@ -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.

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]: [

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;

package/dist/generators/models/{businesslogic-update.generator.d.ts → update/service.generator.d.ts}

@@ -1,5 +1,5 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
+import { ModelMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
 /**
  * Generates update business logic for a given model.
  * The update logic handles all Create/Update/Delete/Upsert operations. See template's readme for more info.