@postxl/generator 0.74.1 → 1.0.1

package/dist/generators/indices/data/module.generator.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataModule = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-/**
- * Generates a data module class.
- */
-function generateDataModule({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.moduleLocation.path).addImports({
-        [meta.data.dataService.location.path]: [meta.data.dataService.class],
-        [meta.backendModules.db.databaseService.location.import]: [meta.backendModules.db.databaseService.name],
-        [meta.backendModules.db.moduleLocation.import]: [meta.backendModules.db.moduleName],
-    });
-    for (const { meta } of mm) {
-        imports.addImport({
-            items: [meta.data.repository.className],
-            from: meta.data.repository.location.path,
-        });
-    }
-    return /* ts */ `
-import { DynamicModule, FactoryProvider } from '@nestjs/common'  
-
-${imports.generate()}
-
-export class ${meta.data.moduleName} {
-  public static forRoot(): DynamicModule {
-    const userRepositoryProvider: FactoryProvider<UserRepository> = {
-      provide: UserRepository,
-      inject: [DatabaseService],
-      useFactory: async (dbService: DatabaseService) => {
-        const repository = new UserRepository(dbService)
-        await repository.init()
-        return repository
-      },
-    }
-
-    const providers = [
-      DataService,
-      
-      userRepositoryProvider,
-      
-      ${mm
-        .filter((mm) => mm.model.name !== 'User')
-        .map(({ meta }) => meta.data.repository.className)
-        .join(',')}
-    ]
-
-    return {
-      module: ${meta.data.moduleName},
-      global: true,
-      imports: [DatabaseModule],
-      providers,
-      exports: providers,
-    }
-  }
-}`;
-}
-exports.generateDataModule = generateDataModule;

package/dist/generators/indices/data/service.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../../lib/meta';
-import { Model } from '../../../lib/schema/schema';
-/**
- * Generates a generic data service object that may be used on the server to access database.
- */
-export declare function generateDataService({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/data/service.generator.js

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataService = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-const types_1 = require("../../../lib/schema/types");
-/**
- * Generates a generic data service object that may be used on the server to access database.
- */
-function generateDataService({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.dataService.location.path);
-    for (const { meta } of mm) {
-        imports.addImport({
-            items: [meta.data.repository.className],
-            from: meta.data.repository.location.path,
-        });
-    }
-    const constructor = mm
-        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repository.className}`)
-        .join(',\n');
-    const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
-    const excelExports = mm
-        .map(({ meta }) => `${meta.import.tableName}: Array.from((await this.${meta.data.dataServiceName}.getAll()).values()),`)
-        .join('\n');
-    const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
-    // Building blocks for bulk mutations
-    imports.addImports({
-        [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.create), (0, types_1.toAnnotatedTypeName)(meta.types.dto.update)],
-        [meta.data.repository.typeFilePath]: [(0, types_1.toAnnotatedTypeName)(meta.data.repository.typeName)],
-        [meta.data.types.location.import]: [(0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation)],
-        [meta.actions.execution.interfaceLocation.import]: [meta.actions.execution.interface],
-    });
-    const creates = [];
-    const updates = [];
-    const upserts = [];
-    const deletes = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.${modelMeta.data.dataServiceName}, execution })`);
-        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.${modelMeta.data.dataServiceName}, execution })`);
-        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.${modelMeta.data.dataServiceName}, execution })`);
-        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.${modelMeta.data.dataServiceName}, execution })`);
-    }
-    return /* ts */ `
-import { Injectable, Logger } from '@nestjs/common'
-
-import { format, pluralize } from '@postxl/runtime'
-
-${imports.generate()}
-
-// If true, the bulk mutation will be executed one by one, instead of all at once (which is the default).
-// Also, each item will be logged to the console.
-// This should help to quickly identify the item that causes an error in a bulk mutation.
-const DEBUG = false
-
-@Injectable()
-export class ${meta.data.dataService.class} {
-  private readonly logger = new Logger(${meta.data.dataService.class}.name)
-
-  constructor(${constructor}) {}
-
-  public async prepareExcelExport() {
-    return {
-      ${excelExports}
-    }
-  }
-
-  public async init(): Promise<void> {
-    ${initializer}
-  }
-
-  public async isEmpty(): Promise<boolean> {
-    return (
-      ${isEmptyChecks}
-    )
-  }
-  public async ${meta.data.dataService.executeBulkMutations}(
-    { steps, execution }: 
-    { steps: ${meta.data.types.bulkMutation}[]; execution: ${meta.actions.execution.interface} }
-  ) {
-    let index = 0
-    for (const step of steps) {
-      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
-      await this.${meta.data.dataService.executeBulkMutation}({ data: step, execution })
-    }
-  }
-
-  public async ${meta.data.dataService.executeBulkMutation}(
-    { data, execution }: 
-    { data: ${meta.data.types.bulkMutation}, execution: ${meta.actions.execution.interface}}
-  ) {
-    // 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.
-    // Alternatively, you can also do this in multiple steps
-    ${creates.join('\n')}
-
-    ${updates.join('\n')}
-
-    ${upserts.join('\n')}
-
-    ${deletes.join('\n')}
-  }
-
-  private async create<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: ${meta.types.dto.create}<T, ID>[] | undefined
-    repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.execution.interface}
-  }): Promise<void> {
-    if (!data || data.length === 0) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.createMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Creating \${name} \${i} - \${_getItemDescription(item)}\`)
-        try {
-          await repo.create?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error creating \${name} \${i} - \${_getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
-  }
-  
-  private async update<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: ${meta.types.dto.update}<T, ID>[] | undefined
-    repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.execution.interface}
-  }): Promise<void> {
-    if (!data || data.length === 0) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.updateMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Updating \${name} \${i} - \${_getItemDescription(item)}\`)
-        try {
-          await repo.update?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error updating \${name} \${i} - \${_getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Updated \${format(data.length)} \${pluralize(name)}\`)
-  }
-
-  private async upsert<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: (${meta.types.dto.create}<T, ID> | ${meta.types.dto.update}<T, ID>)[] | undefined
-    repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.execution.interface}
-  }): Promise<void> {
-    if (!data || data.length === 0) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.upsertMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Upserting \${name} \${i} - \${_getItemDescription(item)}\`)
-        try {
-          await repo.upsert?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error upserting \${name} \${i} - \${_getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Upserted \${format(data.length)} \${pluralize(name)}\`)
-  }
-
-  private async delete<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: ID[] | undefined
-    repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.execution.interface}
-  }): Promise<void> {
-    if (!data || data.length === 0) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.deleteMany?.({ ids: data, execution })
-    } else {
-      let i = 0
-      for (const id of data) {
-        i++
-        this.logger.log(\`Deleting \${name} \${i} - id: \${id.toString()}\`)
-        try {
-          await repo.delete?.({ id, execution })
-        } catch (error) {
-          this.logger.error(\`Error deleting \${name} \${i} - id: \${id.toString()}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Deleted \${format(data.length)} \${pluralize(name)}\`)
-  }
-}
-
-function _getItemDescription<T extends Partial<{ id: ID }>, ID extends number | string | boolean>(item: T): string {
-  const id = \`id: \${item.id !== undefined ? item.id.toString() : 'not provided'}\`
-
-  // If the item has a name, we can assume it is a string and add it to the description
-  if ('name' in item) {
-    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-    return \`\${id}, name: \${item.name}\`
-  }
-  return id
-}
-`;
-}
-exports.generateDataService = generateDataService;

package/dist/generators/indices/data/types.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../../lib/meta';
-import { Model } from '../../../lib/schema/schema';
-/**
- * Generates type for BulkMutations.
- */
-export declare function generateDataTypes({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/data/types.generator.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataTypes = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-/**
- * Generates type for BulkMutations.
- */
-function generateDataTypes({ models, meta }) {
-    const { types } = meta.data;
-    const imports = imports_1.ImportsGenerator.from(types.location.path);
-    const dto = meta.types.dto;
-    imports.addTypeImport({
-        from: meta.types.importPath,
-        items: [dto.create, dto.update, dto.upsert, dto.genericModel, dto.idType],
-    });
-    const modelTypes = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addTypeImport({
-            items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
-            from: modelMeta.types.importPath,
-        });
-        modelTypes.push(`${modelMeta.seed.constantName}?: ${types.bulkMutationForModel}<${modelMeta.types.typeName}, ${modelMeta.types.brandedIdType}>`);
-    }
-    return /* ts */ `
-${imports.generate()}
-
-/**
- * Generic type for BulkMutation for a model.
- */
-export type ${types.bulkMutationForModel}<
-  Model extends ${dto.genericModel}<ID>, 
-  ID extends ${dto.idType}
-> = {
-  create?: ${dto.create}<Model, ID>[]
-  update?: ${dto.update}<Model, ID>[]
-  upsert?: ${dto.upsert}<Model, ID>[]
-  delete?: ID[]
-}
-
-/**
- * Bulk changes for all models.
- */
-export type ${types.bulkMutation} = {
-  ${modelTypes.join('\n')}
-}`;
-}
-exports.generateDataTypes = generateDataTypes;

package/dist/generators/indices/dispatcher-service.generator.d.ts

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

package/dist/generators/indices/dispatcher-service.generator.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateActionsDispatcherService = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const types_1 = require("../../lib/schema/types");
-/**
- * Generates the action dispatcher service.
- */
-function generateActionsDispatcherService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcher.classLocation.path).addImports({
-        [meta.seed.serviceLocation.import]: [meta.seed.serviceClassName],
-        [meta.import.importService.location.import]: [meta.import.importService.name],
-        [meta.update.serviceLocation.import]: [meta.update.serviceClassName],
-        [meta.types.importPath]: (0, types_1.toAnnotatedTypeName)(meta.config.userType),
-        [meta.backendModules.db.databaseService.location.import]: [meta.backendModules.db.databaseService.name],
-        [meta.actions.execution.interfaceLocation.path]: [meta.actions.execution.interface],
-    });
-    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 /* ts */ `
-  import { Injectable } from '@nestjs/common'
-
-import { ExhaustiveSwitchCheck } from '@postxl/runtime'
-
-${imports.generate()}
-
-import { ActionExecutionFactory } from './execution/action'
-import { Action, ResultOfAction } from './actions.types'
-
-
-@Injectable()
-export class ${meta.actions.dispatcher.class} {
-  
-  // As SeedModule and ImportModule get instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
-  // we set the seedService and the importService to value and then overwrite it in the services' constructors.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-  public seedService: SeedService = {} as unknown as any
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-  public ${meta.import.importService.sharedName}: ImportService = {} as unknown as any
-
-  constructor(
-    private readonly updateService: ${meta.update.serviceClassName}, 
-    private readonly databaseService: DatabaseService,
-    private readonly actionExecutionFactory: ActionExecutionFactory,
-  ) {}
-
-  public async dispatch<A extends Action>({ action, user }: { 
-    action: A; 
-    user: ${meta.config.userType} 
-  }): Promise<ResultOfAction<A>> {
-    const execution = await this.actionExecutionFactory.create({ action, databaseService: this.databaseService, user })
-
-    try {
-      const result = await this.execute({ action, execution })
-
-      await execution.success(result)
-
-      return result
-    } catch (e) {
-      await execution.error(e)
-      throw e
-    }
-  }
-
-  private async execute<A extends Action>({
-    action,
-    execution,
-  }: {
-    action: A
-    execution: IActionExecution
-  }): Promise<ResultOfAction<A>> {
-    switch (action.scope) {
-      ${models
-        .map((model) => {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        return `
-        case '${modelMeta.update.scopeName}': {
-          const method = this.updateService.${modelMeta.update.serviceVariableName}[action.type] as (params: {
-            data: A['payload']
-            execution: IActionExecution
-          }) => Promise<ResultOfAction<A>>
-    
-          // NOTE: We need to bind the method to the service instance, as it is a method of the service and not a standalone function.
-          return method.bind(this.updateService.${modelMeta.update.serviceVariableName})({ data: action.payload, execution })
-        }
-        `;
-    })
-        .join('\n')}
-
-      case 'seed':
-        return this.seedService.dispatch({ action, execution }) as Promise<ResultOfAction<A>>
-      
-      case 'import':
-        return this.importService.dispatch({ action, execution }) as Promise<ResultOfAction<A>>
-      
-      default:
-        throw new ExhaustiveSwitchCheck(action)
-    }
-  }
-}
-  `;
-}
-exports.generateActionsDispatcherService = generateActionsDispatcherService;

package/dist/generators/indices/export/class.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../../lib/meta';
-import { Model } from '../../../lib/schema/schema';
-/**
- * Generates the Exporter class for the Export module
- */
-export declare function generateExporterClass({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

package/dist/generators/indices/export/class.generator.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateExporterClass = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-const types_1 = require("../../../lib/schema/types");
-/**
- * Generates the Exporter class for the Export module
- */
-function generateExporterClass({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.export.exporterClass.location.path);
-    imports.addImports({
-        [meta.view.serviceLocation.import]: [meta.view.serviceClassName],
-        [meta.export.encoder.location.path]: [
-            meta.export.encoder.fullEncoderFunctionName,
-            (0, types_1.toAnnotatedTypeName)(meta.export.encoder.encodedExcelDataTypeName),
-        ],
-    });
-    const typeExports = [];
-    const typeExportsDataEntries = [];
-    const privateMaps = [];
-    const exportDataProperties = [];
-    const addFunctions = [];
-    const addAllCalls = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addTypeImport({
-            from: modelMeta.types.importPath,
-            items: [modelMeta.types.brandedIdType, modelMeta.types.typeName],
-        });
-        typeExports.push(`export type ${modelMeta.export.exportDataTypeName} = CapitalizedKeys<${model.name}>`);
-        typeExportsDataEntries.push(`${modelMeta.export.exportDataPropertyName}?: ${modelMeta.export.exportDataTypeName}[]`);
-        privateMaps.push(`private ${modelMeta.internalPluralName} = new Map<${modelMeta.types.brandedIdType}, ${modelMeta.types.typeName}>()`);
-        exportDataProperties.push(`${modelMeta.export.exportDataFullPropertyName}: Array.from(this.${modelMeta.internalPluralName}.values())`);
-        const linkedItems = [];
-        for (const field of model.fields) {
-            if (field.kind !== 'relation') {
-                continue;
-            }
-            const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
-            if (field.isRequired) {
-                linkedItems.push(`await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false, user})`);
-            }
-            else {
-                linkedItems.push(`
-          if (item.${field.name}) { 
-            await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false, user})
-          }`);
-            }
-        }
-        const childItemCalls = [];
-        for (const { referencingField, referencingModel } of model.references) {
-            const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
-            const linkedFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
-            childItemCalls.push(`
-        // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${referencingField.name}
-        for (const ${referencingField.name} of await this.viewService.${linkedModelMeta.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
-          await this.${linkedModelMeta.export.exportAddFunctionName}({id: ${referencingField.name}, includeChildren, user})
-        }
-        `);
-        }
-        const childItems = childItemCalls.length > 0
-            ? `
-          if (includeChildren) {
-            ${childItemCalls.join('\n')}
-          }`
-            : '';
-        const signature = `{id, includeChildren = true, user}: {id: ${model.brandedIdType}, includeChildren?: boolean, user: User}`;
-        addFunctions.push(`
-        /**
-         * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
-         */
-        public async ${modelMeta.export.exportAddFunctionName}(${signature}) {
-          if (this.${modelMeta.internalPluralName}.has(id)) {
-            return
-          }
-          const item = await this.viewService.${modelMeta.view.serviceVariableName}.get({ id, user })
-          if (!item) {
-            this.logger.error(\`Cannot find ${modelMeta.userFriendlyName} \${id}\`)
-            return
-          }
-          this.${modelMeta.internalPluralName}.set(id, item)
-      
-          ${linkedItems.join('\n')}
-
-          ${childItems}
-        }
-      `);
-        addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.view.serviceVariableName}.getAll(user)`);
-    }
-    return /* ts */ `
-// For consistency, we include \`{ includeChildren = true }\` in the signature of every add function.
-// If the model does not have any related models, the \`includeChildren\` parameter is ignored.
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import { Logger } from '@nestjs/common'
-
-${imports.generate()}
-
-/**
- * Exporter helps to export data items and all their (nested) dependencies to Excel format.
- * 
- * Usage:
- *  - Create an instance of the Exporter
- *  - Call the \`add{ModelName}({id})\` methods to add the items you want to export.
- *      This will automatically add all dependencies of the item.
- *  - Call the \`exportData()\` method to get the encoded Excel data.
- *  - Alternatively, you can call 'exportAll()' to dump all data. 
- */
-export class ${meta.export.exporterClass.name} {
-  private logger = new Logger(Exporter.name)
-
-  ${privateMaps.join('\n  ')}
-
-  constructor(private readonly viewService: ViewService) {}
-
-  /**
-   * Exports all data that was added by prior calls to \`.add{Model}\` functions.
-   */
-  public exportData(): ${meta.export.encoder.encodedExcelDataTypeName} {
-    return ${meta.export.encoder.fullEncoderFunctionName}({
-      ${exportDataProperties.join(',\n      ')}
-    })
-  }
-
-  /**
-   * Exports all data.
-   */
-  public async exportAll(user: User): Promise<${meta.export.encoder.encodedExcelDataTypeName}> {
-    ${addAllCalls.join('\n')}
-
-    return this.exportData()
-  }
-
-  ${addFunctions.join('\n\n')}
-}
-
-`;
-}
-exports.generateExporterClass = generateExporterClass;

package/dist/generators/indices/export/encoder.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../../lib/meta';
-import { Model } from '../../../lib/schema/schema';
-/**
- * Generates the data encoder, aggregating all the models.
- */
-export declare function generateExportEncoder({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;