@postxl/generator 0.17.0 → 0.19.0

package/dist/generator.js

@@ -198,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 }));

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

@@ -33,17 +33,16 @@ import { DynamicModule } from '@${meta.config.project}/common'
   
 ${imports.generate()}
 
-const providers = [${providers.join(', ')}]
 
 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.
-   */
+  */
+ 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
@@ -51,12 +50,13 @@ export class ${moduleName} {
 
   /**
    * 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,

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

@@ -70,8 +70,7 @@ ${imports.generate()}
 
 export class DataMockModule {
   
-  // 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, 

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

@@ -49,27 +49,14 @@ function generateDataModule({ models, meta }) {
     }
     const moduleName = meta.data.moduleName;
     return `
-import { Provider, Type } from '@nestjs/common'
+import { Provider } from '@nestjs/common'
 import { DynamicModule } from '@${meta.config.project}/common'
-import { DbModule, DbService } from '@${meta.config.project}/db'
+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.
@@ -95,13 +82,13 @@ export class ${moduleName} {
   /**
    * The forRoot method should only be called once by the root module.
    */
-  static forRoot({ loadData }: { loadData: boolean }): DynamicModule {
+  static forRoot(): DynamicModule {
     if (${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 = {
@@ -121,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.forRoot()],
-      providers: [...providers],
+      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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {