@postxl/generators 0.2.2

package/dist/backend-data-management/data-management.generator.d.ts

@@ -0,0 +1,18 @@
+import * as Generator from '@postxl/generator';
+import { WithActions } from '../backend-actions';
+import { WithBackend } from '../backend-core';
+import { WithRepositories } from '../backend-repositories';
+import { WithDecoders } from '../decoders';
+type ContextRequirements = WithDecoders<WithActions<WithRepositories<WithBackend<Generator.Context>>>>;
+export type ContextResult = WithDataManagement<ContextRequirements>;
+export type WithDataManagement<Context> = Generator.ExtendContext<Context, {
+    dataManagement: DataManagementContext;
+}>;
+export type DataManagementContext = {
+    module: Generator.ImportableItem;
+    service: Generator.ImportableItem;
+    controller: Generator.ImportableItem;
+};
+export declare const generatorId: string & import("zod").BRAND<"PXL.GeneratorInterfaceId">;
+export declare const generator: Generator.GeneratorInterface;
+export {};

package/dist/backend-data-management/data-management.generator.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = exports.generatorId = void 0;
+const path = __importStar(require("node:path"));
+const Generator = __importStar(require("@postxl/generator"));
+const generator_1 = require("@postxl/generator");
+const backend_actions_1 = require("../backend-actions");
+const backend_core_1 = require("../backend-core");
+const backend_repositories_1 = require("../backend-repositories");
+const decoders_1 = require("../decoders");
+const data_management_service_generator_1 = require("./generators/data-management-service.generator");
+exports.generatorId = Generator.toGeneratorInterfaceId('backend-data-management');
+exports.generator = {
+    id: exports.generatorId,
+    requires: [backend_core_1.backendGeneratorId, backend_actions_1.backendActionsGeneratorId, backend_repositories_1.backendRepositoriesGeneratorId, decoders_1.decodersGeneratorId],
+    register: (context) => {
+        const module = {
+            name: Generator.toClassName('DataManagementModule'),
+            location: Generator.toBackendModuleLocation('@data-management/data-management.module'),
+        };
+        const dataManagementModule = {
+            name: Generator.toBackendModuleName('data-management'),
+            moduleClass: module,
+            bootStrap: {
+                import: (0, generator_1.ts)("import multipart from '@fastify/multipart'"),
+                code: (0, generator_1.ts)(`await app.register(multipart, { limits: { fileSize: 100 * 1024 * 1024 }})`),
+            },
+            apiModuleRegistration: {
+                code: (0, generator_1.ts)('...(config.admin.allowBackend ? [DataManagementModule] : [])'),
+            },
+        };
+        context.backend.modules.push(dataManagementModule);
+        context.backend.packageJson.dependencies.push({ packageName: '@fastify/multipart', version: '9.2.1' });
+        const serviceLocation = Generator.toBackendModuleLocation('@data-management/data-management.service');
+        const service = {
+            name: Generator.toClassName('DataManagementService'),
+            location: serviceLocation,
+        };
+        const controller = {
+            name: Generator.toClassName('DataManagementController'),
+            location: Generator.toBackendModuleLocation('@data-management/data-management.controller'),
+        };
+        const dataManagement = { module, service, controller };
+        return { ...context, dataManagement };
+    },
+    generate: async (context) => {
+        const vfsSrc = new Generator.VirtualFileSystem();
+        // Load static template files
+        await vfsSrc.loadFile({
+            diskPath: path.resolve(__dirname, './template/data-management.controller.ts'),
+            targetPath: Generator.toLocalFile(context.dataManagement.controller),
+        });
+        await vfsSrc.loadFile({
+            diskPath: path.resolve(__dirname, './template/data-management.module.ts'),
+            targetPath: Generator.toLocalFile(context.dataManagement.module),
+        });
+        // Generate dynamic service file
+        vfsSrc.write(Generator.toLocalFile(context.dataManagement.service), (0, data_management_service_generator_1.generateDataManagementService)(context));
+        // Add index.ts for the module
+        vfsSrc.write('index.ts', `export { DataManagementModule } from './data-management.module'
+export { DataManagementService } from './data-management.service'
+export { DataManagementController } from './data-management.controller'
+`);
+        const vfs = new Generator.VirtualFileSystem();
+        vfs.insertFromVfs({ targetPath: 'src', vfs: vfsSrc });
+        vfs.write('/tsconfig.lib.json', Generator.generateTsConfig('data-management'));
+        context.vfs.insertFromVfs({ targetPath: 'backend/libs/data-management', vfs });
+        return context;
+    },
+};
+//# sourceMappingURL=data-management.generator.js.map

package/dist/backend-data-management/data-management.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-management.generator.js","sourceRoot":"","sources":["../../src/backend-data-management/data-management.generator.ts"],"names":[],"mappings":"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"}

package/dist/backend-data-management/generators/data-management-service.generator.d.ts

@@ -0,0 +1,8 @@
+import * as Generator from '@postxl/generator';
+import { WithActions } from '../../backend-actions';
+import { WithBackend } from '../../backend-core';
+import { WithRepositories } from '../../backend-repositories';
+import { WithDecoders } from '../../decoders';
+type ContextRequirements = WithDecoders<WithActions<WithRepositories<WithBackend<Generator.Context>>>>;
+export declare function generateDataManagementService(context: ContextRequirements): string;
+export {};

package/dist/backend-data-management/generators/data-management-service.generator.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataManagementService = generateDataManagementService;
+function generateDataManagementService(context) {
+    return /*ts*/ `
+import { DispatcherService } from '@actions/dispatcher.service'
+import type { DataModel, DataModelFlattened, ExcelDataModelFlattened } from '@decoders/data-model.decoder'
+import {
+  decodeDataModel,
+  decodeExcelDataModel,
+  flattenDataModel,
+  flattenExcelDataModel,
+} from '@decoders/data-model.decoder'
+import type { Action_Import } from '@import/import.service'
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common'
+import { DataService } from '@repositories/data.service'
+import { XlPortService } from '@xlport/xlport.service'
+
+import { timeStamp } from '@postxl/utils'
+
+@Injectable()
+export class DataManagementService {
+  private readonly logger = new Logger(DataManagementService.name)
+
+  constructor(
+    private readonly dataService: DataService,
+    private readonly xlPortService: XlPortService,
+    @Inject(forwardRef(() => DispatcherService)) private readonly dispatcherService: DispatcherService,
+  ) {}
+
+  /**
+   * Export raw Excel data to JSON
+   * Uploads an Excel file and returns the cleaned tables as JSON
+   */
+  async exportRawExcel(fileBuffer: Buffer): Promise<{ filename: string; data: any }> {
+    this.logger.log('Exporting raw Excel data to JSON')
+
+    // Import from Excel
+    const xlData = await this.xlPortService.importFromFile(fileBuffer)
+
+    if (xlData.status !== 'success') {
+      throw new Error(\`Error reading Excel file: \${xlData.message}\`)
+    }
+
+    // Clean the data
+    const cleanedTables = this.xlPortService.replaceBlankStringsWithNull(
+      this.xlPortService.replaceBlankTables(xlData.data.tables),
+    )
+
+    const filename = \`\${timeStamp()} raw-excel-export.json\`
+    return { filename, data: cleanedTables }
+  }
+
+  /**
+   * Export processed Excel data to JSON
+   * Uploads an Excel file, decodes it, and returns the DataModel as JSON
+   */
+  async exportProcessedExcel(fileBuffer: Buffer): Promise<{ filename: string; data: DataModel }> {
+    this.logger.log('Exporting processed Excel data to JSON')
+
+    // Import and clean from Excel
+    const xlData = await this.xlPortService.importFromFile(fileBuffer)
+
+    if (xlData.status !== 'success') {
+      throw new Error(\`Error reading Excel file: \${xlData.message}\`)
+    }
+
+    const cleanedTables = this.xlPortService.replaceBlankStringsWithNull(
+      this.xlPortService.replaceBlankTables(xlData.data.tables),
+    )
+
+    // Decode to DataModel
+    const dataModel = decodeExcelDataModel(cleanedTables as unknown as ExcelDataModelFlattened)
+
+    const filename = \`\${timeStamp()} decoded-excel-export.json\`
+    return { filename, data: dataModel }
+  }
+
+  /**
+   * Export current database to JSON (Excel format)
+   * Fetches all data from repositories and exports as ExcelDataModelFlattened
+   */
+  async exportDatabaseExcelFormat(): Promise<{ filename: string; data: ExcelDataModelFlattened }> {
+    this.logger.log('Exporting database to Excel format JSON')
+
+    // Fetch all data from repositories using the centralized method
+    const dataModel = await this.dataService.${context.repositories.dataService.getAllAsDataModel}()
+
+    // Flatten to Excel format
+    const flattened = flattenExcelDataModel(dataModel)
+
+    const filename = \`\${timeStamp()} database-excel-format-export.json\`
+    return { filename, data: flattened }
+  }
+
+  /**
+   * Export current database to JSON (JSON format)
+   * Fetches all data from repositories and exports as DataModelFlattened
+   */
+  async exportDatabaseJsonFormat(): Promise<{ filename: string; data: DataModelFlattened }> {
+    this.logger.log('Exporting database to JSON format')
+
+    // Fetch all data from repositories using the centralized method
+    const dataModel = await this.dataService.${context.repositories.dataService.getAllAsDataModel}()
+
+    // Flatten to JSON format
+    const flattened = flattenDataModel(dataModel)
+
+    const filename = \`\${timeStamp()} database-json-format-export.json\`
+    return { filename, data: flattened }
+  }
+
+  /**
+   * Seed from raw Excel data
+   * Clears database and imports data from Excel file
+   */
+  async seedFromRawExcel(fileBuffer: Buffer, originalFilename: string): Promise<{ success: boolean; result: any }> {
+    this.logger.log('Seeding database from raw Excel data')
+
+    // Clear database
+    await this.dataService.init(true)
+
+    // Dispatch import action
+    const action: Action_Import = {
+      scope: 'import',
+      type: 'excelSeed',
+      payload: {
+        filename: originalFilename,
+        data: fileBuffer,
+      },
+    }
+
+    const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+    return { success: true, result }
+  }
+
+  /**
+   * Seed from decoded JSON
+   * Clears database and imports data from DataModel JSON
+   */
+  async seedFromDecodedJson(fileBuffer: Buffer): Promise<{ success: boolean; result: any }> {
+    this.logger.log('Seeding database from decoded JSON')
+
+    // Clear database
+    await this.dataService.init(true)
+
+    // Parse JSON to DataModel
+    const data: DataModel = JSON.parse(fileBuffer.toString('utf-8'))
+
+    // Dispatch import action
+    const action: Action_Import = {
+      scope: 'import',
+      type: 'dataSeed',
+      payload: data,
+    }
+
+    const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+    return { success: true, result }
+  }
+
+  /**
+   * Seed from Excel-formatted JSON
+   * Clears database and imports data from ExcelDataModelFlattened JSON
+   */
+  async seedFromExcelFormattedJson(fileBuffer: Buffer): Promise<{ success: boolean; result: any }> {
+    this.logger.log('Seeding database from Excel-formatted JSON')
+
+    // Clear database
+    await this.dataService.init(true)
+
+    // Parse and decode JSON
+    const flatData: ExcelDataModelFlattened = JSON.parse(fileBuffer.toString('utf-8'))
+    const data: DataModel = decodeExcelDataModel(flatData)
+
+    // Dispatch import action
+    const action: Action_Import = {
+      scope: 'import',
+      type: 'dataSeed',
+      payload: data,
+    }
+
+    const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+    return { success: true, result }
+  }
+
+  /**
+   * Seed from JSON-formatted JSON
+   * Clears database and imports data from DataModelFlattened JSON
+   */
+  async seedFromJsonFormattedJson(fileBuffer: Buffer): Promise<{ success: boolean; result: any }> {
+    this.logger.log('Seeding database from JSON-formatted JSON')
+
+    // Clear database
+    await this.dataService.init(true)
+
+    // Parse and decode JSON
+    const flatData: DataModelFlattened = JSON.parse(fileBuffer.toString('utf-8'))
+    const data: DataModel = decodeDataModel(flatData)
+
+    // Dispatch import action
+    const action: Action_Import = {
+      scope: 'import',
+      type: 'dataSeed',
+      payload: data,
+    }
+
+    const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+    return { success: true, result }
+  }
+
+  /**
+   * Update from raw Excel data
+   * Imports data from Excel file with delta detection
+   */
+  async updateFromRawExcel(
+    fileBuffer: Buffer,
+    originalFilename: string,
+  ): Promise<{ success: boolean; result?: any; errors?: any }> {
+    this.logger.log('Updating database from raw Excel data with delta detection')
+
+    try {
+      // Dispatch import action
+      const action: Action_Import = {
+        scope: 'import',
+        type: 'excel',
+        payload: {
+          filename: originalFilename,
+          data: fileBuffer,
+        },
+      }
+
+      const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+      return { success: true, result }
+    } catch (error) {
+      this.logger.error('Error updating from raw Excel data', error)
+      return { success: false, errors: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  /**
+   * Update from decoded JSON
+   * Imports data from DataModel JSON with delta detection
+   */
+  async updateFromDecodedJson(fileBuffer: Buffer): Promise<{ success: boolean; result?: any; errors?: any }> {
+    this.logger.log('Updating database from decoded JSON with delta detection')
+
+    // Parse JSON to DataModel
+    const data: DataModel = JSON.parse(fileBuffer.toString('utf-8'))
+
+    try {
+      // Dispatch import action
+      const action: Action_Import = {
+        scope: 'import',
+        type: 'data',
+        payload: data,
+      }
+
+      const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+      return { success: true, result }
+    } catch (error) {
+      this.logger.error('Error updating from decoded JSON', error)
+      return { success: false, errors: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  /**
+   * Update from Excel-formatted JSON
+   * Imports data from ExcelDataModelFlattened JSON with delta detection
+   */
+  async updateFromExcelFormattedJson(fileBuffer: Buffer): Promise<{ success: boolean; result?: any; errors?: any }> {
+    this.logger.log('Updating database from Excel-formatted JSON with delta detection')
+
+    try {
+      // Parse and decode JSON
+      const flatData: ExcelDataModelFlattened = JSON.parse(fileBuffer.toString('utf-8'))
+      const data: DataModel = decodeExcelDataModel(flatData)
+
+      // Dispatch import action
+      const action: Action_Import = {
+        scope: 'import',
+        type: 'data',
+        payload: data,
+      }
+
+      const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+      return { success: true, result }
+    } catch (error) {
+      this.logger.error('Error updating from Excel-formatted JSON', error)
+      return { success: false, errors: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  /**
+   * Update from JSON-formatted JSON
+   * Imports data from DataModelFlattened JSON with delta detection
+   */
+  async updateFromJsonFormattedJson(fileBuffer: Buffer): Promise<{ success: boolean; result?: any; errors?: any }> {
+    this.logger.log('Updating database from JSON-formatted JSON with delta detection')
+
+    try {
+      // Parse and decode JSON
+      const flatData: DataModelFlattened = JSON.parse(fileBuffer.toString('utf-8'))
+      const data: DataModel = decodeDataModel(flatData)
+
+      // Dispatch import action
+      const action: Action_Import = {
+        scope: 'import',
+        type: 'data',
+        payload: data,
+      }
+
+      const result = await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
+
+      return { success: true, result }
+    } catch (error) {
+      this.logger.error('Error updating from JSON-formatted JSON', error)
+      return { success: false, errors: error instanceof Error ? error.message : String(error) }
+    }
+  }
+}
+`;
+}
+//# sourceMappingURL=data-management-service.generator.js.map

package/dist/backend-data-management/generators/data-management-service.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-management-service.generator.js","sourceRoot":"","sources":["../../../src/backend-data-management/generators/data-management-service.generator.ts"],"names":[],"mappings":";;AASA,sEAqUC;AArUD,SAAgB,6BAA6B,CAAC,OAA4B;IACxE,OAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAkF+B,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,iBAAiB;;;;;;;;;;;;;;;;;+CAiBlD,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgOhG,CAAA;AACD,CAAC"}

package/dist/backend-data-management/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-management.generator';
+export { generatorId as backendDataManagementGeneratorId, generator as backendDataManagementGenerator, } from './data-management.generator';

package/dist/backend-data-management/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backendDataManagementGenerator = exports.backendDataManagementGeneratorId = void 0;
+__exportStar(require("./data-management.generator"), exports);
+var data_management_generator_1 = require("./data-management.generator");
+Object.defineProperty(exports, "backendDataManagementGeneratorId", { enumerable: true, get: function () { return data_management_generator_1.generatorId; } });
+Object.defineProperty(exports, "backendDataManagementGenerator", { enumerable: true, get: function () { return data_management_generator_1.generator; } });
+//# sourceMappingURL=index.js.map

package/dist/backend-data-management/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/backend-data-management/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,8DAA2C;AAC3C,yEAGoC;AAFlC,6IAAA,WAAW,OAAoC;AAC/C,2IAAA,SAAS,OAAkC"}