@postxl/generator 0.51.0 → 0.52.0

package/dist/generator.js

@@ -84,6 +84,7 @@ const parse_1 = require("./prisma/parse");
 const CONFIG_SCHEMA = zod_1.z
     .object({
     pathToDataLib: zod_1.z.string().optional(),
+    pathToDbLib: zod_1.z.string().optional(),
     pathToCypress: zod_1.z.string().optional(),
     pathToE2ELib: zod_1.z.string().optional(),
     pathToImportExport: zod_1.z.string().optional(),
@@ -108,6 +109,7 @@ const CONFIG_SCHEMA = zod_1.z
     return {
         paths: {
             dataLibPath: (0, types_1.toPath)(s.pathToDataLib || './backend/libs/data/src/'),
+            dbLibPath: (0, types_1.toPath)(s.pathToDbLib || './backend/libs/db/src/'),
             cypressPath: (0, types_1.toPath)(s.pathToCypress || './e2e/cypress/'),
             e2eLibPath: (0, types_1.toPath)(s.pathToE2ELib || './backend/libs/e2e/src/'),
             importExportPath: (0, types_1.toPath)(s.pathToImportExport || './backend/libs/import-export/src/'),
@@ -203,6 +205,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         // Data
         generated.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamock_module_generator_1.generateDataMockModule)({ models, meta }));
         generated.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
+        generated.write(`/${meta.data.emptyDbCommandFilePath}.ts`, (0, emptydatabasemigration_generator_1.generateEmptyDatabaseCommand)({ models, meta }));
         generated.write(`/${meta.data.dataService.filePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
         generated.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdata_service_generator_1.generateTestDataService)({ models, meta }));
         generated.write(`/${meta.e2e.dataMocker.filePath}.ts`, (0, datamocker_generator_1.generateDataMocker)({ models, meta }));
@@ -212,12 +215,6 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         generated.write(`/${meta.data.repository.indexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
         generated.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
         generated.write(`/${meta.data.types.filePath}.ts`, (0, data_types_generator_1.generateDataTypes)({ 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 }));
-        }
         // Import-Export
         generated.write(`/${meta.importExport.types.filePath}.ts`, (0, importexport_types_generator_1.generateImportExportTypes)({ models, meta }));
         generated.write(`/${meta.importExport.exporterClass.filePath}.ts`, (0, importexport_exporter_class_generator_1.generateImportExportExporterClass)({ models, meta }));

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

@@ -1,22 +1,11 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ * Generates a const that contains the SQL to delete all data from the E2E database.
  *
- * The routine is used in e2e tests to empty the database before each test.
+ * This is used in e2e tests to empty the database before each test.
  */
-export declare function generateEmptyDatabaseStoredProcedure({ models }: {
+export declare function generateEmptyDatabaseCommand({ 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,74 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prismaMigrationExists = exports.deriveEmptyDatabaseMigrationFilePath = exports.generateEmptyDatabaseStoredProcedure = void 0;
-const fs_1 = __importDefault(require("fs"));
+exports.generateEmptyDatabaseCommand = void 0;
 /**
- * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ * Generates a const that contains the SQL to delete all data from the E2E database.
  *
- * The routine is used in e2e tests to empty the database before each test.
+ * This is used in e2e tests to empty the database before each test.
  */
-function generateEmptyDatabaseStoredProcedure({ models }) {
-    const modelTables = models
-        .map((model) => `\t${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`);
+function generateEmptyDatabaseCommand({ models }) {
+    const modelTables = models.map((model) => `${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 systemTables = ['Action', 'Mutation'].map((table) => `${configSchema}"${table}"`);
     const configTableName = `${configSchema}"Config"`;
-    return `
-CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
-    SELECT
-    FROM ${configTableName}
-    WHERE NOT "isTest"
-) THEN RETURN;
-END IF;
-TRUNCATE TABLE 
-${[...systemTables, ...modelTables].join(',\n')};
-
-END;
-$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.prismaMigrationsPath}! Please run "prisma migrate dev" first.`);
-    }
-    const existingTimestamp = firstMigration.split('_')[0];
-    const nextTimestamp = (Number.parseInt(existingTimestamp) + 1).toString();
-    return `/${meta.prismaMigrationsPath}/${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;
-/**
- * Returns the first migration in the migrations folder if it exists.
+    return /** ts */ `
+/** 
+ * SQL instruction to delete all data from the E2E database. Should only be used internally by the DbService!
  */
-function getFirstPrismaMigration(meta) {
-    const folder = meta.prismaMigrationsPath;
-    try {
-        return fs_1.default.readdirSync(folder).find((f) => fs_1.default.statSync(`${folder}/${f}`).isDirectory());
-    }
-    catch (err) {
-        return undefined;
-    }
+export const wipeDatabaseCommand = \`
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM ${configTableName} WHERE "isTest" = TRUE) THEN
+    TRUNCATE TABLE 
+      ${[...systemTables, ...modelTables].join(',\n      ')};
+  END IF;
+END
+$$;\`
+`;
 }
+exports.generateEmptyDatabaseCommand = generateEmptyDatabaseCommand;

package/dist/lib/meta.d.ts

@@ -134,6 +134,10 @@ export type SchemaMetaData = {
          * Path to the file containing the data module class definition.
          */
         dataModuleFilePath: Types.FilePath;
+        /**
+         * Path to the file containing the data module class definition.
+         */
+        emptyDbCommandFilePath: Types.FilePath;
         /**
          * Path to the file containing the mock data for the database.
          */

package/dist/lib/meta.js

@@ -119,6 +119,7 @@ function getSchemaMetadata({ config }) {
             importPath: Types.toBackendModulePath(`@backend/data`),
             dataModuleFilePath: Types.toPath(`${config.paths.dataLibPath}data.module`),
             dataMockModuleFilePath: Types.toPath(`${config.paths.dataLibPath}data.mock.module`),
+            emptyDbCommandFilePath: Types.toPath(`${config.paths.dbLibPath}wipe-database.sql`),
             repository: {
                 typeFilePath: Types.toPath(`${config.paths.dataLibPath}repository.type`),
                 typeName: Types.toTypeName(`Repository`),

package/dist/lib/schema/schema.d.ts

@@ -12,14 +12,14 @@ export type SchemaConfig = {
          * Path to the directory containing actions.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference actions using `@project/actions` import.
+         * may reference actions using `@backend/actions` import.
          */
         actionsPath: Types.FilePath;
         /**
          * Path to the directory containing business logic.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference mock data using `@project/business-logic` import.
+         * may reference mock data using `@backend/business-logic` import.
          */
         businessLogicPath: Types.FilePath;
         /**
@@ -34,14 +34,21 @@ export type SchemaConfig = {
          * Path to the directory containing data library definitions.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference data library using `@project/data` import.
+         * may reference data library using `@backend/data` import.
          */
         dataLibPath: Types.FilePath;
+        /**
+         * Path to the directory containing db library definitions.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference data library using `@backend/db` import.
+         */
+        dbLibPath: Types.FilePath;
         /**
          * Path to the directory containing import-export module.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference import-export using `@project/import-export` import.
+         * may reference import-export using `@backend/import-export` import.
          */
         importExportPath: Types.FilePath;
         /**
@@ -52,28 +59,28 @@ export type SchemaConfig = {
          * Path to the directory containing model type definitions.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference type definitions using `@project/types` import.
+         * may reference type definitions using `@backend/types` import.
          */
         modelTypeDefinitionsPath: Types.FilePath;
         /**
          * Path to the directory containing React components.
          *
          * NOTE: Metadata assumes that the project is set up so that React components
-         * may be referenced using `@project/react` import.
+         * may be referenced using `@backend/react` import.
          */
         reactFolderPath: Types.FilePath;
         /**
          * Path to the directory containing seed module.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference mock data using `@project/seed` import.
+         * may reference mock data using `@backend/seed` import.
          */
         seedLibPath: Types.FilePath;
         /**
          * Path to the directory containing mock data samples.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
-         * may reference mock data using `@project/seed-data` import.
+         * may reference mock data using `@backend/seed-data` import.
          */
         seedDataPath: Types.FilePath;
         /**

package/package.json

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