@postxl/generator 0.68.0 → 0.69.1

package/dist/generators/indices/datamock-module.generator.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataMockModule = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates a mocking class
- */
-function generateDataMockModule({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.mockModule.location.path).addImports({
-        [meta.data.moduleLocation.path]: [meta.data.moduleName],
-        [meta.data.dataService.location.path]: [meta.data.dataService.class],
-        [meta.backendModules.db.moduleLocation.import]: [meta.backendModules.db.moduleName],
-        // we need to import the file directly instead via the normal index file as this would cause a circular dependency else
-        [meta.actions.execution.mockLocation.import]: [meta.actions.execution.mock],
-    });
-    for (const { model, meta } of mm) {
-        imports.addTypeImport({ items: [model.typeName], from: meta.types.importPath });
-        imports.addImport({ items: [meta.data.repository.className], from: meta.data.repository.location.path });
-        imports.addImport({ items: [meta.data.mockRepository.className], from: meta.data.mockRepository.location.path });
-    }
-    const providers = mm
-        .map(({ meta }) => `{ 
-          provide: ${meta.data.repository.className},
-          useFactory: async () => {
-            const repository = new ${meta.data.mockRepository.className}()
-            if (!!seed && !!seed.${meta.seed.constantName}) {
-              await repository.reInit({items: seed.${meta.seed.constantName}, execution })
-            }
-            return repository
-          }
-        }`)
-        .join(', ');
-    return /* ts */ `
-import { DynamicModule } from '@nestjs/common'
-
-${imports.generate()}
-
-export class ${meta.data.mockModule.name} {
-  static mock(seed?: MockData): DynamicModule {
-    const execution = new MockActionExecution()
-
-    const providers = [
-      DataService, 
-      ${providers} 
-    ]
-
-    return {
-      module: ${meta.data.moduleName},
-      imports: [DatabaseModule.provideMock()],
-      providers,
-      exports: providers,
-      global: true,
-    }    
-  }
-}
-
-export interface ${meta.data.dataMockDataType} {
-  ${mm.map(({ model, meta }) => `${meta.data.mockDataPropertyName}?: ${model.typeName}[]`).join('\n')}
-}
-`;
-}
-exports.generateDataMockModule = generateDataMockModule;

package/dist/generators/indices/datamocker.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates a generic data mocker class.
- */
-export declare function generateDataMocker({ models, meta: schemaMeta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/datamocker.generator.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataMocker = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const schema_1 = require("../../lib/schema/schema");
-const types_1 = require("../../lib/schema/types");
-/**
- * Generates a generic data mocker class.
- */
-function generateDataMocker({ models, meta: schemaMeta }) {
-    const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(schemaMeta.e2e.dataMockerLocation.path);
-    for (const { model, meta } of modelMetas) {
-        imports.addImports({
-            [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.typeName)],
-            [meta.e2e.stubLocation.path]: [meta.e2e.stubGenerationFnName],
-        });
-    }
-    const publicVariables = modelMetas
-        .map(({ model, meta }) => `public ${meta.data.dataServiceName}: ${model.typeName}[] = []`)
-        .join('\n');
-    const privateIds = modelMetas
-        .map(({ model, meta }) => `private ${meta.data.dataServiceIdName}Ids = new IdTracker<${model.typeName}>()`)
-        .join('\n');
-    const addDataFunctions = modelMetas.map(({ model, meta }) => generateAddDataFunction(model, meta)).join('\n');
-    return `
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import type { MockData } from '@backend/data/data.mock.module'
-
-${imports.generate()}
-
-import { IdTracker } from './id-tracker.class'
-
-
-export class DataMocker implements MockData {
-  ${publicVariables}
-
-  ${privateIds}
-
-  ${addDataFunctions}
-}
-`;
-}
-exports.generateDataMocker = generateDataMocker;
-function generateAddDataFunction(model, meta) {
-    const { fields, idField } = model;
-    const relations = fields
-        .filter(schema_1.isFieldRelation)
-        .map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }), model: field.relationToModel })))
-        .map((r) => {
-        if (r.isRequired) {
-            return `
-        if (_item.${r.name}) {
-          if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === _item.${r.name}) === -1) {
-            this.add${r.model.typeName}({ id: _item.${r.name} })
-          }
-        } else {
-          if (this.${r.meta.data.dataServiceName}.length === 0) {
-            this.add${r.model.typeName}()
-          }
-          _item.${r.name} = this.${r.meta.data.dataServiceName}[0].id
-        }
-      `;
-        }
-        return `
-      if (_item.${r.name}) {
-        if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === _item.${r.name}) === -1) {
-          this.add${r.model.typeName}({ id: _item.${r.name} })
-        }
-      }
-    `;
-    });
-    // TODO: Move the publicly accessible function's name to the metadata definition!
-    return /* ts */ `
-  public add${model.typeName}(
-    item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName} }>
-  ): DataMocker {
-    const _stub = stub${model.typeName}(item ?? {})
-    const _item = this.${meta.data.dataServiceIdName}Ids.ensureId(_stub)
-    
-    this.${meta.data.dataServiceName}.push(_item)
-    
-    ${relations.join('\n')}
-    
-    return this
-  }`;
-}

package/dist/generators/indices/emptydatabasemigration.generator.d.ts

@@ -1,11 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates a const that contains the SQL to delete all data from the E2E database.
- *
- * This is used in e2e tests to empty the database before each test.
- */
-export declare function generateEmptyDatabaseCommand({ models }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/emptydatabasemigration.generator.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEmptyDatabaseCommand = void 0;
-/**
- * Generates a const that contains the SQL to delete all data from the E2E database.
- *
- * This is used in e2e tests to empty the database before each test.
- */
-function generateEmptyDatabaseCommand({ models }) {
-    const modelTables = models.map((model) => `${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`);
-    // We determine the schema used for all system tables by looking at the User model's schema.
-    const userModel = models.find((model) => model.name === 'User');
-    if (!userModel) {
-        throw new Error('Model definition for "User" could not be found - hence schema for system table cannot be derived!');
-    }
-    const configSchema = userModel.sourceSchemaName !== undefined ? `"${userModel.sourceSchemaName}".` : '';
-    const systemTables = ['Action', 'Mutation'].map((table) => `${configSchema}"${table}"`);
-    const configTableName = `${configSchema}"Config"`;
-    return /** ts */ `
-/** 
- * SQL instruction to delete all data from the E2E database. Should only be used internally by the DbService!
- */
-export const wipeDatabaseCommand = \`
-DO $$
-BEGIN
-  IF EXISTS (SELECT 1 FROM ${configTableName} WHERE "isTest" = TRUE) THEN
-    TRUNCATE TABLE 
-      ${[...systemTables, ...modelTables].join(',\n      ')};
-  END IF;
-END
-$$;\`
-`;
-}
-exports.generateEmptyDatabaseCommand = generateEmptyDatabaseCommand;

package/dist/generators/indices/testdata-service.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates the TestDataService class.
- */
-export declare function generateTestDataService({ models, meta: schemaMeta, }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/testdata-service.generator.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTestDataService = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const types_1 = require("../../lib/schema/types");
-/**
- * Generates the TestDataService class.
- */
-function generateTestDataService({ models, meta: schemaMeta, }) {
-    const imports = imports_1.ImportsGenerator.from(schemaMeta.data.testDataServiceFilePath);
-    imports.addImports({
-        [schemaMeta.actions.execution.classLocation.import]: [(0, types_1.toClassName)('ActionExecutionFactory')],
-        [schemaMeta.data.dataService.location.import]: [schemaMeta.data.dataService.class],
-        [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
-        [schemaMeta.data.mockModule.location.import]: [(0, types_1.toAnnotatedTypeName)(schemaMeta.data.dataMockDataType)],
-        [schemaMeta.importExport.converterFunctions.location.import]: [
-            schemaMeta.importExport.converterFunctions.mockDataToBulkMutations,
-        ],
-    });
-    const reInitCalls = [];
-    const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    for (const { model, meta } of modelMetas) {
-        if (model.defaultField) {
-            imports.addImport({ items: [meta.data.stubGenerationFnName], from: meta.data.stubLocation.import });
-            const stubDefault = `${meta.data.stubGenerationFnName}({ ${model.defaultField.name}: true })`;
-            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [${stubDefault}], execution: actionExecution })`);
-        }
-        else {
-            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [], execution: actionExecution })`);
-        }
-    }
-    return /* ts */ `
-import { Injectable, Logger } from '@nestjs/common'
-
-${imports.generate()}
-
-@Injectable()
-export class TestDataService {
-  private logger = new Logger(TestDataService.name)
-
-  constructor(
-    private readonly databaseService: DatabaseService,
-    private readonly dataService: ${schemaMeta.data.dataService.class},
-    private readonly actionExecutionFactory: ActionExecutionFactory,
-  ) {}
-
-  public async resetTestData(data: MockData) {
-    this.logger.log('💥 Emptying test data')
-    await this.databaseService.WIPE_ENTIRE_DATABASE()
-
-    // We need to init the user repository first so the root user is created
-    this.logger.log('✍ Setting test data')
-    await this.dataService.users.init()
-
-    this.logger.log('✍ Setting test data')
-
-    const mockData = ${schemaMeta.importExport.converterFunctions.mockDataToBulkMutations}(data)
-
-    const actionExecution = await this.actionExecutionFactory.create({
-      action: {
-        scope: 'seed',
-        type: 'data',
-        name: 'E2E', 
-        order: 0, 
-        payload: []
-      },
-      databaseService: this.databaseService,
-      user: this.dataService.users.rootUser,
-    })
-
-    try {
-      ${reInitCalls.join('\n')}
-      
-      await actionExecution.success()
-      this.logger.log('✅ Reset test data')
-    } catch (e) {
-      await actionExecution.error(e)
-      throw e
-    }
-  }
-}`;
-}
-exports.generateTestDataService = generateTestDataService;

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

@@ -1,324 +0,0 @@
-"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 = __importStar(require("../../lib/schema/types"));
-const typescript_1 = require("../../lib/typescript");
-const jsdoc_1 = require("../../lib/utils/jsdoc");
-const string_1 = require("../../lib/utils/string");
-const zod_1 = require("../../lib/zod");
-/**
- * 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 });
-    const m = {
-        iExecution: schemaMeta.actions.execution.interface,
-        typeName: meta.types.typeName,
-        brandedId: model.brandedIdType,
-    };
-    const imports = imports_1.ImportsGenerator.from(meta.update.serviceClassLocation.path);
-    imports.addImports({
-        [meta.data.repository.location.import]: meta.data.repository.className,
-        [meta.types.importPath]: [
-            Types.toAnnotatedTypeName(m.brandedId),
-            Types.toAnnotatedTypeName(m.typeName),
-            meta.types.toBrandedIdTypeFnName,
-        ],
-        [meta.view.serviceLocation.import]: [meta.view.serviceClassName],
-        [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
-        [schemaMeta.actions.dispatcher.definitionLocation.import]: [schemaMeta.actions.dispatcher.definition],
-        [schemaMeta.update.serviceLocation.path]: schemaMeta.update.serviceClassName,
-        [schemaMeta.view.serviceLocation.import]: schemaMeta.view.serviceClassName,
-    });
-    for (const field of (0, fields_1.getRelationFields)(model)) {
-        // NOTE: We add `toBrandedType` functions for foreign models for decoders.
-        if (field.relationToModel.typeName === model.typeName) {
-            continue;
-        }
-        const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
-        imports.addImport({
-            from: refModelMeta.types.importPath,
-            items: [refModelMeta.types.toBrandedIdTypeFnName],
-        });
-        imports.addTypeImport({
-            from: refModelMeta.types.importPath,
-            items: [refModelMeta.types.brandedIdType],
-        });
-    }
-    for (const { enumerator } of (0, fields_1.getEnumFields)(model)) {
-        const enumMeta = (0, meta_1.getEnumMetadata)({ enumerator });
-        imports.addTypeImport({
-            from: enumMeta.types.importPath,
-            items: [enumerator.tsTypeName],
-        });
-    }
-    /**
-     * 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
-     * would be referenced using `this.data` variable).
-     */
-    const modelRepositoryVariableName = meta.view.dataRepositoryVariableName;
-    const constructorParameters = [
-        `private readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
-        `@Inject(forwardRef(() => ${schemaMeta.update.serviceClassName})) private readonly updateService: ${schemaMeta.update.serviceClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly viewService: ${schemaMeta.view.serviceClassName}`,
-    ];
-    const { view, update } = meta;
-    const deleteFn = generateDeleteFn({ model, meta, m });
-    const deleteManyFn = generateDeleteManyFn({ imports, model, meta, m });
-    const cloneFn = generateCloneFn({ model, meta, m });
-    /* prettier-ignore */
-    return /* ts */ `
-    import { Inject, Injectable, forwardRef } from '@nestjs/common'
-    import { z } from 'zod'
-
-    ${imports.generate()}
-
-    export type Scope = "${meta.actions.actionScopeConstType}"
-
-    export type Actions = {
-      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
-      create: {
-        payload: CreatePayload
-        result: ${m.typeName}
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
-      update: {
-        payload: UpdatePayload
-        result: ${m.typeName}
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
-      upsert: {
-        payload: UpsertPayload
-        result: ${m.typeName}
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
-      delete: {
-        payload: ${m.brandedId}
-        result: ${m.brandedId}
-      }
-    }
-
-    /**
-     * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
-     */
-    export const ${meta.update.createInputDecoder} = z.object({
-      ${model.fields
-        .filter((f) => !f.attributes.isReadonly)
-        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f })}`)
-        .join(',')}
-    })
-
-    type CreatePayload = z.infer<typeof ${meta.update.createInputDecoder}>
-
-    /**
-     * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
-     */
-    export const ${meta.update.updateInputDecoder} = 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 UpdatePayload = z.infer<typeof ${meta.update.updateInputDecoder}>
-
-    /**
-     * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
-     */
-    export const ${meta.update.upsertInputDecoder} = z.union([${meta.update.updateInputDecoder}, ${meta.update.createInputDecoder}])
-    
-    type UpsertPayload = z.infer<typeof ${meta.update.upsertInputDecoder}>
-
-    export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
-
-    @Injectable()
-    export class ${update.serviceClassName} implements ${update.serviceInterfaceName} {
-
-      /**
-       * Instance of the ${meta.userFriendlyName} view service for convenience.
-       */
-      private view: ${view.serviceClassName}
-
-      constructor(${constructorParameters.join(',\n')}) {
-        this.view = this.viewService.${view.serviceVariableName}
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
-      public async create({ data, execution }: { data: CreatePayload; execution: ${m.iExecution} }): Promise<${m.typeName}> {
-        return this.data.create({ item: data, execution })
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
-      public async update({ data, execution }: { data: UpdatePayload; execution: ${m.iExecution} }): Promise<${m.typeName}> {
-        return this.data.update({ item: data, execution })
-      }
-
-      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
-      public async upsert({ data, execution }: { data: UpsertPayload; execution: ${m.iExecution} }): Promise<${m.typeName}> {
-        return this.data.upsert({ item: data, execution })
-      }
-
-      ${deleteFn}
-
-      ${deleteManyFn}
-
-      ${cloneFn}
-    }
- `;
-}
-exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
-/**
- * Returns a function implementation that deletes a single entity and all its related entities.
- */
-function generateDeleteFn({ model, meta, m }) {
-    const backReferenceDelete = [];
-    const backReferenceNames = [];
-    for (const { referencingField, referencingModel } of model.references) {
-        // NOTE: We only delete back references that are required references so that delete method
-        //       doesn't fail on non-null constraints.
-        if (!referencingField.isRequired) {
-            continue;
-        }
-        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.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(data)
-      await this.updateService.${refModelMeta.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 generateDeleteManyFn({ imports, model, meta, m, }) {
-    const idArrays = [];
-    const idAssignments = [];
-    const deleteCalls = [];
-    for (const { referencingField, referencingModel } of model.references) {
-        // NOTE: We only delete back references that are required references.
-        if (!referencingField.isRequired) {
-            continue;
-        }
-        imports.addTypeImport({ items: [referencingModel.brandedIdType], from: meta.types.importPath });
-        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.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)
-        ${idArray}.push(..._ids)
-      }
-      `);
-        deleteCalls.push(`await this.updateService.${refModelMeta.update.serviceVariableName}.deleteMany({ data: ${idArray}, execution })`);
-    }
-    let relatedEntities = '';
-    if (idArrays.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 shallow clones a given entity. Unique fields are required
- * to generate a unique clone as skipping them would result in a non-unique clone.
- */
-function generateCloneFn({ model, meta, m }) {
-    const inputFields = 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`;
-    });
-    return `
-  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} deep clone and returns it.`])}
-  public async clone(
-    { data, execution }: { data: { ${inputFields.join(', ')} }; execution: ${m.iExecution} }
-  ): Promise<${m.typeName}> {
-    const source = await this.view.get(data.id)
-    if (!source) {
-      throw new Error(\`${meta.userFriendlyName} with id \${data.id} not found\`)
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { id, ...duplicate } = { ...source, ...data } satisfies Actions['create']['payload']
-
-    return await this.create({ data: duplicate, execution })
-  }`;
-}