@postxl/generator 0.16.8 → 0.19.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(),
@@ -197,7 +198,12 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.data.repositoriesConstFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
             generated.write(`/${meta.data.repositoriesIndexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
             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 }));
+            // We only generate the empty database migration if the migration folder already has an existing migration
+            // Else we would generate a migration that deletes from tables that have not yet been created in the database
+            // We include this check here as the template does not come with any migration - hence this migration should also not be generated
+            if ((0, emptydatabasemigration_generator_1.prismaMigrationExists)(meta)) {
+                generated.write((0, emptydatabasemigration_generator_1.deriveEmptyDatabaseMigrationFilePath)(meta), (0, emptydatabasemigration_generator_1.generateEmptyDatabaseStoredProcedure)({ models, meta }));
+            }
         }
         if (!config.disableGenerators.businessLogic) {
             generated.write(`/${meta.businessLogic.indexFilePath}.ts`, (0, businesslogicindex_generator_1.generateBusinessLogicIndex)({ models, meta }));
@@ -206,6 +212,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...')
+    }
+  
+    const providers = [${providers.join(', ')}]
+    ${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,33 +69,25 @@ 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> {
+  
+  static mock(seed?: MockData): DynamicModule {
     const providers = [
       DataService, 
       TestDataService, 
       ${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,52 +49,52 @@ function generateDataModule({ models, meta }) {
     }
     const moduleName = meta.data.moduleName;
     return `
-import { DynamicModule, Provider, Type } from '@nestjs/common'
-import { DbModule, DbService } from '@${meta.config.project}/db'
+import { Provider } from '@nestjs/common'
+import { DynamicModule } from '@${meta.config.project}/common'
+import { DbModule } from '@${meta.config.project}/db'
 
-import { AsyncInit, Repository } from './repository.type'
+import { Repository } from './repository.type'
 
 ${imports.generate()}
 
-const createRepositoryProvider = <T extends AsyncInit>(t: Type<T>, loadData: boolean): Provider => ({
-  inject: [DbService],
-  provide: t,
-  useFactory: async (dbService: DbService): Promise<T> => {
-    const repository = new t(dbService)
-    await dbService.isInitialized(t.name)
-    if (loadData) {
-      await repository.init()
-    }
-    return repository
-  },
-})
-
 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(): 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 = [
-      ${mm.map(({ meta }) => `createRepositoryProvider(${meta.data.repositoryClassName}, loadData)`).join(',\n')}
+      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',')}
     ]
 
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
-      imports: [DbModule.provide()],
+      imports: [DbModule.forRoot()],
       providers: [DataService, ...repositoryProviders],
       exports: [DataService, ...repositoryProviders],
     }
@@ -108,16 +108,16 @@ export class ${moduleName} {
       return ${moduleName}.cachedModule
     }
 
-    const providers: Provider<Repository<any, any>>[] = [
-      // createRepositoryProvider(TherapeuticAreaRepository, true),
-      TestDataService,
+    const repositoryProviders = [
+      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',')}
     ]
+    const providers = [TestDataService, ...repositoryProviders]
 
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
-      imports: [DbModule.provide()],
-      providers: [...providers],
+      imports: [DbModule.forRoot()],
+      providers,
       exports: providers,
     }
 

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

@@ -18,7 +18,7 @@ function generateDataService({ models, meta }) {
     const constructor = mm
         .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repositoryClassName}`)
         .join(',\n');
-    const initializer = mm.map(({ meta }) => `this.${meta.data.dataServiceName}.init()`).join(',\n');
+    const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
     const excelExports = mm
         .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(this.${meta.data.dataServiceName}.getAll()),`)
         .join('\n');
@@ -40,7 +40,7 @@ export class DataService {
   }
 
   public async init(): Promise<void> {
-    await Promise.all([${initializer}])
+    ${initializer}
   }
 
   public isEmpty(): boolean {

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

@@ -1,9 +1,20 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates a data module class.
+ * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
  */
 export declare function generateEmptyDatabaseStoredProcedure({ models }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;
+/**
+ * Generates a the full file path for the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * This is done by finding the first migration in the migrations folder and using its timestamp + 1.
+ * In case no migration is found, an error is shown!
+ */
+export declare function deriveEmptyDatabaseMigrationFilePath(meta: SchemaMetaData): string;
+/**
+ * Checks if any Prisma migration exists.
+ */
+export declare function prismaMigrationExists(meta: SchemaMetaData): boolean;

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

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEmptyDatabaseStoredProcedure = void 0;
+exports.prismaMigrationExists = exports.deriveEmptyDatabaseMigrationFilePath = exports.generateEmptyDatabaseStoredProcedure = void 0;
+const fs_1 = __importDefault(require("fs"));
 /**
- * Generates a data module class.
+ * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
  */
 function generateEmptyDatabaseStoredProcedure({ models }) {
     const tables = models
@@ -24,3 +28,31 @@ $BODY$ LANGUAGE plpgsql;
   `;
 }
 exports.generateEmptyDatabaseStoredProcedure = generateEmptyDatabaseStoredProcedure;
+/**
+ * Generates a the full file path for the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * This is done by finding the first migration in the migrations folder and using its timestamp + 1.
+ * In case no migration is found, an error is shown!
+ */
+function deriveEmptyDatabaseMigrationFilePath(meta) {
+    const firstMigration = getFirstPrismaMigration(meta);
+    if (firstMigration === undefined) {
+        throw new Error(`No Prisma migration found in ${meta.migrationsPath}! Please run "prisma migrate dev" first.`);
+    }
+    const existingTimestamp = firstMigration.split('_')[0];
+    const nextTimestamp = (Number.parseInt(existingTimestamp) + 1).toString();
+    return `/${meta.migrationsPath}/${nextTimestamp}_emptyDatabase/migration.sql`;
+}
+exports.deriveEmptyDatabaseMigrationFilePath = deriveEmptyDatabaseMigrationFilePath;
+/**
+ * Checks if any Prisma migration exists.
+ */
+function prismaMigrationExists(meta) {
+    const firstMigration = getFirstPrismaMigration(meta);
+    return firstMigration !== undefined;
+}
+exports.prismaMigrationExists = prismaMigrationExists;
+function getFirstPrismaMigration(meta) {
+    const folder = meta.migrationsPath;
+    return fs_1.default.readdirSync(folder).find((f) => fs_1.default.statSync(`${folder}/${f}`).isDirectory());
+}

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/generators/models/seed.generator.js

@@ -112,6 +112,7 @@ function quoteSingleQuote(str) {
     return str.replace(/'/g, "\\'");
 }
 function generateScalarFieldExample({ field, model, index, mode, }) {
+    var _a;
     const { hasExample, example } = generateFieldExample({ field, model, index, mode });
     switch (field.tsTypeName) {
         case 'string': {
@@ -143,6 +144,10 @@ function generateScalarFieldExample({ field, model, index, mode, }) {
             if (hasExample) {
                 return `${example}`;
             }
+            //in case the field is configured with `IsDefaultField` attribute, the first item should be true, all other false
+            if (((_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name) === field.name) {
+                return index === 0 ? 'true' : 'false';
+            }
             return generateMockBoolean();
         }
         case 'Date': {
@@ -204,6 +209,9 @@ function generateMockDate() {
     return `new Date('${d.toISOString()}')`;
 }
 function generateRelationFieldExample({ field, index, model, mode, }) {
+    if (!field.isRequired) {
+        return 'null';
+    }
     const referenceId = faker_1.faker.datatype.number({ min: 1, max: mode.itemCount });
     const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
     const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;

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.8",
+  "version": "0.19.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",