@postxl/generator 0.34.0 → 0.36.0

package/dist/generators/indices/{datamockmodule.generator.js → datamock-module.generator.js}

@@ -30,21 +30,13 @@ const Types = __importStar(require("../../lib/schema/types"));
 /**
  * Generates a mocking class
  */
-// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateDataMockModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.dataMockModuleFilePath)
-        .addImport({
-        items: [Types.toVariableName('DataModule')],
-        from: meta.data.dataModuleFilePath,
-    })
-        .addImport({
-        items: [Types.toVariableName('DataService')],
-        from: meta.data.dataServiceFilePath,
-    })
-        .addImport({
-        items: [Types.toVariableName('TestDataService')],
-        from: meta.data.testDataServiceFilePath,
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataMockModuleFilePath).addImports({
+        [meta.data.dataModuleFilePath]: [Types.toVariableName('DataModule')],
+        [meta.data.dataServiceFilePath]: [Types.toVariableName('DataService')],
+        // we need to import the file directly instead via the normal index file as this would cause a circular dependency else
+        [meta.actions.actionExecutionInterfaceFilePath]: [meta.actions.actionExecutionMock],
     });
     for (const { model, meta } of mm) {
         imports.addImport({ items: [model.typeName], from: meta.types.importPath });
@@ -57,7 +49,7 @@ function generateDataMockModule({ models, meta }) {
           useFactory: async () => {
             const repository = new ${meta.data.mockRepositoryClassName}()
             if (!!seed && !!seed.${meta.seed.constantName}) {
-              await repository.reInit(seed.${meta.seed.constantName})
+              await repository.reInit({items: seed.${meta.seed.constantName}, execution })
             }
             return repository
           }
@@ -70,11 +62,11 @@ import { DbModule } from '@${meta.config.project}/db'
 ${imports.generate()}
 
 export class DataMockModule {
-  
   static mock(seed?: MockData): DynamicModule {
+    const execution = new MockActionExecution()
+
     const providers = [
       DataService, 
-      TestDataService, 
       ${providers} 
     ]
 

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

@@ -11,13 +11,9 @@ function generateDataMocker({ models, meta: schemaMeta }) {
     const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     const imports = imports_1.ImportsGenerator.from(schemaMeta.data.dataMockerFilePath);
     for (const { model, meta } of modelMetas) {
-        imports.addImport({
-            items: [model.typeName],
-            from: meta.types.importPath,
-        });
-        imports.addImport({
-            items: [meta.data.stubGenerationFnName],
-            from: schemaMeta.data.dataMockerStubImportPath,
+        imports.addImports({
+            [meta.types.importPath]: [model.typeName],
+            [schemaMeta.data.dataMockerStubImportPath]: [meta.data.stubGenerationFnName],
         });
     }
     const publicVariables = modelMetas
@@ -27,13 +23,15 @@ function generateDataMocker({ models, meta: schemaMeta }) {
         .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');
-    // const timeNow = new Date().toLocaleTimeString('en-US', { hour12: false, hour: 'numeric', minute: 'numeric' })
-    // const todayDate = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'numeric', day: 'numeric' })
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import type { MockData } from '@pxl/data'
-import { IdTracker } from './id-tracker.class'
+
 ${imports.generate()}
 
+import { IdTracker } from './id-tracker.class'
+
+
 export class DataMocker implements MockData {
   ${publicVariables}
 
@@ -44,38 +42,46 @@ export class DataMocker implements MockData {
 `;
 }
 exports.generateDataMocker = generateDataMocker;
-// Generated time stamp: ${todayDate} ${timeNow}
 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 })));
-    return `public add${model.typeName}(item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName}}>): DataMocker {
-    const initial${meta.data.dataServiceIdName} = stub${model.typeName}(item ?? {})
-    this.${meta.data.dataServiceName}.push(this.${meta.data.dataServiceIdName}Ids.ensureId(initial${meta.data.dataServiceIdName}))
-    const ${meta.data.dataServiceIdName} = this.${meta.data.dataServiceName}[this.${meta.data.dataServiceName}.length - 1]
-    ${relations
-        .map((r) => `
-        ${r.isRequired
-        ? `
-            if (${meta.data.dataServiceIdName}.${r.name}) {
-                if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
-                    this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
-                }
-            } else {
-                if (this.${r.meta.data.dataServiceName}.length === 0) {
-                  this.add${r.model.typeName}()
-                }
-                ${meta.data.dataServiceIdName}.${r.name} = this.${r.meta.data.dataServiceName}[0].id
-              }
-        `
-        : `
-            if (${meta.data.dataServiceIdName}.${r.name}) {
-              if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
-                  this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
-              }
-            }
-            `}
-    `)
-        .join('\n')}
+    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 `
+  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/datamodule.generator.js

@@ -30,17 +30,10 @@ const Types = __importStar(require("../../lib/schema/types"));
 /**
  * Generates a data module class.
  */
-// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateDataModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.dataModuleFilePath)
-        .addImport({
-        items: [Types.toVariableName('TestDataService')],
-        from: meta.data.testDataServiceFilePath,
-    })
-        .addImport({
-        items: [Types.toVariableName('DataService')],
-        from: meta.data.dataServiceFilePath,
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataModuleFilePath).addImports({
+        [meta.data.dataServiceFilePath]: [Types.toVariableName('DataService')],
     });
     for (const { meta } of mm) {
         imports.addImport({
@@ -65,7 +58,9 @@ export class ${moduleName} {
    * The getInstance method should be called by any module that needs the module.
    */
   static getInstance(): DynamicModule {
-    if (!${moduleName}.cachedModule) throw new Error('${moduleName} must be called via .provide first!')
+    if (!${moduleName}.cachedModule) {
+      throw new Error('${moduleName} must be called via .provide first!')
+    }
     return ${moduleName}.cachedModule
   }
   
@@ -106,11 +101,10 @@ export class ${moduleName} {
       return ${moduleName}.cachedModule
     }
 
-    const repositoryProviders = [
+    const providers = [
       ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',')}
     ]
-    const providers = [TestDataService, ...repositoryProviders]
-
+    
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,

package/dist/generators/indices/{businesslogicmodule.generator.d.ts → dispatcher-service.generator.d.ts}

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

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionsDispatcherService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the action dispatcher service.
+ */
+function generateActionsDispatcherService({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.seed.serviceFilePath).addImports({
+        [meta.seed.importPath]: [meta.seed.serviceClassName],
+        [meta.businessLogic.update.importPath]: [meta.businessLogic.update.serviceClassName],
+        [meta.types.importPath]: meta.config.userType,
+    });
+    const dataLoader = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        dataLoader.push(`await this.upload({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}, repo: this.dataService.${modelMeta.data.dataServiceName}, log })`);
+    }
+    return `
+  import { Injectable } from '@nestjs/common'
+
+import { ExhaustiveSwitchCheck } from '@pxl/common'
+import { DbService } from '@pxl/db'
+
+${imports.generate()}
+
+import { ActionExecution, createActionExecution } from './actionExecution.class'
+import { Action, ResultOfAction } from './actions.types'
+
+
+@Injectable()
+export class DispatcherService {
+  // as the SeedModule gets instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
+  // we set the seedService to a dummy value and then overwrite it in the ${meta.seed.serviceClassName} constructor.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+  public seedService: ${meta.seed.serviceClassName} = {} as unknown as any
+  constructor(
+    private readonly updateService: ${meta.businessLogic.update.serviceClassName}, 
+    private readonly dbService: DbService
+  ) {}
+
+  public async dispatch<A extends Action>({ action, user }: { 
+    action: A; 
+    user: ${meta.config.userType} 
+  }): Promise<ResultOfAction<A>> {
+    const execution = await createActionExecution({ action, dbService: this.dbService, user })
+
+    try {
+      const result = await (this.execute({ action, execution }) as Promise<ResultOfAction<A>>)
+
+      await execution.success()
+
+      return result
+    } catch (e) {
+      await execution.error(e)
+      throw e
+    }
+  }
+
+  private async execute({ action, execution }: { action: Action; execution: ActionExecution }) {
+    switch (action.scope) {
+      ${models
+        .map((model) => {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        return `
+        case '${modelMeta.businessLogic.scopeName}':
+          return this.updateService.${modelMeta.businessLogic.update.serviceVariableName}.dispatch({ action, execution })
+        `;
+    })
+        .join('\n')}
+      case 'seed':
+        return this.seedService.dispatch({ action, execution })
+      default:
+        throw new ExhaustiveSwitchCheck(action)
+    }
+  }
+}
+  `;
+}
+exports.generateActionsDispatcherService = generateActionsDispatcherService;

package/dist/generators/indices/seed-migration.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the initial migration based on the generated seed data.
+ */
+export declare function generateSeedMigration({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/seed-migration.generator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedMigration = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the initial migration based on the generated seed data.
+ */
+function generateSeedMigration({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.seedData.initialMigrationFilePath);
+    const modelTypes = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            items: [modelMeta.seed.constantName],
+            from: modelMeta.seed.filePath,
+        });
+        modelTypes.push(`${modelMeta.seed.constantName}: { create: ${modelMeta.seed.constantName} }`);
+    }
+    return `
+import { createActionSeedData } from '${meta.seed.importPath}'
+${imports.generate()}
+
+export const MIGRATION_001_BASEDATA = createActionSeedData({
+  name: 'Base data',
+  order: 1,
+  data: [
+    {
+      ${modelTypes.join(',\n')}
+    },
+  ],
+})
+`;
+}
+exports.generateSeedMigration = generateSeedMigration;

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

@@ -3,7 +3,7 @@ import { Model } from '../../lib/schema/schema';
 /**
  * Generates index file for all seed files.
  */
-export declare function generateSeedService({ models, meta }: {
+export declare function generateSeedService({ models }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;