@postxl/generator 0.16.7 → 0.17.0

package/dist/generator.js

@@ -67,6 +67,7 @@ const businesslogicmodule_generator_1 = require("./generators/indices/businesslo
 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 seed_service_generator_1 = require("./generators/indices/seed-service.generator");
 const CONFIG_SCHEMA = zod_1.z
     .object({
     project: zod_1.z.string(),
@@ -206,6 +207,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         }
         if (!config.disableGenerators.seed) {
             generated.write(`/${meta.seed.indexFilePath}.ts`, (0, seed_generator_1.generateSeedIndex)({ models, meta }));
+            generated.write(`/${meta.seed.serviceFilePath}.ts`, (0, seed_service_generator_1.generateSeedService)({ models, meta }));
             generated.write(`/${meta.seed.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
             generated.write(`/${meta.seed.templateDecoderFilePath}.ts`, (0, seed_template_decoder_generator_1.generateSeedTemplateDecoder)({ models, meta }));
         }

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

@@ -27,19 +27,45 @@ function generateBusinessLogicModule({ models, meta }) {
         });
         providers.push(meta.businessLogic.serviceClassName);
     }
+    const moduleName = meta.businessLogic.moduleName;
     return `
-import { Module } from '@nestjs/common'
+import { DynamicModule } from '@${meta.config.project}/common'
   
 ${imports.generate()}
 
 const providers = [${providers.join(', ')}]
-@Module({
-  imports: [${meta.data.moduleName}],
-  providers,
-  exports: providers,
-})
-export class BusinessLogicModule {}
 
+export class ${moduleName} {
+  /**
+   * Internal cache for the module instance.
+   */
+  private static cachedModule: DynamicModule | undefined = undefined
+
+  /**
+   * 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!')
+    return ${moduleName}.cachedModule
+  }
+
+  /**
+   * The forRoot method should only be called once by the root module.
+   */
+  static forRoot(): DynamicModule {
+    if (${moduleName}.cachedModule) {
+      throw new Error('${moduleName} is already instantiated, please call .forRoot only once from root...')
+    }
+
+    ${moduleName}.cachedModule = {
+      module: ${moduleName},
+      providers,
+      imports: [${meta.data.moduleName}.getInstance()],
+      exports: providers,
+    }
+    return ${moduleName}.cachedModule
+  }
+}
 `;
 }
 exports.generateBusinessLogicModule = generateBusinessLogicModule;

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

@@ -69,16 +69,7 @@ import { DbModule } from '@${meta.config.project}/db'
 ${imports.generate()}
 
 export class DataMockModule {
-  private static cachedModule: DynamicModule | undefined = undefined
-
-  static isInstantiated(): boolean {
-    return !!DataMockModule.cachedModule
-  }
-  static getInstance(): DataModule {
-    if (!DataMockModule.cachedModule) throw new Error('DataMockModule must be called via .mock first!')
-    return DataMockModule.cachedModule
-  }
-
+  
   // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
   static async mock(seed?: MockData): Promise<DynamicModule> {
     const providers = [
@@ -87,15 +78,17 @@ export class DataMockModule {
       ${providers} 
     ]
 
-    DataMockModule.cachedModule = {
+    const cachedModule = {
       module: DataModule,
       imports: [DbModule.provideMock()],
       providers: providers,
       exports: providers,
       global: true,
     }
-
-    return DataMockModule.cachedModule
+    
+    ${meta.data.moduleName}._storeMockModule(cachedModule)
+    
+    return cachedModule
   }
 }
 

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

@@ -49,7 +49,8 @@ function generateDataModule({ models, meta }) {
     }
     const moduleName = meta.data.moduleName;
     return `
-import { DynamicModule, Provider, Type } from '@nestjs/common'
+import { Provider, Type } from '@nestjs/common'
+import { DynamicModule } from '@${meta.config.project}/common'
 import { DbModule, DbService } from '@${meta.config.project}/db'
 
 import { AsyncInit, Repository } from './repository.type'
@@ -70,21 +71,33 @@ const createRepositoryProvider = <T extends AsyncInit>(t: Type<T>, loadData: boo
 })
 
 export class ${moduleName} {
+  /**
+   * Internal cache for the module instance.
+   */
   private static cachedModule: DynamicModule | undefined = undefined
 
-  static isInstantiated(): boolean {
-    return !!${moduleName}.cachedModule
-  }
-
-  static getInstance(): ${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!')
     return ${moduleName}.cachedModule
   }
+  
+  /**
+   * Stores another module instance in the cache.
+   * Note: This should only be used for testing purposes.
+   */
+  static _storeMockModule(module: DynamicModule): void {
+    ${moduleName}.cachedModule = module
+  }
 
-  static provide({ loadData }: { loadData: boolean }): DynamicModule {
+  /**
+   * The forRoot method should only be called once by the root module.
+   */
+  static forRoot({ loadData }: { loadData: boolean }): DynamicModule {
     if (${moduleName}.cachedModule) {
-      console.warn('${moduleName} is already instantiated, skipping...')
-      return ${moduleName}.cachedModule
+      throw new Error('${moduleName} is already instantiated, please call .forRoot only once from root...')
     }
 
     const repositoryProviders = [
@@ -94,7 +107,7 @@ export class ${moduleName} {
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
-      imports: [DbModule.provide()],
+      imports: [DbModule.forRoot()],
       providers: [DataService, ...repositoryProviders],
       exports: [DataService, ...repositoryProviders],
     }
@@ -116,7 +129,7 @@ export class ${moduleName} {
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
-      imports: [DbModule.provide()],
+      imports: [DbModule.forRoot()],
       providers: [...providers],
       exports: providers,
     }

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

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

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

@@ -0,0 +1,162 @@
+"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 = [];
+    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, 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'
+  
+  /**
+   * Configuration options for seeding
+   */
+  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
+    /**
+     * If true, data will be loaded into the repositories after seeding.
+     * This should be used on startup of the application, but typically 
+     * not when running tests or from the CLI.
+     */
+    loadDataAfterSeeding?: boolean
+  }
+
+  const DEFAULTOPTIONS: SeedServiceOptions = { reset: false, log: false, loadDataAfterSeeding: 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 })
+    }
+  
+    /**
+     * 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)}\`)
+      }
+      return this._seed({ data: dataParsed.data, options })
+    }
+  
+    private async _seed({ data, options: { loadDataAfterSeeding, 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
+        }
+      }
+  
+      await this.uploadData({ data, log })
+  
+      await this.dbService.config.update({
+        where: { id: true },
+        data: { isSeeded: true },
+      })
+  
+      if (loadDataAfterSeeding) {
+        await this.dataService.init()
+      }
+  
+      this.logger.log('✅ Done')
+    }
+  
+    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 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 (!log) {
+        await repo.createMany(data)
+      } else {
+        let i = 0
+        for (const item of data) {
+          i++
+          console.log(name, i, item.id)
+          try {
+            await repo.createWithId?.(item)
+          } catch (error) {
+            console.log(item)
+            throw error
+          }
+        }
+      }
+  
+      this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
+    }
+  } 
+  `;
+}
+exports.generateSeedService = generateSeedService;

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

@@ -28,7 +28,7 @@ function generateSeedTemplateDecoder({ models, meta }) {
   
   ${decoders.join('\n')}
 
-  export const seedTemplateDecoder = z
+  export const ${meta.seed.templateDecoderName} = z
     .object({${tableDecoders.join(',\n')}})
     .transform((item) => ({${renameTransforms.join(',\n')}}))
   `;
@@ -73,8 +73,6 @@ function generateTableDecoder({ model, meta, imports, }) {
                 break;
             }
             case 'enum': {
-                const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
-                imports.addImport({ items: [field.enumerator.tsTypeName], from: refEnumMeta.types.importPath });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([${field.enumerator.values.map((v) => `'${v}'`).join(', ')}])${field.isRequired ? '' : '.nullable()'}`);
                 break;
             }

package/dist/lib/meta.d.ts

@@ -73,6 +73,10 @@ export type SchemaMetaData = {
          * Path to the index file for the seed package.
          */
         indexFilePath: Types.Path;
+        /**
+         * Path to the SeedService file.
+         */
+        serviceFilePath: Types.Path;
         /**
          * Path to seed Excel template file.
          */
@@ -81,6 +85,10 @@ export type SchemaMetaData = {
          * Path to template decoder file.
          */
         templateDecoderFilePath: Types.Path;
+        /**
+         * The name of the template decoder function.
+         */
+        templateDecoderName: Types.Fnction;
         /**
          * Path that may be used in the import statement.
          */

package/dist/lib/meta.js

@@ -55,9 +55,11 @@ function getSchemaMetadata({ config }) {
             importPath: Types.toPath(`@${config.project}/trpc`),
         },
         seed: {
-            indexFilePath: Types.toPath(`${config.paths.seedPath}index`),
+            indexFilePath: Types.toPath(`${config.paths.seedPath}data/index`),
+            serviceFilePath: Types.toPath(`${config.paths.seedPath}seed.service`),
             templateExcelFilePath: Types.toPath(`${config.paths.seedPath}template.xlsx`),
-            templateDecoderFilePath: Types.toPath(`${config.paths.seedPath}seed-decoder`),
+            templateDecoderFilePath: Types.toPath(`${config.paths.seedPath}seed.decoder`),
+            templateDecoderName: Types.toFunction(`seedTemplateDecoder`),
             importPath: Types.toPath(`@${config.project}/seed`),
             randomSeed: config.randomSeed,
         },
@@ -108,7 +110,7 @@ function getModelMetadata({ model }) {
             dataRepositoryVariableName: Types.toVariableName(`data`),
         },
         seed: {
-            filePath: Types.toPath(`${config.paths.seedPath}${uncapitalizedPlural}`),
+            filePath: Types.toPath(`${config.paths.seedPath}data/${uncapitalizedPlural}`),
             constantName: Types.toVariableName(`${uncapitalizedPlural}`),
             importPath: Types.toPath(`@${config.project}/seed`),
             excel: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.16.7",
+  "version": "0.17.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -45,7 +45,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepublish": "tsc -p tsconfig.build.json",
-    "dev": "tsc -b -w",
+    "dev": "tsc -p tsconfig.build.json -w",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:types": "tsc --noEmit",