@postxl/generator 0.13.0 → 0.15.0

package/dist/generator.js

@@ -61,11 +61,18 @@ const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
 const client_path_1 = require("./prisma/client-path");
 const parse_1 = require("./prisma/parse");
+const businesslogicservice_generator_1 = require("./generators/indices/businesslogicservice.generator");
+const businesslogicindex_generator_1 = require("./generators/indices/businesslogicindex.generator");
+const businesslogicmodule_generator_1 = require("./generators/indices/businesslogicmodule.generator");
+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 CONFIG_SCHEMA = zod_1.z
     .object({
     project: zod_1.z.string(),
     pathToTypes: zod_1.z.string().optional(),
     pathToDataLib: zod_1.z.string().optional(),
+    pathToBusinessLogic: zod_1.z.string().optional(),
     pathToSeedLib: zod_1.z.string().optional(),
     trpcRoutesFolder: zod_1.z.string().optional(),
     reactFolderOutput: zod_1.z.string().optional(),
@@ -84,6 +91,7 @@ const CONFIG_SCHEMA = zod_1.z
         project: s.project,
         paths: {
             dataLibPath: (0, types_1.toPath)(s.pathToDataLib || 'repos'),
+            businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || 'repos'),
             reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
             modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || 'types'),
             seedPath: (0, types_1.toPath)(s.pathToSeedLib || 'seed'),
@@ -95,6 +103,7 @@ const CONFIG_SCHEMA = zod_1.z
         disableGenerators: {
             types: s.pathToTypes === undefined,
             data: s.pathToDataLib === undefined,
+            businessLogic: s.pathToBusinessLogic === undefined,
             seed: s.pathToSeedLib === undefined,
             trpc: s.trpcRoutesFolder === undefined,
             react: s.reactFolderOutput === undefined,
@@ -154,6 +163,10 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
                 generated.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
                 generated.write(`/${meta.data.mockRepoFilePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
             }
+            // Business Logic
+            if (!config.disableGenerators.businessLogic) {
+                generated.write(`/${meta.businessLogic.serviceFilePath}.ts`, (0, businesslogic_generator_1.generateModelBusinessLogic)({ model, meta }));
+            }
             // Routes
             if (!config.disableGenerators.trpc) {
                 generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
@@ -186,8 +199,15 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             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 }));
         }
+        if (!config.disableGenerators.businessLogic) {
+            generated.write(`/${meta.businessLogic.indexFilePath}.ts`, (0, businesslogicindex_generator_1.generateBusinessLogicIndex)({ models, meta }));
+            generated.write(`/${meta.businessLogic.moduleFilePath}.ts`, (0, businesslogicmodule_generator_1.generateBusinessLogicModule)({ models, meta }));
+            generated.write(`/${meta.businessLogic.serviceFilePath}.ts`, (0, businesslogicservice_generator_1.generateBusinessLogicService)({ models, meta }));
+        }
         if (!config.disableGenerators.seed) {
             generated.write(`/${meta.seed.indexFilePath}.ts`, (0, seed_generator_1.generateSeedIndex)({ 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 }));
         }
         if (!config.disableGenerators.trpc) {
             generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicIndex = void 0;
+const exports_1 = require("../../lib/exports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates index file for all businessLogic files.
+ */
+function generateBusinessLogicIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.businessLogic.indexFilePath);
+    exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
+    exports.exportEverythingFromPath(meta.businessLogic.moduleFilePath);
+    for (const model of models) {
+        const meta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
+    }
+    return exports.generate();
+}
+exports.generateBusinessLogicIndex = generateBusinessLogicIndex;

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

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a business Logic module class.
+ */
+export declare function generateBusinessLogicModule({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicModule = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates a business Logic module class.
+ */
+function generateBusinessLogicModule({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.moduleFilePath)
+        .addImport({
+        items: [meta.data.moduleName],
+        from: meta.data.importPath,
+    })
+        .addImport({
+        items: [meta.businessLogic.serviceClassName],
+        from: meta.businessLogic.serviceFilePath,
+    });
+    const providers = [meta.businessLogic.serviceClassName];
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.businessLogic.serviceClassName],
+            from: meta.businessLogic.serviceFilePath,
+        });
+        providers.push(meta.businessLogic.serviceClassName);
+    }
+    return `
+import { Module } from '@nestjs/common'
+  
+${imports.generate()}
+
+const providers = [${providers.join(', ')}]
+@Module({
+  imports: [${meta.data.moduleName}],
+  providers,
+  exports: providers,
+})
+export class BusinessLogicModule {}
+
+`;
+}
+exports.generateBusinessLogicModule = generateBusinessLogicModule;

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

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the business logic service class.
+ */
+export declare function generateBusinessLogicService({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBusinessLogicService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the business logic service class.
+ */
+function generateBusinessLogicService({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.businessLogic.serviceClassName],
+            from: meta.businessLogic.serviceFilePath,
+        });
+    }
+    const constructor = mm
+        .map(({ meta }) => `public ${meta.businessLogic.serviceVariableName} :${meta.businessLogic.serviceClassName}`)
+        .join(',\n');
+    return `
+import { Injectable } from '@nestjs/common'
+
+${imports.generate()}
+
+@Injectable()
+export class ${meta.businessLogic.serviceClassName} {
+  constructor(${constructor}) {}
+}
+`;
+}
+exports.generateBusinessLogicService = generateBusinessLogicService;

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

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataMockModule = void 0;
+const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const Types = __importStar(require("../../lib/schema/types"));
-const imports_1 = require("../../lib/imports");
 /**
  * Generates a mocking class
  */
@@ -51,7 +51,7 @@ function generateDataMockModule({ models, meta }) {
         imports.addImport({ items: [meta.data.mockRepositoryClassName], from: meta.data.mockRepoFilePath });
     }
     const providers = mm
-        .map(({ meta, model }) => `{ 
+        .map(({ meta }) => `{ 
           provide: ${meta.data.repositoryClassName},
           useFactory: async () => {
             const repository = new ${meta.data.mockRepositoryClassName}()

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

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataModule = void 0;
+const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const Types = __importStar(require("../../lib/schema/types"));
-const imports_1 = require("../../lib/imports");
 /**
  * Generates a data module class.
  */
@@ -47,6 +47,7 @@ function generateDataModule({ models, meta }) {
             from: meta.data.repoFilePath,
         });
     }
+    const moduleName = meta.data.moduleName;
     return `
 import { DynamicModule, Provider, Type } from '@nestjs/common'
 import { DbModule, DbService } from '@${meta.config.project}/db'
@@ -68,43 +69,43 @@ const createRepositoryProvider = <T extends AsyncInit>(t: Type<T>, loadData: boo
   },
 })
 
-export class DataModule {
+export class ${moduleName} {
   private static cachedModule: DynamicModule | undefined = undefined
 
   static isInstantiated(): boolean {
-    return !!DataModule.cachedModule
+    return !!${moduleName}.cachedModule
   }
 
-  static getInstance(): DataModule {
-    if (!DataModule.cachedModule) throw new Error('DataModule must be called via .provide first!')
-    return DataModule.cachedModule
+  static getInstance(): ${moduleName} {
+    if (!${moduleName}.cachedModule) throw new Error('${moduleName} must be called via .provide first!')
+    return ${moduleName}.cachedModule
   }
 
   static provide({ loadData }: { loadData: boolean }): DynamicModule {
-    if (DataModule.cachedModule) {
-      console.warn('DataModule is already instantiated, skipping...')
-      return DataModule.cachedModule
+    if (${moduleName}.cachedModule) {
+      console.warn('${moduleName} is already instantiated, skipping...')
+      return ${moduleName}.cachedModule
     }
 
-    const repositoryProviders: Provider<Repository<any, any>>[] = [
-      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',\n')}
-    ].map((r) => createRepositoryProvider(r as any, loadData))
+    const repositoryProviders = [
+      ${mm.map(({ meta }) => `createRepositoryProvider(${meta.data.repositoryClassName}, loadData)`).join(',\n')}
+    ]
 
-    DataModule.cachedModule = {
-      module: DataModule,
+    ${moduleName}.cachedModule = {
+      module: ${moduleName},
       global: true,
       imports: [DbModule.provide()],
       providers: [DataService, ...repositoryProviders],
       exports: [DataService, ...repositoryProviders],
     }
 
-    return DataModule.cachedModule
+    return ${moduleName}.cachedModule
   }
 
   static provideE2E(): DynamicModule {
-    if (DataModule.cachedModule) {
-      console.warn('DataModule is already instantiated, skipping...')
-      return DataModule.cachedModule
+    if (${moduleName}.cachedModule) {
+      console.warn('${moduleName} is already instantiated, skipping...')
+      return ${moduleName}.cachedModule
     }
 
     const providers: Provider<Repository<any, any>>[] = [
@@ -112,15 +113,15 @@ export class DataModule {
       TestDataService,
     ]
 
-    DataModule.cachedModule = {
-      module: DataModule,
+    ${moduleName}.cachedModule = {
+      module: ${moduleName},
       global: true,
       imports: [DbModule.provide()],
       providers: [...providers],
       exports: providers,
     }
 
-    return DataModule.cachedModule
+    return ${moduleName}.cachedModule
   }
 }
 `;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataService = void 0;
-const meta_1 = require("../../lib/meta");
 const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
 /**
  * Generates a generic data service object that may be used on the server to access database.
  */

package/dist/generators/indices/seed-template-decoder.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates a decoder for the Seed Excel template
+ */
+export declare function generateSeedTemplateDecoder({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedTemplateDecoder = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+const types_2 = require("../../lib/types");
+// TODO: Remove hardcoded path that seems to be reused in multiple places!
+const PXL_COMMON = (0, types_1.toPath)('@pxl/common');
+/**
+ * Creates a decoder for the Seed Excel template
+ */
+function generateSeedTemplateDecoder({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.seed.templateDecoderFilePath);
+    const decoders = [];
+    const tableDecoders = [];
+    const renameTransforms = [];
+    for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        decoders.push(generateTableDecoder({ model, meta: modelMeta, imports }));
+        tableDecoders.push(`${modelMeta.seed.excel.tableName}: z.array(${modelMeta.seed.decoder.schemaName})`);
+        renameTransforms.push(`${modelMeta.seed.decoder.dataName}: item['${modelMeta.seed.excel.tableName}']`);
+    }
+    return `
+  import * as z from 'zod'
+  
+  ${imports.generate()}
+  
+  ${decoders.join('\n')}
+
+  export const seedTemplateDecoder = z
+    .object({${tableDecoders.join(',\n')}})
+    .transform((item) => ({${renameTransforms.join(',\n')}}))
+  `;
+}
+exports.generateSeedTemplateDecoder = generateSeedTemplateDecoder;
+function generateTableDecoder({ model, meta, imports, }) {
+    const fieldDecoders = [];
+    const renameTransforms = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        renameTransforms.push(`${field.name}: item['${fieldMeta.excelColumnName}']`);
+        switch (field.kind) {
+            case 'id': {
+                imports.addImport({
+                    items: [meta.types.toBrandedIdTypeFnName],
+                    from: meta.types.importPath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.unbrandedTypeName,
+                    nullable: false,
+                    imports,
+                })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'scalar': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.typeName,
+                    nullable: !field.isRequired,
+                    imports,
+                })}`);
+                break;
+            }
+            case 'relation': {
+                const refModel = field.relationToModel;
+                const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+                imports.addImport({
+                    items: [refMeta.types.toBrandedIdTypeFnName],
+                    from: refMeta.types.importPath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.unbrandedTypeName,
+                    nullable: !field.isRequired,
+                    imports,
+                })}.transform((id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => ${field.isRequired ? '' : ' id === null ? null : '}${refMeta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'enum': {
+                const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
+                imports.addImport({
+                    items: [field.enumerator.typeName],
+                    from: refEnumMeta.types.importPath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([${field.enumerator.values.map((v) => `'${v}'`).join(', ')}])${field.isRequired ? '' : '.nullable()'}`);
+                break;
+            }
+            default: {
+                throw new types_2.ExhaustiveSwitchCheck(field);
+            }
+        }
+    }
+    return `  
+/**
+ * The schema for the ${model.name} table
+ */
+const ${meta.seed.decoder.schemaName} = z
+  .object({${fieldDecoders.join(',\n')}})
+  .transform((item) => ({${renameTransforms.join(',\n')}}))
+  
+/**
+ * The type of the ${model.name} table
+ */
+export type ${meta.seed.decoder.decoderTypeName} = z.infer<typeof ${meta.seed.decoder.schemaName}>
+
+export const ${meta.seed.decoder.decoderName} = z.array(${meta.seed.decoder.schemaName})
+`;
+}
+function toExcelDecoder({ typeName, nullable, imports, }) {
+    switch (typeName) {
+        case 'string': {
+            const decoder = (0, types_1.toFunction)(nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        case 'boolean':
+            imports.addImport({
+                items: [(0, types_1.toFunction)('excelBooleanDecoder')],
+                from: PXL_COMMON,
+            });
+            return 'excelBooleanDecoder';
+        case 'number':
+            return `z.number()${nullable ? '.nullable()' : ''}`;
+        case 'Date': {
+            const decoder = (0, types_1.toFunction)(nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        default:
+            throw new Error('Unknown type');
+    }
+}

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates an Excel template file that can be used to manage Seed data.
+ * The template file contains a sheet for each model, with the column for each field.
+ */
+export declare function generateSeedExcelTemplate({ models }: {
+    models: Model[];
+}): Promise<Buffer>;

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

@@ -0,0 +1,80 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedExcelTemplate = void 0;
+const Excel = __importStar(require("exceljs"));
+const meta_1 = require("../../lib/meta");
+/**
+ * Creates an Excel template file that can be used to manage Seed data.
+ * The template file contains a sheet for each model, with the column for each field.
+ */
+function generateSeedExcelTemplate({ models }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wb = initializeWorkbook();
+        for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
+            const meta = (0, meta_1.getModelMetadata)({ model });
+            addModel({ model, meta, wb });
+        }
+        const buffer = Buffer.from(yield wb.xlsx.writeBuffer());
+        return buffer;
+    });
+}
+exports.generateSeedExcelTemplate = generateSeedExcelTemplate;
+function initializeWorkbook() {
+    const wb = new Excel.Workbook();
+    wb.creator = 'XLPort';
+    wb.lastModifiedBy = 'XLPort';
+    wb.created = new Date();
+    wb.modified = new Date();
+    return wb;
+}
+function addModel({ model, meta, wb }) {
+    const ws = wb.addWorksheet(model.name);
+    const table = ws.addTable({
+        name: meta.seed.excel.tableName,
+        ref: 'A1',
+        headerRow: true,
+        totalsRow: false,
+        style: {
+            theme: 'TableStyleMedium2',
+            showRowStripes: true,
+        },
+        columns: model.fields.map((field) => ({
+            name: (0, meta_1.getFieldMetadata)({ field }).excelColumnName,
+        })),
+        rows: [],
+    });
+    table.addRow(model.fields.map(() => null));
+    table.commit();
+}

package/dist/generators/models/businesslogic.generator.d.ts

@@ -0,0 +1,9 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates business logic for a given model.
+ */
+export declare function generateModelBusinessLogic({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;