@postxl/generator 0.34.0 → 0.35.0

package/dist/generators/indices/seed-template-decoder.generator.js

@@ -5,20 +5,21 @@ 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 string_1 = require("../../lib/utils/string");
 // TODO: Remove hardcoded path that seems to be reused in multiple places!
 const PXL_COMMON = (0, types_1.toPath)('@pxl/common');
 /**
  * Creates a decoder for the Seed Excel template.
  */
 function generateSeedTemplateDecoder({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seed.templateDecoderFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.seedData.templateDecoderFilePath);
     const decoders = [];
     const tableDecoders = [];
     const renameTransforms = [];
     for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
         decoders.push(generateTableDecoder({ model, meta: modelMeta, imports }));
-        tableDecoders.push(`${modelMeta.seed.excel.tableName}: z.array(${modelMeta.seed.decoder.schemaName})`);
+        tableDecoders.push(`${modelMeta.seed.excel.tableName}: ${modelMeta.seed.decoder.decoderName}`);
         renameTransforms.push(`${modelMeta.seed.decoder.dataName}: item['${modelMeta.seed.excel.tableName}']`);
     }
     return `
@@ -26,9 +27,14 @@ function generateSeedTemplateDecoder({ models, meta }) {
   
   ${imports.generate()}
   
+  /**
+   * Helper schema to identify blank Excel cells
+   */
+  const nullOrBlankSchema = z.union([z.null(), z.literal('')])
+
   ${decoders.join('\n')}
 
-  export const ${meta.seed.templateDecoderName} = z
+  export const ${meta.seedData.templateDecoderName} = z
     .object({${tableDecoders.join(',\n')}})
     .transform((item) => ({${renameTransforms.join(',\n')}}))
   `;
@@ -36,10 +42,12 @@ function generateSeedTemplateDecoder({ models, meta }) {
 exports.generateSeedTemplateDecoder = generateSeedTemplateDecoder;
 function generateTableDecoder({ model, meta, imports, }) {
     const fieldDecoders = [];
+    const blankFieldDecoders = [];
     const renameTransforms = [];
     for (const field of model.fields) {
         const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
         renameTransforms.push(`${field.name}: item['${fieldMeta.excelColumnName}']`);
+        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: nullOrBlankSchema`);
         switch (field.kind) {
             case 'id': {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
@@ -81,6 +89,7 @@ function generateTableDecoder({ model, meta, imports, }) {
             }
         }
     }
+    const blankSchemaName = `blank${(0, string_1.capitalize)(meta.seed.decoder.schemaName)}`;
     return `  
 /**
  * The schema for the ${model.name} table
@@ -88,13 +97,20 @@ function generateTableDecoder({ model, meta, imports, }) {
 const ${meta.seed.decoder.schemaName} = z
   .object({${fieldDecoders.join(',\n')}})
   .transform((item) => ({${renameTransforms.join(',\n')}}))
-  
-/**
+
+/** The schema to identify blank rows in the ${model.name} table */
+const ${blankSchemaName} = z
+  .object({${blankFieldDecoders.join(',\n')}})
+  .transform(() => undefined)
+
+  /**
  * The type of the ${model.name} table
  */
 export type ${meta.seed.decoder.decoderTypeName} = z.infer<typeof ${meta.seed.decoder.schemaName}>
 
-export const ${meta.seed.decoder.decoderName} = z.array(${meta.seed.decoder.schemaName})
+export const ${meta.seed.decoder.decoderName} = z
+  .array(${meta.seed.decoder.schemaName}.or(${blankSchemaName}))
+  .transform((items) => items.filter(Boolean) as ${meta.seed.decoder.decoderTypeName}[])
 `;
 }
 function toExcelDecoder({ tsTypeName, dbTypeName: typeName, nullable, imports, }) {

package/dist/generators/indices/{seed.generator.d.ts → seeddata-type.generator.d.ts}

@@ -1,9 +1,9 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates index file for all seed files.
+ * Generates a type for all SeedData.
  */
-export declare function generateSeedIndex({ models, meta }: {
+export declare function generateSeedDataType({ models, meta }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;

package/dist/generators/indices/seeddata-type.generator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedDataType = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+/**
+ * Generates a type for all SeedData.
+ */
+function generateSeedDataType({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.types.importPath);
+    imports.addImport({ from: meta.data.importPath, items: [(0, types_1.toClassName)('MockData')] });
+    const modelTypes = [];
+    const mockConverters = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            items: [modelMeta.types.dto.create, modelMeta.types.dto.update, modelMeta.types.dto.upsert],
+            from: modelMeta.types.importPath,
+        });
+        modelTypes.push(`${modelMeta.seed.constantName}?: {
+      create?: ${modelMeta.types.dto.create}[]
+      update?: ${modelMeta.types.dto.update}[]
+      upsert?: ${modelMeta.types.dto.upsert}[]
+      delete?: string[]
+    }`);
+        mockConverters.push(`${modelMeta.seed.constantName}: { create: data.${modelMeta.seed.constantName} }`);
+    }
+    return `
+${imports.generate()}
+
+export type SeedData = {
+  ${modelTypes.join('\n')}
+}
+
+export function mockDataToCreate(data: MockData): SeedData {
+  return {
+    ${mockConverters.join(',\n')}
+  }
+}`;
+}
+exports.generateSeedDataType = generateSeedDataType;

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

@@ -3,7 +3,7 @@ import { Enum, Model } from '../../lib/schema/schema';
 /**
  * Generates an index file that exports all types.
  */
-export declare function generateTypesIndex({ models, enums, meta, }: {
+export declare function generateTypesIndex({ models, enums, meta: schemaMeta, }: {
     models: Model[];
     enums: Enum[];
     meta: SchemaMetaData;

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

@@ -6,16 +6,18 @@ const meta_1 = require("../../lib/meta");
 /**
  * Generates an index file that exports all types.
  */
-function generateTypesIndex({ models, enums, meta, }) {
-    const exports = exports_1.ExportsGenerator.from(meta.types.indexFilePath);
+function generateTypesIndex({ models, enums, meta: schemaMeta, }) {
+    const exports = exports_1.ExportsGenerator.from(schemaMeta.types.indexFilePath);
     for (const model of models) {
-        const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.types.filePath);
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(modelMeta.types.filePath);
     }
     for (const enumerator of enums) {
-        const meta = (0, meta_1.getEnumMetadata)({ enumerator });
-        exports.exportEverythingFromPath(meta.types.filePath);
+        const enumMeta = (0, meta_1.getEnumMetadata)({ enumerator });
+        exports.exportEverythingFromPath(enumMeta.types.filePath);
     }
+    // dto.types contains generic types that are used by all models
+    exports.exportEverythingFromPath(schemaMeta.types.dto.path);
     return exports.generate();
 }
 exports.generateTypesIndex = generateTypesIndex;

package/dist/generators/models/businesslogic-update.generator.d.ts

@@ -0,0 +1,10 @@
+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.
+ */
+export declare function generateModelBusinessLogicUpdate({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

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

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelBusinessLogicUpdate = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const jsdoc_1 = require("../../lib/utils/jsdoc");
+const repository_generator_1 = require("./repository.generator");
+/**
+ * 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 imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
+    imports.addImports({
+        [meta.data.importPath]: meta.data.repositoryClassName,
+        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecutionInterface,
+        [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
+        [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
+        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
+        [meta.data.importPath]: [meta.data.repositoryClassName],
+    });
+    /**
+     * 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.businessLogic.dataRepositoryVariableName;
+    /**
+     * The name of the variable that holds the central business logic service instance.
+     * Instead of injecting a repository instance for each model, we inject this single instance
+     * which then provides access to all models' business logic.
+     */
+    const updateServiceClassName = 'updateService';
+    const viewServiceClassName = 'viewService';
+    const actionBlocks = generateActionsBuildingBlocks({ model, meta });
+    imports.addImport({ from: meta.types.importPath, items: actionBlocks.importTypes });
+    const constructorParameters = [
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly ${updateServiceClassName}: ${schemaMeta.businessLogic.update.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
+    ];
+    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
+    return `
+import { Inject, Injectable, forwardRef } from '@nestjs/common'
+import { ExhaustiveSwitchCheck } from '@pxl/common'
+
+${imports.generate()}
+
+${actionBlocks.actionTypeDefinition}
+
+${actionBlocks.resultMap}
+
+${actionBlocks.typeDefinitionWithCreateFunction}
+
+@Injectable()
+export class ${meta.businessLogic.update.serviceClassName} {
+  constructor(${constructorParameters.join(',\n')}) {}
+
+  ${actionBlocks.dispatcher}
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
+  public async create(
+    { item, execution }: ${methodTypeSignatures.create.parameters[0]}
+  ): ${methodTypeSignatures.create.returnType} {
+    return this.${modelRepositoryVariableName}.create({ item, execution })
+  }
+
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
+  public async createMany(
+    { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
+  ): ${methodTypeSignatures.createMany.returnType} {
+    return this.${modelRepositoryVariableName}.createMany({ items, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
+  public async update(
+    { item, execution }: ${methodTypeSignatures.update.parameters[0]}
+  ): ${methodTypeSignatures.update.returnType} {
+    return this.${modelRepositoryVariableName}.update({ item, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
+  public async updateMany(
+    { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
+  ): ${methodTypeSignatures.updateMany.returnType} {
+    return this.${modelRepositoryVariableName}.updateMany({ items, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
+  public async upsert(
+    { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
+  ): ${methodTypeSignatures.upsert.returnType} {
+    return this.${modelRepositoryVariableName}.upsert({ item, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
+  public async upsertMany(
+    { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
+  ): ${methodTypeSignatures.upsertMany.returnType} {
+    return this.${modelRepositoryVariableName}.upsertMany({ items, execution })
+  }
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
+  public async delete(
+    { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
+  ): ${methodTypeSignatures.delete.returnType} {
+    return this.${modelRepositoryVariableName}.delete({ id, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
+  public async deleteMany(
+    { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
+  ): ${methodTypeSignatures.deleteMany.returnType} {
+    return this.${modelRepositoryVariableName}.deleteMany({ ids, execution })
+  }
+
+}`;
+}
+exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
+function generateActionsBuildingBlocks({ model, meta }) {
+    const actionTypeDefinition = [];
+    const resultMap = [];
+    const typeDefinitionWithCreateFunction = [];
+    const importTypes = [];
+    const dispatcher = [];
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    const actionDefinitions = prepareActionDefinitions({ model, meta });
+    for (const [type, config] of Object.entries(actionDefinitions)) {
+        const def = generateAction({ model, meta, type: type, config });
+        actionTypeDefinition.push(def.actionName),
+            resultMap.push(def.resultMap),
+            typeDefinitionWithCreateFunction.push(def.typeDefinition, def.createFunction, ''),
+            importTypes.push(...def.importTypes),
+            dispatcher.push(def.dispatchCaseExpression);
+    }
+    return {
+        importTypes,
+        actionTypeDefinition: `export type Action_${meta.businessLogic.update.actionNameModelPart} = ${actionTypeDefinition.join(' | ')}`,
+        resultMap: `export type ActionResult_${meta.businessLogic.update.actionNameModelPart} = { 
+      ${resultMap.join('\n')} 
+    }`,
+        typeDefinitionWithCreateFunction: `${typeDefinitionWithCreateFunction.join('\n')}`,
+        dispatcher: `
+      public async dispatch<A extends Action_${meta.businessLogic.update.actionNameModelPart}>({ action, execution }: {
+        action: A; 
+        execution: ${schemaMeta.actions.actionExecutionInterface} 
+      }) {
+        switch (action.type) {
+          ${dispatcher.join('\n')}
+          default: {
+            throw new ExhaustiveSwitchCheck(action)
+          }
+        }
+      }`,
+    };
+}
+function prepareActionDefinitions({ model, meta, }) {
+    return {
+        create: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Create`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreate,
+            payload: meta.types.dto.create,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.create],
+            dispatcherParameterName: 'item',
+        },
+        createMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_CreateMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreateMany,
+            payload: `${meta.types.dto.create}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.create],
+            dispatcherParameterName: 'items',
+        },
+        update: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Update`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdate,
+            payload: meta.types.dto.update,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.update],
+            dispatcherParameterName: 'item',
+        },
+        updateMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpdateMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdateMany,
+            payload: `${meta.types.dto.update}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.update],
+            dispatcherParameterName: 'items',
+        },
+        upsert: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Upsert`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsert,
+            payload: meta.types.dto.upsert,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.upsert],
+            dispatcherParameterName: 'item',
+        },
+        upsertMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpsertMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsertMany,
+            payload: `${meta.types.dto.upsert}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.upsert],
+            dispatcherParameterName: 'items',
+        },
+        delete: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Delete`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameDelete,
+            payload: model.brandedIdType,
+            resultType: model.brandedIdType,
+            imports: [model.brandedIdType],
+            dispatcherParameterName: 'id',
+        },
+        deleteMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_DeleteMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameDeleteMany,
+            payload: `${model.brandedIdType}[]`,
+            resultType: `${model.brandedIdType}[]`,
+            imports: [model.brandedIdType],
+            dispatcherParameterName: 'ids',
+        },
+    };
+}
+function generateAction({ meta, type, config: { imports, actionName, payload, createFunctionName, resultType, dispatcherParameterName }, }) {
+    return {
+        actionName,
+        actionType: type,
+        importTypes: imports,
+        resultMap: `${type}: ${resultType}`,
+        typeDefinition: `
+      export type ${actionName} = { scope: '${meta.actions.actionScopeConstType}'; type: '${type}'; payload: ${payload} }`,
+        createFunction: `
+      export function ${createFunctionName}(payload: ${payload}): ${actionName} {
+        return { scope: '${meta.actions.actionScopeConstType}', type: '${type}', payload }
+      }`,
+        dispatchCaseExpression: `
+      case '${type}':
+        return this.${type}({ ${dispatcherParameterName}: action.payload, execution })`,
+    };
+}

package/dist/generators/models/businesslogic-view.generator.d.ts

@@ -0,0 +1,10 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates view business logic for a given model.
+ * The view  logic exposes all information and links of a model. See template's readme for more info.
+ */
+export declare function generateModelBusinessLogicView({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

package/dist/generators/models/{businesslogic.generator.js → businesslogic-view.generator.js}

@@ -1,44 +1,23 @@
 "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.generateModelBusinessLogic = void 0;
+exports.generateModelBusinessLogicView = 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 ast_1 = require("../../lib/utils/ast");
-const repository_generator_1 = require("./repository.generator");
 /**
- * Generates business logic for a given model.
+ * Generates view business logic for a given model.
+ * The view  logic exposes all information and links of a model. See template's readme for more info.
  */
-// TODO: https://github.com/PostXL/PostXL/issues/347
-function generateModelBusinessLogic({ model, meta }) {
+function generateModelBusinessLogicView({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
-    imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
-    imports.addImport({ from: meta.types.importPath, items: [model.brandedIdType, meta.types.typeName] });
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
+    imports.addImports({
+        [meta.data.importPath]: meta.data.repositoryClassName,
+        [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
+        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
+        [meta.data.importPath]: [meta.data.repositoryClassName],
+    });
     /**
      * 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
@@ -50,16 +29,11 @@ function generateModelBusinessLogic({ model, meta }) {
      * Instead of injecting a repository instance for each model, we inject this single instance
      * which then provides access to all models' business logic.
      */
-    const businessLogicServiceClassName = Types.toVariableName('businessLogic');
+    const viewServiceClassName = 'viewService';
     const constructorParameters = [
         `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.serviceClassName})) private readonly ${businessLogicServiceClassName}: ${schemaMeta.businessLogic.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
-    imports.addImport({
-        from: schemaMeta.businessLogic.serviceFilePath,
-        items: [schemaMeta.businessLogic.serviceClassName],
-    });
-    imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
     /**
      * Variable names and their definitions indexed by the name of the relation they represent.
      */
@@ -67,9 +41,9 @@ function generateModelBusinessLogic({ model, meta }) {
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        const variableGetter = `this.${businessLogicServiceClassName}.${refMeta.businessLogic.serviceVariableName}.get(itemRaw.${relation.name})`;
+        const variableGetter = `this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
         const variablePresenceCheck = `
-    if (!${relation.relatedModelBacklinkFieldName}) {
+      if (!${relation.relatedModelBacklinkFieldName}) {
         throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
       }
       `;
@@ -114,11 +88,10 @@ function generateModelBusinessLogic({ model, meta }) {
     })
         .join(',\n')}
       }
+
       return item
     }
   `;
-    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
-    // prettier-ignore
     return `
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { FilterOperator } from '@pxl/common'
@@ -126,7 +99,7 @@ import { FilterOperator } from '@pxl/common'
 ${imports.generate()}
 
 @Injectable()
-export class ${meta.businessLogic.serviceClassName} {
+export class ${meta.businessLogic.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
 
   /**
@@ -140,14 +113,14 @@ export class ${meta.businessLogic.serviceClassName} {
   ${hasLinkedItems ? linkedItemsGetterFn : ''}
 
   /**
-   * Returns a map of all ${meta.userFriendlyName}s.
+   * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
   public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
     return this.${modelRepositoryVariableName}.getAll()
   }
 
-    /**
-   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyName}s.
+  /**
+   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyNamePlural}.
    */
   public getList({
     filter,
@@ -171,29 +144,6 @@ export class ${meta.businessLogic.serviceClassName} {
     return { rows: paginated, count: items.length }
   }
 
-  /**
-   * Creates a new ${meta.userFriendlyName}.
-   */
-  public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {
-    return this.${modelRepositoryVariableName}.create(item)
-  }
-
-  /**
-   * Updates the given ${meta.userFriendlyName}.
-   */
-  public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
-    return this.${modelRepositoryVariableName}.update(item)
-  }
-
-  /**
-   * Deletes the ${meta.userFriendlyName} with the given id.
-   * 
-   * Note: This does NOT delete any linked items. 
-   * If the item is a dependency of another item, the deletion will fail!
-   */
-  public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
-    return this.${modelRepositoryVariableName}.delete(id)
-  }
 }
 
 // Utility Functions
@@ -203,7 +153,7 @@ ${_createModelCompareFn({ model })}
 ${_createModelFilterFn({ model })}
 `;
 }
-exports.generateModelBusinessLogic = generateModelBusinessLogic;
+exports.generateModelBusinessLogicView = generateModelBusinessLogicView;
 /**
  * Generates a utility filter function for the given model that can be used to filter out instances
  * of a model using a given operator on a given field.
@@ -221,8 +171,9 @@ function _createModelFilterFn({ model }) {
           case 'contains': {
             return (item[field] || '').toLowerCase().includes(value.toLowerCase())
           }
-          default:
+          default: {
             return false
+          }
         }
       `,
         };

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

@@ -198,7 +198,7 @@ export const ${components.modals.editComponentName} = ({
       <Typed.Formik
         initialValues={{
 					${fields
-        .filter((f) => !f.attributes.isReadonly)
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         switch (field.kind) {
             case 'enum':
@@ -500,7 +500,7 @@ function getEditFormInputFields({ model }) {
 }
 function getEditFormikMutationData({ model: { fields } }) {
     return fields
-        .filter((f) => !f.attributes.isReadonly)
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {

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

@@ -31,6 +31,10 @@ type FnSignature = {
      * 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.
@@ -40,7 +44,12 @@ export declare function getRepositoryMethodsTypeSignatures({ model, meta }: {
     meta: ModelMetaData;
 }): {
     create: FnSignature;
+    createMany: FnSignature;
     update: FnSignature;
+    updateMany: FnSignature;
+    upsert: FnSignature;
+    upsertMany: FnSignature;
     delete: FnSignature;
+    deleteMany: FnSignature;
 };
 export {};