@postxl/generator 0.38.2 → 0.40.0

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

@@ -8,30 +8,55 @@ const meta_1 = require("../../lib/meta");
  */
 function generateDataService({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.dataServiceFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataService.filePath);
     for (const { meta } of mm) {
         imports.addImport({
-            items: [meta.data.repositoryClassName],
-            from: meta.data.repoFilePath,
+            items: [meta.data.repository.className],
+            from: meta.data.repository.filePath,
         });
     }
     const constructor = mm
-        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repositoryClassName}`)
+        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repository.className}`)
         .join(',\n');
     const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
     const excelExports = mm
-        .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
+        .map(({ meta }) => `${meta.importExport.tableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
         .join('\n');
     const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
-    return `
-import { Injectable } from '@nestjs/common'
+    // Building blocks for bulk mutations
+    imports.addImports({
+        [meta.types.importPath]: [meta.types.dto.create, meta.types.dto.update],
+        [meta.data.repository.typeFilePath]: [meta.data.repository.typeName],
+        [meta.data.types.filePath]: [meta.data.types.bulkMutation],
+        [meta.actions.importPath]: [meta.actions.actionExecution.interface],
+    });
+    const creates = [];
+    const updates = [];
+    const upserts = [];
+    const deletes = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+    }
+    return /* ts */ `
+import { Injectable, Logger } from '@nestjs/common'
 
-import { mapValues } from '@pxl/common'
+import { format, mapValues, pluralize } from '@pxl/common'
 
 ${imports.generate()}
 
+// If true, the bulk mutation will be executed one by one, instead of all at once (which is the default).
+// Also, each item will be logged to the console.
+// This should help to quickly identify the item that causes an error in a bulk mutation.
+const DEBUG = false
+
 @Injectable()
-export class DataService {
+export class ${meta.data.dataService.class} {
+  private readonly logger = new Logger(${meta.data.dataService.class}.name)
+
   constructor(${constructor}) {}
 
   public async prepareExcelExport() {
@@ -49,6 +74,174 @@ export class DataService {
       ${isEmptyChecks}
     )
   }
+  public async ${meta.data.dataService.executeBulkMutations}(
+    { steps, execution }: 
+    { steps: ${meta.data.types.bulkMutation}[]; execution: ${meta.actions.actionExecution.interface} }
+  ) {
+    let index = 0
+    for (const step of steps) {
+      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
+      await this.${meta.data.dataService.executeBulkMutation}({ data: step, execution })
+    }
+  }
+
+  public async ${meta.data.dataService.executeBulkMutation}(
+    { data, execution }: 
+    { data: ${meta.data.types.bulkMutation}, execution: ${meta.actions.actionExecution.interface}}
+  ) {
+    // NOTE: the order of these calls is important, because of foreign key constraints
+    // The current order is based on the order of the models in the schema
+    // Change the order based on your needs.
+    // Attention: Depending on the dependencies in seed data, you may also have to take care of relations,
+    // e.g. by removing any foreign key first - and then update these after all data is created.
+    // Alternatively, you can also do this in multiple steps
+    ${creates.join('\n')}
+
+    ${updates.join('\n')}
+
+    ${upserts.join('\n')}
+
+    ${deletes.join('\n')}
+  }
+
+  private async create<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ${meta.types.dto.create}<T, ID>[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.createMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Creating \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.create?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error creating \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
+  }
+  
+  private async update<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ${meta.types.dto.update}<T, ID>[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.updateMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Updating \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.update?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error updating \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Updated \${format(data.length)} \${pluralize(name)}\`)
+  }
+
+  private async upsert<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: (${meta.types.dto.create}<T, ID> | ${meta.types.dto.update}<T, ID>)[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.upsertMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Upserting \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.upsert?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error upserting \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Upserted \${format(data.length)} \${pluralize(name)}\`)
+  }
+
+  private async delete<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ID[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.deleteMany?.({ ids: data, execution })
+    } else {
+      let i = 0
+      for (const id of data) {
+        i++
+        this.logger.log(\`Deleting \${name} \${i} - id: \${id.toString()}\`)
+        try {
+          await repo.delete?.({ id, execution })
+        } catch (error) {
+          this.logger.error(\`Error deleting \${name} \${i} - id: \${id.toString()}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Deleted \${format(data.length)} \${pluralize(name)}\`)
+  }
+}
+
+function _getItemDescription<T extends Partial<{ id: ID }>, ID extends number | string | boolean>(item: T): string {
+  const id = \`id: \${item.id !== undefined ? item.id.toString() : 'not provided'}\`
+
+  // If the item has a name, we can assume it is a string and add it to the description
+  if ('name' in item) {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    return \`\${id}, name: \${item.name}\`
+  }
+  return id
 }
 `;
 }

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

@@ -7,8 +7,9 @@ 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({
+    const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcherService.filePath).addImports({
         [meta.seed.importPath]: [meta.seed.serviceClassName],
+        [meta.importExport.importPath]: [meta.importExport.importService.name],
         [meta.businessLogic.update.importPath]: [meta.businessLogic.update.serviceClassName],
         [meta.types.importPath]: meta.config.userType,
     });
@@ -17,7 +18,7 @@ function generateActionsDispatcherService({ models, meta }) {
         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 `
+    return /* ts */ `
   import { Injectable } from '@nestjs/common'
 
 import { ExhaustiveSwitchCheck } from '@pxl/common'
@@ -25,26 +26,31 @@ import { DbService } from '@pxl/db'
 
 ${imports.generate()}
 
-import { ActionExecution, createActionExecution } from './actionExecution.class'
+import { ActionExecutionFactory, IActionExecution } from './actionExecution'
 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.
+export class ${meta.actions.dispatcherService.class} {
+  
+  // As SeedModule and ImportExportModule get instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
+  // we set the seedService and the importService to value and then overwrite it in the services' constructors.
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-  public seedService: ${meta.seed.serviceClassName} = {} as unknown as any
+  public seedService: SeedService = {} as unknown as any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+  public ${meta.importExport.importService.sharedName}: ImportService = {} as unknown as any
+
   constructor(
     private readonly updateService: ${meta.businessLogic.update.serviceClassName}, 
-    private readonly dbService: DbService
+    private readonly dbService: DbService,
+    private readonly actionExecutionFactory: ActionExecutionFactory,
   ) {}
 
   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 })
+    const execution = await this.actionExecutionFactory.create({ action, dbService: this.dbService, user })
 
     try {
       const result = await (this.execute({ action, execution }) as Promise<ResultOfAction<A>>)
@@ -58,7 +64,7 @@ export class DispatcherService {
     }
   }
 
-  private async execute({ action, execution }: { action: Action; execution: ActionExecution }) {
+  private async execute({ action, execution }: { action: Action; execution: IActionExecution }) {
     switch (action.scope) {
       ${models
         .map((model) => {
@@ -71,6 +77,10 @@ export class DispatcherService {
         .join('\n')}
       case 'seed':
         return this.seedService.dispatch({ action, execution })
+      
+      case 'import':
+        return this.importService.dispatch({ action, execution })
+      
       default:
         throw new ExhaustiveSwitchCheck(action)
     }

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

@@ -2,6 +2,8 @@ import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
  * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * The routine is used in e2e tests to empty the database before each test.
  */
 export declare function generateEmptyDatabaseStoredProcedure({ models }: {
     models: Model[];

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

@@ -7,13 +7,20 @@ exports.prismaMigrationExists = exports.deriveEmptyDatabaseMigrationFilePath = e
 const fs_1 = __importDefault(require("fs"));
 /**
  * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * The routine is used in e2e tests to empty the database before each test.
  */
 function generateEmptyDatabaseStoredProcedure({ models }) {
-    const tables = models
-        .map((model) => `\t${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`)
-        .join(',\n');
-    const useSchemas = models.some((model) => model.sourceSchemaName !== undefined);
-    const configTableName = useSchemas ? ' "Configuration"."Config"' : '"Config"';
+    const modelTables = models
+        .map((model) => `\t${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) => `\t${configSchema}"${table}"`);
+    const configTableName = `${configSchema}"Config"`;
     return `
 CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
     SELECT
@@ -22,8 +29,8 @@ CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
 ) THEN RETURN;
 END IF;
 TRUNCATE TABLE 
-${tables};
-UPDATE ${configTableName} SET "isSeeded"=false;
+${[...systemTables, ...modelTables].join(',\n')};
+
 END;
 $BODY$ LANGUAGE plpgsql;
   `;

package/dist/generators/indices/importexport-convert-import-functions.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the Exporter class for the Import-Export module
+ */
+export declare function generateImportExportConvertImportFunctions({ models, meta, }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;