@postxl/generator 0.14.0 → 0.15.0

package/dist/generator.js

@@ -61,6 +61,10 @@ const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
 const client_path_1 = require("./prisma/client-path");
 const parse_1 = require("./prisma/parse");
+const businesslogicservice_generator_1 = require("./generators/indices/businesslogicservice.generator");
+const businesslogicindex_generator_1 = require("./generators/indices/businesslogicindex.generator");
+const businesslogicmodule_generator_1 = require("./generators/indices/businesslogicmodule.generator");
+const businesslogic_generator_1 = require("./generators/models/businesslogic.generator");
 const seed_template_decoder_generator_1 = require("./generators/indices/seed-template-decoder.generator");
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const CONFIG_SCHEMA = zod_1.z
@@ -68,6 +72,7 @@ const CONFIG_SCHEMA = zod_1.z
     project: zod_1.z.string(),
     pathToTypes: zod_1.z.string().optional(),
     pathToDataLib: zod_1.z.string().optional(),
+    pathToBusinessLogic: zod_1.z.string().optional(),
     pathToSeedLib: zod_1.z.string().optional(),
     trpcRoutesFolder: zod_1.z.string().optional(),
     reactFolderOutput: zod_1.z.string().optional(),
@@ -86,6 +91,7 @@ const CONFIG_SCHEMA = zod_1.z
         project: s.project,
         paths: {
             dataLibPath: (0, types_1.toPath)(s.pathToDataLib || 'repos'),
+            businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || 'repos'),
             reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
             modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || 'types'),
             seedPath: (0, types_1.toPath)(s.pathToSeedLib || 'seed'),
@@ -97,6 +103,7 @@ const CONFIG_SCHEMA = zod_1.z
         disableGenerators: {
             types: s.pathToTypes === undefined,
             data: s.pathToDataLib === undefined,
+            businessLogic: s.pathToBusinessLogic === undefined,
             seed: s.pathToSeedLib === undefined,
             trpc: s.trpcRoutesFolder === undefined,
             react: s.reactFolderOutput === undefined,
@@ -156,6 +163,10 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
                 generated.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
                 generated.write(`/${meta.data.mockRepoFilePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
             }
+            // Business Logic
+            if (!config.disableGenerators.businessLogic) {
+                generated.write(`/${meta.businessLogic.serviceFilePath}.ts`, (0, businesslogic_generator_1.generateModelBusinessLogic)({ model, meta }));
+            }
             // Routes
             if (!config.disableGenerators.trpc) {
                 generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
@@ -188,6 +199,11 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
             generated.write(`/${meta.migrationsPath}/emptyDatabase.template.sql`, (0, emptydatabasemigration_generator_1.generateEmptyDatabaseStoredProcedure)({ models, meta }));
         }
+        if (!config.disableGenerators.businessLogic) {
+            generated.write(`/${meta.businessLogic.indexFilePath}.ts`, (0, businesslogicindex_generator_1.generateBusinessLogicIndex)({ models, meta }));
+            generated.write(`/${meta.businessLogic.moduleFilePath}.ts`, (0, businesslogicmodule_generator_1.generateBusinessLogicModule)({ models, meta }));
+            generated.write(`/${meta.businessLogic.serviceFilePath}.ts`, (0, businesslogicservice_generator_1.generateBusinessLogicService)({ models, meta }));
+        }
         if (!config.disableGenerators.seed) {
             generated.write(`/${meta.seed.indexFilePath}.ts`, (0, seed_generator_1.generateSeedIndex)({ models, meta }));
             generated.write(`/${meta.seed.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicIndex = void 0;
+const exports_1 = require("../../lib/exports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates index file for all businessLogic files.
+ */
+function generateBusinessLogicIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.businessLogic.indexFilePath);
+    exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
+    exports.exportEverythingFromPath(meta.businessLogic.moduleFilePath);
+    for (const model of models) {
+        const meta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
+    }
+    return exports.generate();
+}
+exports.generateBusinessLogicIndex = generateBusinessLogicIndex;

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

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a business Logic module class.
+ */
+export declare function generateBusinessLogicModule({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicModule = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates a business Logic module class.
+ */
+function generateBusinessLogicModule({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.moduleFilePath)
+        .addImport({
+        items: [meta.data.moduleName],
+        from: meta.data.importPath,
+    })
+        .addImport({
+        items: [meta.businessLogic.serviceClassName],
+        from: meta.businessLogic.serviceFilePath,
+    });
+    const providers = [meta.businessLogic.serviceClassName];
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.businessLogic.serviceClassName],
+            from: meta.businessLogic.serviceFilePath,
+        });
+        providers.push(meta.businessLogic.serviceClassName);
+    }
+    return `
+import { Module } from '@nestjs/common'
+  
+${imports.generate()}
+
+const providers = [${providers.join(', ')}]
+@Module({
+  imports: [${meta.data.moduleName}],
+  providers,
+  exports: providers,
+})
+export class BusinessLogicModule {}
+
+`;
+}
+exports.generateBusinessLogicModule = generateBusinessLogicModule;

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the business logic service class.
+ */
+function generateBusinessLogicService({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.businessLogic.serviceClassName],
+            from: meta.businessLogic.serviceFilePath,
+        });
+    }
+    const constructor = mm
+        .map(({ meta }) => `public ${meta.businessLogic.serviceVariableName} :${meta.businessLogic.serviceClassName}`)
+        .join(',\n');
+    return `
+import { Injectable } from '@nestjs/common'
+
+${imports.generate()}
+
+@Injectable()
+export class ${meta.businessLogic.serviceClassName} {
+  constructor(${constructor}) {}
+}
+`;
+}
+exports.generateBusinessLogicService = generateBusinessLogicService;

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

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataMockModule = void 0;
+const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const Types = __importStar(require("../../lib/schema/types"));
-const imports_1 = require("../../lib/imports");
 /**
  * Generates a mocking class
  */

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

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataModule = void 0;
+const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const Types = __importStar(require("../../lib/schema/types"));
-const imports_1 = require("../../lib/imports");
 /**
  * Generates a data module class.
  */
@@ -47,6 +47,7 @@ function generateDataModule({ models, meta }) {
             from: meta.data.repoFilePath,
         });
     }
+    const moduleName = meta.data.moduleName;
     return `
 import { DynamicModule, Provider, Type } from '@nestjs/common'
 import { DbModule, DbService } from '@${meta.config.project}/db'
@@ -68,43 +69,43 @@ const createRepositoryProvider = <T extends AsyncInit>(t: Type<T>, loadData: boo
   },
 })
 
-export class DataModule {
+export class ${moduleName} {
   private static cachedModule: DynamicModule | undefined = undefined
 
   static isInstantiated(): boolean {
-    return !!DataModule.cachedModule
+    return !!${moduleName}.cachedModule
   }
 
-  static getInstance(): DataModule {
-    if (!DataModule.cachedModule) throw new Error('DataModule must be called via .provide first!')
-    return DataModule.cachedModule
+  static getInstance(): ${moduleName} {
+    if (!${moduleName}.cachedModule) throw new Error('${moduleName} must be called via .provide first!')
+    return ${moduleName}.cachedModule
   }
 
   static provide({ loadData }: { loadData: boolean }): DynamicModule {
-    if (DataModule.cachedModule) {
-      console.warn('DataModule is already instantiated, skipping...')
-      return DataModule.cachedModule
+    if (${moduleName}.cachedModule) {
+      console.warn('${moduleName} is already instantiated, skipping...')
+      return ${moduleName}.cachedModule
     }
 
-    const repositoryProviders: Provider<Repository<any, any>>[] = [
-      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',\n')}
-    ].map((r) => createRepositoryProvider(r as any, loadData))
+    const repositoryProviders = [
+      ${mm.map(({ meta }) => `createRepositoryProvider(${meta.data.repositoryClassName}, loadData)`).join(',\n')}
+    ]
 
-    DataModule.cachedModule = {
-      module: DataModule,
+    ${moduleName}.cachedModule = {
+      module: ${moduleName},
       global: true,
       imports: [DbModule.provide()],
       providers: [DataService, ...repositoryProviders],
       exports: [DataService, ...repositoryProviders],
     }
 
-    return DataModule.cachedModule
+    return ${moduleName}.cachedModule
   }
 
   static provideE2E(): DynamicModule {
-    if (DataModule.cachedModule) {
-      console.warn('DataModule is already instantiated, skipping...')
-      return DataModule.cachedModule
+    if (${moduleName}.cachedModule) {
+      console.warn('${moduleName} is already instantiated, skipping...')
+      return ${moduleName}.cachedModule
     }
 
     const providers: Provider<Repository<any, any>>[] = [
@@ -112,15 +113,15 @@ export class DataModule {
       TestDataService,
     ]
 
-    DataModule.cachedModule = {
-      module: DataModule,
+    ${moduleName}.cachedModule = {
+      module: ${moduleName},
       global: true,
       imports: [DbModule.provide()],
       providers: [...providers],
       exports: providers,
     }
 
-    return DataModule.cachedModule
+    return ${moduleName}.cachedModule
   }
 }
 `;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataService = void 0;
-const meta_1 = require("../../lib/meta");
 const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
 /**
  * Generates a generic data service object that may be used on the server to access database.
  */

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

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSeedTemplateDecoder = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
-const types_1 = require("../../lib/types");
+const types_1 = require("../../lib/schema/types");
+const types_2 = require("../../lib/types");
+// 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
  */
@@ -20,7 +23,6 @@ function generateSeedTemplateDecoder({ models, meta }) {
     }
     return `
   import * as z from 'zod'
-  import { excelStringDecoder, excelStringNullableDecoder, excelBooleanDecoder, excelDateNullableDecoder, excelDateDecoder }  from '@pxl/common'
   
   ${imports.generate()}
   
@@ -42,11 +44,12 @@ function generateTableDecoder({ model, meta, imports, }) {
             case 'id': {
                 imports.addImport({
                     items: [meta.types.toBrandedIdTypeFnName],
-                    from: meta.types.filePath,
+                    from: meta.types.importPath,
                 });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     typeName: field.unbrandedTypeName,
                     nullable: false,
+                    imports,
                 })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
                 break;
             }
@@ -54,6 +57,7 @@ function generateTableDecoder({ model, meta, imports, }) {
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     typeName: field.typeName,
                     nullable: !field.isRequired,
+                    imports,
                 })}`);
                 break;
             }
@@ -62,11 +66,12 @@ function generateTableDecoder({ model, meta, imports, }) {
                 const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
                 imports.addImport({
                     items: [refMeta.types.toBrandedIdTypeFnName],
-                    from: refMeta.types.filePath,
+                    from: refMeta.types.importPath,
                 });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     typeName: field.unbrandedTypeName,
                     nullable: !field.isRequired,
+                    imports,
                 })}.transform((id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => ${field.isRequired ? '' : ' id === null ? null : '}${refMeta.types.toBrandedIdTypeFnName}(id))`);
                 break;
             }
@@ -74,13 +79,13 @@ function generateTableDecoder({ model, meta, imports, }) {
                 const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
                 imports.addImport({
                     items: [field.enumerator.typeName],
-                    from: refEnumMeta.types.filePath,
+                    from: refEnumMeta.types.importPath,
                 });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([${field.enumerator.values.map((v) => `'${v}'`).join(', ')}])${field.isRequired ? '' : '.nullable()'}`);
                 break;
             }
             default: {
-                throw new types_1.ExhaustiveSwitchCheck(field);
+                throw new types_2.ExhaustiveSwitchCheck(field);
             }
         }
     }
@@ -100,16 +105,32 @@ export type ${meta.seed.decoder.decoderTypeName} = z.infer<typeof ${meta.seed.de
 export const ${meta.seed.decoder.decoderName} = z.array(${meta.seed.decoder.schemaName})
 `;
 }
-function toExcelDecoder({ typeName, nullable }) {
+function toExcelDecoder({ typeName, nullable, imports, }) {
     switch (typeName) {
-        case 'string':
-            return nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder';
+        case 'string': {
+            const decoder = (0, types_1.toFunction)(nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
         case 'boolean':
+            imports.addImport({
+                items: [(0, types_1.toFunction)('excelBooleanDecoder')],
+                from: PXL_COMMON,
+            });
             return 'excelBooleanDecoder';
         case 'number':
             return `z.number()${nullable ? '.nullable()' : ''}`;
-        case 'Date':
-            return nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder';
+        case 'Date': {
+            const decoder = (0, types_1.toFunction)(nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
         default:
             throw new Error('Unknown type');
     }

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

@@ -0,0 +1,9 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates business logic for a given model.
+ */
+export declare function generateModelBusinessLogic({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

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

@@ -0,0 +1,172 @@
+"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;
+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"));
+/**
+ * Generates business logic for a given model.
+ */
+function generateModelBusinessLogic({ model, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
+    const repos = new Map();
+    imports.addImport({
+        items: [meta.data.repositoryClassName],
+        from: meta.data.importPath,
+    });
+    imports.addImport({
+        items: [model.brandedIdType, meta.types.typeName],
+        from: meta.types.importPath,
+    });
+    const dataRepo = Types.toVariableName('data');
+    repos.set(meta.data.repositoryClassName, { name: dataRepo, repoName: meta.data.repositoryClassName });
+    const linkedItems = new Map();
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        if (relation.relationToModel.typeName === model.typeName) {
+            continue;
+        }
+        const refModel = relation.relationToModel;
+        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+        imports.addImport({
+            items: [refModel.brandedIdType, refMeta.types.typeName],
+            from: refMeta.types.importPath,
+        });
+        imports.addImport({
+            items: [refMeta.data.repositoryClassName],
+            from: refMeta.data.importPath,
+        });
+        repos.set(refMeta.data.repositoryClassName, {
+            name: refMeta.internalPluralName,
+            repoName: refMeta.data.repositoryClassName,
+        });
+        linkedItems.set(relation.name, {
+            fieldName: relation.relatedModelBacklinkFieldName,
+            variableDefinition: `
+    const ${relation.relatedModelBacklinkFieldName} = this.${refMeta.internalPluralName}.get(itemRaw.${relation.name})
+    ${!relation.isRequired
+                ? ''
+                : `
+    if (!${relation.relatedModelBacklinkFieldName}) {
+      throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
+    }`}`,
+        });
+    }
+    const hasLinkedItems = linkedItems.size > 0;
+    if (hasLinkedItems) {
+        imports.addImport({
+            items: [meta.types.linkedTypeName],
+            from: meta.types.importPath,
+        });
+    }
+    for (const f of (0, fields_1.getEnumFields)(model)) {
+        const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
+        imports.addImport({
+            items: [f.enumerator.typeName],
+            from: refEnumMeta.types.importPath,
+        });
+    }
+    return `
+import { Injectable } from '@nestjs/common'
+  ${imports.generate()}
+
+@Injectable()
+export class ${meta.businessLogic.serviceClassName} {
+  constructor(
+    ${[...repos.values()].map(({ name, repoName }) => `private readonly ${name}: ${repoName}`).join(',\n')}
+  ) {}
+
+  /**
+   * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
+   * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
+   */
+  public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
+    return this.${dataRepo}.get(id)
+  }
+  ${!hasLinkedItems
+        ? ''
+        : `
+  /**
+   * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
+   * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
+   */
+  public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
+    const itemRaw = this.${dataRepo}.get(id)
+    if (!itemRaw) return null
+    ${[...linkedItems.values()].map(({ variableDefinition }) => variableDefinition).join('\n')}
+    const item: ${meta.types.linkedTypeName} = {
+      ${model.fields
+            .map((f) => {
+            if (f.kind !== 'relation') {
+                return `${f.name}: itemRaw.${f.name}`;
+            }
+            const linked = linkedItems.get(f.name);
+            if (!linked) {
+                throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
+            }
+            return `${linked.fieldName}`;
+        })
+            .join(',\n')}
+    }
+    return item
+  }`}
+
+  /**
+   * Returns a map of all ${meta.userFriendlyName}s.
+   */
+  public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
+    return this.${dataRepo}.getAll()
+  }
+
+  /**
+   * Creates a new ${meta.userFriendlyName}.
+   */
+  public async create(item: Omit<${model.typeName}, 'id'>): Promise<${model.typeName}> {
+    return this.${dataRepo}.create(item)
+  }
+
+  /**
+   * Updates the given ${meta.userFriendlyName}.
+   */
+  public async update(item: Partial<${model.typeName}> & { 
+		id: ${model.brandedIdType}
+	}): Promise<${model.typeName}> {
+    return this.${dataRepo}.update(item)
+  }
+
+  /**
+   * Deletes the ${meta.userFriendlyName} with the given id.
+   * 
+   * Note: This does NOT delete any linked items. 
+   * If the items is a dependency of another item, the deletion will fail!
+   */
+  public async delete(id: ${model.brandedIdType}): Promise<void> {
+    return this.${dataRepo}.delete(id)
+  }
+}
+`;
+}
+exports.generateModelBusinessLogic = generateModelBusinessLogic;

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

@@ -14,7 +14,9 @@ function generateModelContext({ model, meta }) {
         items: [model.typeName, model.brandedIdType],
         from: meta.types.importPath,
     });
+    const resultMapTypeDefinition = `Map<${model.brandedIdType}, ${model.typeName}>`;
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import React, { useMemo } from 'react'
 
 import { createUseContext } from '@lib/react'
@@ -25,7 +27,7 @@ ${imports.generate()}
 
 type Context = {
 	ready: boolean
-	map: Map<${model.brandedIdType}, ${model.typeName}>
+	map: ${resultMapTypeDefinition}
 	list: ${model.typeName}[]
 }
 
@@ -34,11 +36,11 @@ const ReactContext = React.createContext<Context | null>(null)
 /**
  * Context provider to fetch the ${meta.userFriendlyName} data and use it in componenets.
  */
-export const ${meta.react.context.contextProviderName} = ({ children }: React.PropsWithChildren<{}>) => {
+export const ${meta.react.context.contextProviderName} = ({ children }: React.PropsWithChildren) => {
 	const ${queryName} = trpc.${meta.trpc.getMap.reactQueryMethod}.useQuery()
 
 	const context = useMemo<Context>(() => {
-		const data = ${queryName}.data ?? new Map()
+		const data: ${resultMapTypeDefinition} = ${queryName}.data ?? new ${resultMapTypeDefinition}()
 
 		return {
 			ready: ${queryName}.isLoading === false,

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

@@ -47,7 +47,7 @@ function generateModelLibraryComponents({ model, meta }) {
       const { ready, list } = ${context.hookFnName}()
 
       return (
-        <CardList>
+        <CardList loading={!ready}>
           {list.map(item => <${components.cardComponentName} key={item.id} item={item} />)}
         </CardList>
       )

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

@@ -23,7 +23,7 @@ function generateModelLookupComponents({ model, meta }) {
     const tsOmittedFields = hasNameField ? `'label' | 'options' | 'loading'` : `'options' | 'loading'`;
     const reactLabelField = hasNameField ? `label={(l) => l.name}` : '';
     return `
-import React, { useMemo } from 'react'
+import React from 'react'
 
 import { MenuSelectInput, MenuSelectField } from '@components/atoms/MenuSelect'
 import { SelectInput, SelectField } from '@components/atoms/SelectInput'

package/dist/generators/models/react.generator/modals.generator.d.ts

@@ -1,5 +1,5 @@
-import { Model } from '../../../lib/schema/schema';
 import { ModelMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
 /**
  * Utility generator that creates a create modal component for a given model.
  */