@postxl/generator 0.34.0 → 0.35.0

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-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;

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

@@ -1,152 +1,356 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSeedService = void 0;
-const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 /**
  * Generates index file for all seed files.
  */
-function generateSeedService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seed.serviceFilePath).addImport({
-        from: meta.seed.templateDecoderFilePath,
-        items: [meta.seed.templateDecoderName],
-    });
-    const dataLoader = [];
+function generateSeedService({ models }) {
+    const creates = [];
+    const updates = [];
+    const upserts = [];
+    const deletes = [];
     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 })`);
+        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
     }
     return `
-  import { Injectable, Logger } from '@nestjs/common'
-  import { format, pluralize } from '@pxl/common'
-  import { DataService, Repository } from '@pxl/data'
-  import { DbService } from '@pxl/db'
-  import { XlPortService } from '@pxl/xlport'
-  ${imports.generate()}
-
-  import * as SEEDDATA from './data'
-  
+import { Injectable, Logger } from '@nestjs/common'
+import { ExhaustiveSwitchCheck, format, pluralize } from '@pxl/common'
+import { DataService, Repository } from '@pxl/data'
+import { DbService } from '@pxl/db'
+import { XlPortService } from '@pxl/xlport'
+
+import { ActionExecution, DispatcherService } from '@pxl/actions'
+import { RootUserService } from '@pxl/root-user'
+
+import {
+  ActionPreparation_Seed,
+  ActionPreparation_Seed_Excel,
+  Action_Seed,
+  Action_Seed_CustomLogic,
+  Action_Seed_Excel,
+  createActionSeedExcel,
+} from './action.types'
+import { SeedData } from './seed-data.type'
+import { CreateDTO, UpdateDTO } from '@pxl/types'
+import { SEED_MIGRATIONS } from '@pxl/seed-data'
+
+// If true, the seed data will be created/updated 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 operation.
+const DEBUG = false
+
+@Injectable()
+export class SeedService {
+  private readonly logger = new Logger(SeedService.name)
+
+  constructor(
+    private readonly dataService: DataService,
+    private readonly xlPortService: XlPortService,
+    private readonly dbService: DbService,
+    private readonly dispatcherService: DispatcherService,
+    private readonly rootUserService: RootUserService,
+  ) {
+    dispatcherService.seedService = this
+  }
+
   /**
-   * Configuration options for seeding
+   * To be called on application startup. Will validate the seed data migrations and execute any pending migrations.
+   *
+   * Each migration is an action, i.e. will be dispatched via the default dispatcher service and logged like any other action.
    */
-  export type SeedServiceOptions = {
-    /**
-     * If true, the database will be emptied before seeding.
-     * This is only possible if the database is set to test database!
-     */
-    reset?: boolean
-    /**
-     * If true, the seed data will be logged to the console.
-     * Note: This is significantly slower - but can be useful for debugging.
-     */
-    log?: boolean
+  public async seed() {
+    this.verifyIntegrity()
+
+    let executed = 0
+    for (const migration of SEED_MIGRATIONS) {
+      // Skip any migrations that have already been executed
+      const migrationExists = await this.dbService.action.findFirst({
+        where: { migrationOrder: migration.order, status: 'Success' },
+      })
+      if (migrationExists) {
+        continue
+      }
+
+      const action = await this.convertToAction(migration)
+
+      this.logger.log(\`Executing seed migration \${migration.order} - \${migration.name}\`)
+      await this.dispatcherService.dispatch({ action, user: this.rootUserService.rootUser })
+
+      executed++
+    }
+
+    if (executed === 0) {
+      if (SEED_MIGRATIONS.length > 0) {
+        this.logger.log(\`✅ All \${format(SEED_MIGRATIONS.length)} seed migrations have already been applied executed\`)
+      } else {
+        this.logger.log(\`No seed migrations found.\`)
+      }
+    } else {
+      if (executed === SEED_MIGRATIONS.length) {
+        this.logger.log(\`✅ Executed all \${format(executed)} seed migrations\`)
+      } else {
+        this.logger.log(
+          \`✅ Executed \${format(executed)} seed migrations, skipped \${format(SEED_MIGRATIONS.length - executed)} previous migrations\`,
+        )
+      }
+    }
   }
 
-  const DEFAULTOPTIONS: SeedServiceOptions = { reset: false, log: false }
-  @Injectable()
-  export class SeedService {
-    private readonly logger = new Logger(SeedService.name)
-    constructor(
-      private readonly dataService: DataService,
-      private readonly xlPortService: XlPortService,
-      private dbService: DbService,
-    ) {}
-    /**
-     * Seeds the database with the given data. Any data not provided will be taken from the default seed data.
-     */
-    public async seed({ data, options = DEFAULTOPTIONS }: { data?: Partial<typeof SEEDDATA>; options?: SeedServiceOptions }) {
-      return this._seed({ data: { ...SEEDDATA, ...data }, options })
+  private async convertToAction(migration: ActionPreparation_Seed): Promise<Action_Seed> {
+    switch (migration.type) {
+      case 'data':
+        return migration
+      case 'excel':
+        return await this.convertExcelToAction(migration)
+      case 'custom':
+        return migration
+      default:
+        throw new ExhaustiveSwitchCheck(migration)
     }
-  
-    /**
-     * Seeds the database with the given data from an Excel file.
-     */
-    public async seedFromExcel({
-      templatePath = './template.xlsx',
-      options = DEFAULTOPTIONS,
-    }: {
-      templatePath?: string
-      options?: SeedServiceOptions
-    }) {
-      const xlData = this.xlPortService.importFromFile(templatePath)
-  
-      const dataParsed = ${meta.seed.templateDecoderName}.safeParse(xlData)
-      if (!dataParsed.success) {
-        throw new Error(\`Error in parsing Excel seed data: \${JSON.stringify(dataParsed.error.message)}\`)
+  }
+
+  /**
+   * Will be call by the dispatcher service to dispatch the given action.
+   */
+  public async dispatch({ action, execution }: { action: Action_Seed; execution: ActionExecution }) {
+    switch (action.type) {
+      case 'data':
+        return this.uploadDataSteps({ steps: action.payload, execution })
+      case 'excel':
+        return this.uploadData({ data: action.payload.data, execution })
+      case 'custom':
+        return this.handleCustomLogic({ action, execution })
+
+      default:
+        throw new ExhaustiveSwitchCheck(action)
+    }
+  }
+
+  /**
+   * Checks if the order of the migrations is correct and if there are any missing migrations.
+   */
+  private verifyIntegrity() {
+    let startOrder = 0
+    for (const { name, order } of SEED_MIGRATIONS) {
+      if (order <= startOrder) {
+        throw new Error(
+          \`Invalid migration order. The order of migration "\${name}" must be after \${startOrder} but is \${order}. Is the order field correct and the order in the SEED_MIGRATIONS array correct?\`,
+        )
       }
-      return this._seed({ data: dataParsed.data, options })
+      startOrder = order
     }
-  
-    private async _seed({ data, options: { reset, log } }: { data: typeof SEEDDATA; options: SeedServiceOptions }) {
-      if (reset) {
-        this.logger.log('Resetting database')
-        await this.dbService.emptyDatabase()
-      } else {
-        const config = await this.dbService.config.findFirst({ where: { id: true } })
-        if (!config) {
-          throw new Error('Database is not initialized')
-        }
-        if (config.isSeeded) {
-          this.logger.log('Database is already seeded')
-          return
+  }
+
+  /**
+   * Reads the Excel file and parses it using the provided decoder.
+   * If the parsing is successful, the data is packaged into an Action_Seed_Excel.
+   */
+  private async convertExcelToAction({
+    name,
+    order,
+    filename,
+    decoder,
+  }: ActionPreparation_Seed_Excel): Promise<Action_Seed_Excel> {
+    const xlData = await this.xlPortService.importFromFile(filename)
+    if (xlData.status === 'error') {
+      this.logger.error(xlData.message)
+      throw new Error(\`Error importing Excel data\`)
+    }
+
+    const dataParsed = decoder.safeParse(xlData.data.tables)
+    if (!dataParsed.success) {
+      this.logger.error(dataParsed.error.message)
+      throw new Error(\`Error parsing Excel seed data\`)
+    }
+
+    return createActionSeedExcel({ name, order, filename, data: dataParsed.data })
+  }
+
+  /**
+   * Executes the custom logic of the given migration.
+   * To do this, we retrieve the handler from the migration and call it, injecting the data service into the handler.
+   */
+  private handleCustomLogic({ action, execution }: { action: Action_Seed_CustomLogic; execution: ActionExecution }) {
+    const actionPreparation = SEED_MIGRATIONS.find((m) => m.order === action.order)
+    if (!actionPreparation) {
+      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
+    }
+    if (actionPreparation.type !== 'custom') {
+      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
+    }
+    return actionPreparation.handler({ action, data: this.dataService, execution })
+  }
+  /**
+   * Executes the data loading step by step
+   */
+  private async uploadDataSteps({ steps, execution }: { steps: SeedData[]; execution: ActionExecution }) {
+    let index = 0
+    for (const step of steps) {
+      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
+      await this.uploadData({ data: step, execution })
+    }
+  }
+
+  private async uploadData({ data, execution }: { data: SeedData; execution: ActionExecution }) {
+    // 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: CreateDTO<T, ID>[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): 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
         }
       }
-  
-      await this.uploadData({ data, log })
-  
-      await this.dbService.config.update({
-        where: { id: true },
-        data: { isSeeded: true },
-      })
-  
-      this.logger.log('✅ Done')
     }
+    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
+  }
   
-    private async uploadData({ log = false, data }: { data: typeof SEEDDATA; log?: boolean }) {
-      // 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.
-      ${dataLoader.join('\n')}
+  private async update<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: UpdateDTO<T, ID>[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): Promise<void> {
+    if (!data) {
+      return
     }
-  
-    private async upload<T extends { id: ID }, ID extends number | string | boolean>({
-      name,
-      data,
-      repo,
-      log = false,
-      onlyOnReset = true,
-    }: {
-      name: string
-      data: T[]
-      repo: Repository<T, ID>
-      log?: boolean
-      onlyOnReset?: boolean
-    }): Promise<void> {
-      if (repo.count() > 0 && onlyOnReset) {
-        this.logger.log(\`\${pluralize(name)} already exist, skipping\`)
-        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
+        }
       }
-      if (!log) {
-        await repo.createMany(data)
-      } else {
-        let i = 0
-        for (const item of data) {
-          i++
-          console.log(name, i, item.id)
-          try {
-            await repo.create?.(item)
-          } catch (error) {
-            console.log(item)
-            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: (CreateDTO<T, ID> | UpdateDTO<T, ID>)[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): 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(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
     }
-  } 
-  `;
+    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: Repository<T, ID>
+    execution: ActionExecution
+  }): 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
+}
+`;
 }
 exports.generateSeedService = generateSeedService;