@postxl/generator 0.56.6 → 0.56.8

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

@@ -1,54 +1,59 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelBusinessLogicUpdate = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
-const types_1 = require("../../lib/schema/types");
+const Types = __importStar(require("../../lib/schema/types"));
 const zod_1 = require("../../lib/schema/zod");
 const jsdoc_1 = require("../../lib/utils/jsdoc");
+const string_1 = require("../../lib/utils/string");
 /**
  * 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.
  */
 function generateModelBusinessLogicUpdate({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    /**
-     * Shorthand variable for relevant metadata.
-     */
     const m = {
-        /**
-         * The name of the interface that handles the action execution.
-         */
         iExecution: schemaMeta.actions.execution.interface,
-        /**
-         * The name of the type that represents a fully typed, flat object, e.g. `Aggregation`
-         */
         typeName: meta.types.typeName,
-        /**
-         * Type of the ID field that is specific to this model, e.g. `AggregationId`
-         */
         brandedId: model.brandedIdType,
-        /**
-         * Internal type name for create payload, e.g. `CreateAggregation`
-         */
         createType: `Create${meta.internalSingularNameCapitalized}`,
-        /**
-         * Internal type name for update payload, e.g. `UpdateAggregation`
-         */
         updateType: `Update${meta.internalSingularNameCapitalized}`,
-        /**
-         * Internal type name for upsert payload, e.g. `UpsertAggregation`
-         */
         upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
+        cloneType: `Clone${meta.internalSingularNameCapitalized}`,
     };
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
         [meta.data.importPath]: meta.data.repository.className,
         [meta.types.importPath]: [
-            (0, types_1.toAnnotatedTypeName)(m.brandedId),
-            (0, types_1.toAnnotatedTypeName)(m.typeName),
+            Types.toAnnotatedTypeName(m.brandedId),
+            Types.toAnnotatedTypeName(m.typeName),
             meta.types.toBrandedIdTypeFnName,
+            Types.toFunctionName(`omitId`),
         ],
         [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
         [schemaMeta.actions.importPath]: [schemaMeta.actions.execution.interface, schemaMeta.actions.dispatcher.definition],
@@ -66,6 +71,9 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
             from: refMeta.types.importPath,
         });
     }
+    for (const { referencingModel } of model.references) {
+        imports.addTypeImport({ items: [referencingModel.brandedIdType], from: meta.types.importPath });
+    }
     /**
      * The name of the variable that holds the repository instance for the current model
      * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
@@ -77,7 +85,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly updateService: ${schemaMeta.businessLogic.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly viewService: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
-    const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
+    const { zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject } = meta.businessLogic.update;
     const { view, update } = meta.businessLogic;
     /* prettier-ignore */
     return /* ts */ `
@@ -136,6 +144,12 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         payload: ${m.brandedId}[]
         result: ${m.brandedId}[]
       }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Clones a ${meta.userFriendlyName} and returns the clone.`])}
+      clone: {
+        payload: ${m.cloneType}
+        result: ${m.typeName}
+      }
     }
 
     /**
@@ -169,6 +183,18 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     
     type ${m.upsertType} = z.infer<typeof ${zodUpsertObject}>
 
+    /**
+     * Zod decoder for validating the clone input of a ${meta.userFriendlyName} .
+     */
+    export const ${zodCloneObject} = z.object({
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === "id")
+        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f, allowAnyOptionalField: f.kind !== 'id' })}`)
+        .join(',')}
+    })
+
+    type ${m.cloneType} = z.infer<typeof ${zodCloneObject}>
+
     export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
 
     @Injectable()
@@ -213,16 +239,122 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         return this.data.upsertMany({ items: data, execution })
       }
 
-      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
-      public async delete({ data, execution }: { data: ${m.brandedId}; execution: ${m.iExecution} }): Promise<${m.brandedId}> {
-        return this.data.delete({ id: data, execution })
-      }
+      
+      ${generateDeleteFunction({ model, meta, m })}
 
-      ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
-      public async deleteMany({ data, execution }: { data: ${m.brandedId}[]; execution: ${m.iExecution} }): Promise<${m.brandedId}[]> {
-        return this.data.deleteMany({ ids: data, execution })
-      }  
+      ${generateDeleteManyMethod({ model, meta, m })}
+
+      ${generateCloneMethod({ model, meta, m })}
     }
  `;
 }
 exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
+/**
+ * Returns a function implementation that deletes a single entity and all its related entities.
+ */
+function generateDeleteFunction({ model, meta, m }) {
+    const backReferenceDelete = [];
+    const backReferenceNames = [];
+    for (const { referencingField, referencingModel } of model.references) {
+        const refModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
+        const refFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
+        const ids = `${refModelMeta.internalSingularName}${(0, string_1.capitalize)(referencingField.name)}s`;
+        backReferenceNames.push(`${refModelMeta.userFriendlyNamePlural}.${referencingField.name}`);
+        backReferenceDelete.push(`
+      // ${referencingModel.name}.${referencingField.name}
+      const ${ids} = await this.viewService.${refModelMeta.businessLogic.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(data)
+      await this.updateService.${refModelMeta.businessLogic.update.serviceVariableName}.deleteMany({ data: ${ids}, execution })
+    `);
+    }
+    return `
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} instance and returns its id.`])}
+  public async delete(
+    { data, execution }: { data: ${m.brandedId}; execution: ${m.iExecution} }
+  ): Promise<${m.brandedId}> {
+    ${backReferenceDelete.join('\n')}
+    return this.data.delete({ id: data, execution })
+  }
+  `;
+}
+/**
+ * Returns a function that deletes multiple entities and all their related entities.
+ */
+function generateDeleteManyMethod({ model, meta, m }) {
+    const idArrays = [];
+    const idAssignments = [];
+    const deleteCalls = [];
+    for (const { referencingField, referencingModel } of model.references) {
+        const refModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
+        const refFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
+        const idArray = `${refModelMeta.internalSingularName}${(0, string_1.capitalize)(referencingField.name)}s`;
+        idArrays.push(`const ${idArray}: ${referencingModel.brandedIdType}[] = []`);
+        idAssignments.push(`
+      {
+        // ${referencingModel.name}.${referencingField.name}
+        const _ids = await this.viewService.${refModelMeta.businessLogic.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)
+        ${idArray}.push(..._ids)
+      }
+      `);
+        deleteCalls.push(`await this.updateService.${refModelMeta.businessLogic.update.serviceVariableName}.deleteMany({ data: ${idArray}, execution })`);
+    }
+    let relatedEntities = '';
+    if (model.references.length > 0) {
+        relatedEntities = `
+      ${idArrays.join('\n')}
+      
+      for (const id of ids) {
+        ${idAssignments.join('\n')}
+      }
+      
+      ${deleteCalls.join('\n')}
+    `;
+    }
+    return `
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
+  public async deleteMany(
+    { data: ids, execution }: { data: ${m.brandedId}[]; execution: ${m.iExecution} }
+  ): Promise<${m.brandedId}[]> {
+    if (ids.length === 0) {
+      return []
+    }
+    
+    ${relatedEntities}
+
+    return this.data.deleteMany({ ids, execution })
+  }`;
+}
+/**
+ * Returns a function that deep clones a given entity and all its related entities.
+ */
+function generateCloneMethod({ model, meta, m }) {
+    const backReferenceCloning = [];
+    const backReferenceNames = [];
+    for (const { referencingField, referencingModel } of model.references) {
+        const refModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
+        const refFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
+        backReferenceNames.push(`${refModelMeta.userFriendlyNamePlural}.${referencingField.name}`);
+        const { view, update } = refModelMeta.businessLogic;
+        backReferenceCloning.push(`
+      // ${referencingModel.name}.${referencingField.name}
+      for (const childId of await this.viewService.${view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
+        await this.updateService.${update.serviceVariableName}.clone({ data: { id: childId, ${referencingField.name}: clone.id }, execution })
+      }
+    `);
+    }
+    return `
+  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} deep clone and returns it.`])}
+  public async clone(
+    { data: { id, ...data }, execution }: { data: ${m.cloneType}; execution: ${m.iExecution} }
+  ): Promise<${m.typeName}> {
+    const source = await this.view.get(id)
+    if (!source) {
+      throw new Error(\`${meta.userFriendlyName} with id \${id} not found\`)
+    }
+
+    const clone = await this.data.create({ item: { ...omitId(source), ...data }, execution })
+
+    ${backReferenceCloning.join('\n')}
+
+    return clone
+  }`;
+}

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

@@ -12,14 +12,14 @@ function generateRoute({ model, meta }) {
     const defaultValueMethod = `
     getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
   `;
-    const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
+    const { zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject } = meta.businessLogic.update;
     const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
         [meta.types.importPath]: [
             (0, types_1.toAnnotatedTypeName)(model.typeName),
             meta.types.toBrandedIdTypeFnName,
             meta.types.zodDecoderFnNames.id,
         ],
-        [meta.businessLogic.update.serviceFilePath]: [zodCreateObject, zodUpdateObject, zodUpsertObject],
+        [meta.businessLogic.update.serviceFilePath]: [zodCreateObject, zodUpdateObject, zodUpsertObject, zodCloneObject],
     });
     return /* ts */ `
 import { z } from 'zod'
@@ -91,6 +91,10 @@ export const ${meta.trpc.routerName} = router({
     deleteMany: procedure
       .input(z.array(${meta.types.zodDecoderFnNames.id}))
       .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "deleteMany", payload: input})),
+
+    clone: procedure
+      .input(${zodCloneObject})
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "clone", payload: input})),
 })
 `;
 }

package/dist/lib/meta.d.ts

@@ -954,6 +954,10 @@ export type ModelMetaData = {
              * The name of the function that decodes an Upsert object to a fully typed object, e.g. `aggregationUpsertDecoder`.
              */
             zodUpsertObject: Types.FunctionName;
+            /**
+             * The name of the function that clones an object, e.g. `aggregationCloneDecoder`.
+             */
+            zodCloneObject: Types.FunctionName;
         };
         /**
          * Name by which the business logic service exposes the data service.

package/dist/lib/meta.js

@@ -346,6 +346,7 @@ function getModelMetadata({ model }) {
                 zodCreateObject: Types.toFunctionName(`${camelCase}CreateDecoder`),
                 zodUpdateObject: Types.toFunctionName(`${camelCase}UpdateDecoder`),
                 zodUpsertObject: Types.toFunctionName(`${camelCase}UpsertDecoder`),
+                zodCloneObject: Types.toFunctionName(`${camelCase}CloneDecoder`),
             },
             dataRepositoryVariableName: Types.toVariableName(`data`),
         },

package/package.json

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