@postxl/generator 0.34.0 → 0.36.0

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

@@ -1,152 +1,356 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSeedService = void 0;
-const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 /**
  * Generates index file for all seed files.
  */
-function generateSeedService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seed.serviceFilePath).addImport({
-        from: meta.seed.templateDecoderFilePath,
-        items: [meta.seed.templateDecoderName],
-    });
-    const dataLoader = [];
+function generateSeedService({ models }) {
+    const creates = [];
+    const updates = [];
+    const upserts = [];
+    const deletes = [];
     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 })`);
+        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
+        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
     }
     return `
-  import { Injectable, Logger } from '@nestjs/common'
-  import { format, pluralize } from '@pxl/common'
-  import { DataService, Repository } from '@pxl/data'
-  import { DbService } from '@pxl/db'
-  import { XlPortService } from '@pxl/xlport'
-  ${imports.generate()}
-
-  import * as SEEDDATA from './data'
-  
+import { Injectable, Logger } from '@nestjs/common'
+import { ExhaustiveSwitchCheck, format, pluralize } from '@pxl/common'
+import { DataService, Repository } from '@pxl/data'
+import { DbService } from '@pxl/db'
+import { XlPortService } from '@pxl/xlport'
+
+import { ActionExecution, DispatcherService } from '@pxl/actions'
+import { RootUserService } from '@pxl/root-user'
+
+import {
+  ActionPreparation_Seed,
+  ActionPreparation_Seed_Excel,
+  Action_Seed,
+  Action_Seed_CustomLogic,
+  Action_Seed_Excel,
+  createActionSeedExcel,
+} from './action.types'
+import { SeedData } from './seed-data.type'
+import { CreateDTO, UpdateDTO } from '@pxl/types'
+import { SEED_MIGRATIONS } from '@pxl/seed-data'
+
+// If true, the seed data will be created/updated 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 operation.
+const DEBUG = false
+
+@Injectable()
+export class SeedService {
+  private readonly logger = new Logger(SeedService.name)
+
+  constructor(
+    private readonly dataService: DataService,
+    private readonly xlPortService: XlPortService,
+    private readonly dbService: DbService,
+    private readonly dispatcherService: DispatcherService,
+    private readonly rootUserService: RootUserService,
+  ) {
+    dispatcherService.seedService = this
+  }
+
   /**
-   * Configuration options for seeding
+   * To be called on application startup. Will validate the seed data migrations and execute any pending migrations.
+   *
+   * Each migration is an action, i.e. will be dispatched via the default dispatcher service and logged like any other action.
    */
-  export type SeedServiceOptions = {
-    /**
-     * If true, the database will be emptied before seeding.
-     * This is only possible if the database is set to test database!
-     */
-    reset?: boolean
-    /**
-     * If true, the seed data will be logged to the console.
-     * Note: This is significantly slower - but can be useful for debugging.
-     */
-    log?: boolean
+  public async seed() {
+    this.verifyIntegrity()
+
+    let executed = 0
+    for (const migration of SEED_MIGRATIONS) {
+      // Skip any migrations that have already been executed
+      const migrationExists = await this.dbService.action.findFirst({
+        where: { migrationOrder: migration.order, status: 'Success' },
+      })
+      if (migrationExists) {
+        continue
+      }
+
+      const action = await this.convertToAction(migration)
+
+      this.logger.log(\`Executing seed migration \${migration.order} - \${migration.name}\`)
+      await this.dispatcherService.dispatch({ action, user: this.rootUserService.rootUser })
+
+      executed++
+    }
+
+    if (executed === 0) {
+      if (SEED_MIGRATIONS.length > 0) {
+        this.logger.log(\`✅ All \${format(SEED_MIGRATIONS.length)} seed migrations have already been applied executed\`)
+      } else {
+        this.logger.log(\`No seed migrations found.\`)
+      }
+    } else {
+      if (executed === SEED_MIGRATIONS.length) {
+        this.logger.log(\`✅ Executed all \${format(executed)} seed migrations\`)
+      } else {
+        this.logger.log(
+          \`✅ Executed \${format(executed)} seed migrations, skipped \${format(SEED_MIGRATIONS.length - executed)} previous migrations\`,
+        )
+      }
+    }
   }
 
-  const DEFAULTOPTIONS: SeedServiceOptions = { reset: false, log: false }
-  @Injectable()
-  export class SeedService {
-    private readonly logger = new Logger(SeedService.name)
-    constructor(
-      private readonly dataService: DataService,
-      private readonly xlPortService: XlPortService,
-      private dbService: DbService,
-    ) {}
-    /**
-     * Seeds the database with the given data. Any data not provided will be taken from the default seed data.
-     */
-    public async seed({ data, options = DEFAULTOPTIONS }: { data?: Partial<typeof SEEDDATA>; options?: SeedServiceOptions }) {
-      return this._seed({ data: { ...SEEDDATA, ...data }, options })
+  private async convertToAction(migration: ActionPreparation_Seed): Promise<Action_Seed> {
+    switch (migration.type) {
+      case 'data':
+        return migration
+      case 'excel':
+        return await this.convertExcelToAction(migration)
+      case 'custom':
+        return migration
+      default:
+        throw new ExhaustiveSwitchCheck(migration)
     }
-  
-    /**
-     * Seeds the database with the given data from an Excel file.
-     */
-    public async seedFromExcel({
-      templatePath = './template.xlsx',
-      options = DEFAULTOPTIONS,
-    }: {
-      templatePath?: string
-      options?: SeedServiceOptions
-    }) {
-      const xlData = this.xlPortService.importFromFile(templatePath)
-  
-      const dataParsed = ${meta.seed.templateDecoderName}.safeParse(xlData)
-      if (!dataParsed.success) {
-        throw new Error(\`Error in parsing Excel seed data: \${JSON.stringify(dataParsed.error.message)}\`)
+  }
+
+  /**
+   * Will be call by the dispatcher service to dispatch the given action.
+   */
+  public async dispatch({ action, execution }: { action: Action_Seed; execution: ActionExecution }) {
+    switch (action.type) {
+      case 'data':
+        return this.uploadDataSteps({ steps: action.payload, execution })
+      case 'excel':
+        return this.uploadData({ data: action.payload.data, execution })
+      case 'custom':
+        return this.handleCustomLogic({ action, execution })
+
+      default:
+        throw new ExhaustiveSwitchCheck(action)
+    }
+  }
+
+  /**
+   * Checks if the order of the migrations is correct and if there are any missing migrations.
+   */
+  private verifyIntegrity() {
+    let startOrder = 0
+    for (const { name, order } of SEED_MIGRATIONS) {
+      if (order <= startOrder) {
+        throw new Error(
+          \`Invalid migration order. The order of migration "\${name}" must be after \${startOrder} but is \${order}. Is the order field correct and the order in the SEED_MIGRATIONS array correct?\`,
+        )
       }
-      return this._seed({ data: dataParsed.data, options })
+      startOrder = order
     }
-  
-    private async _seed({ data, options: { reset, log } }: { data: typeof SEEDDATA; options: SeedServiceOptions }) {
-      if (reset) {
-        this.logger.log('Resetting database')
-        await this.dbService.emptyDatabase()
-      } else {
-        const config = await this.dbService.config.findFirst({ where: { id: true } })
-        if (!config) {
-          throw new Error('Database is not initialized')
-        }
-        if (config.isSeeded) {
-          this.logger.log('Database is already seeded')
-          return
+  }
+
+  /**
+   * Reads the Excel file and parses it using the provided decoder.
+   * If the parsing is successful, the data is packaged into an Action_Seed_Excel.
+   */
+  private async convertExcelToAction({
+    name,
+    order,
+    filename,
+    decoder,
+  }: ActionPreparation_Seed_Excel): Promise<Action_Seed_Excel> {
+    const xlData = await this.xlPortService.importFromFile(filename)
+    if (xlData.status === 'error') {
+      this.logger.error(xlData.message)
+      throw new Error(\`Error importing Excel data\`)
+    }
+
+    const dataParsed = decoder.safeParse(xlData.data.tables)
+    if (!dataParsed.success) {
+      this.logger.error(dataParsed.error.message)
+      throw new Error(\`Error parsing Excel seed data\`)
+    }
+
+    return createActionSeedExcel({ name, order, filename, data: dataParsed.data })
+  }
+
+  /**
+   * Executes the custom logic of the given migration.
+   * To do this, we retrieve the handler from the migration and call it, injecting the data service into the handler.
+   */
+  private handleCustomLogic({ action, execution }: { action: Action_Seed_CustomLogic; execution: ActionExecution }) {
+    const actionPreparation = SEED_MIGRATIONS.find((m) => m.order === action.order)
+    if (!actionPreparation) {
+      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
+    }
+    if (actionPreparation.type !== 'custom') {
+      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
+    }
+    return actionPreparation.handler({ action, data: this.dataService, execution })
+  }
+  /**
+   * Executes the data loading step by step
+   */
+  private async uploadDataSteps({ steps, execution }: { steps: SeedData[]; execution: ActionExecution }) {
+    let index = 0
+    for (const step of steps) {
+      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
+      await this.uploadData({ data: step, execution })
+    }
+  }
+
+  private async uploadData({ data, execution }: { data: SeedData; execution: ActionExecution }) {
+    // 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: CreateDTO<T, ID>[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): Promise<void> {
+    if (!data) {
+      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
         }
       }
-  
-      await this.uploadData({ data, log })
-  
-      await this.dbService.config.update({
-        where: { id: true },
-        data: { isSeeded: true },
-      })
-  
-      this.logger.log('✅ Done')
     }
+    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
+  }
   
-    private async uploadData({ log = false, data }: { data: typeof SEEDDATA; log?: boolean }) {
-      // 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.
-      ${dataLoader.join('\n')}
+  private async update<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: UpdateDTO<T, ID>[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): Promise<void> {
+    if (!data) {
+      return
     }
-  
-    private async upload<T extends { id: ID }, ID extends number | string | boolean>({
-      name,
-      data,
-      repo,
-      log = false,
-      onlyOnReset = true,
-    }: {
-      name: string
-      data: T[]
-      repo: Repository<T, ID>
-      log?: boolean
-      onlyOnReset?: boolean
-    }): Promise<void> {
-      if (repo.count() > 0 && onlyOnReset) {
-        this.logger.log(\`\${pluralize(name)} already exist, skipping\`)
-        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
+        }
       }
-      if (!log) {
-        await repo.createMany(data)
-      } else {
-        let i = 0
-        for (const item of data) {
-          i++
-          console.log(name, i, item.id)
-          try {
-            await repo.create?.(item)
-          } catch (error) {
-            console.log(item)
-            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: (CreateDTO<T, ID> | UpdateDTO<T, ID>)[] | undefined
+    repo: Repository<T, ID>
+    execution: ActionExecution
+  }): Promise<void> {
+    if (!data) {
+      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(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
     }
-  } 
-  `;
+    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: Repository<T, ID>
+    execution: ActionExecution
+  }): Promise<void> {
+    if (!data) {
+      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.generateSeedService = generateSeedService;

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

@@ -5,20 +5,21 @@ 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");
+const string_1 = require("../../lib/utils/string");
 // 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 imports = imports_1.ImportsGenerator.from(meta.seedData.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})`);
+        tableDecoders.push(`${modelMeta.seed.excel.tableName}: ${modelMeta.seed.decoder.decoderName}`);
         renameTransforms.push(`${modelMeta.seed.decoder.dataName}: item['${modelMeta.seed.excel.tableName}']`);
     }
     return `
@@ -26,9 +27,14 @@ function generateSeedTemplateDecoder({ models, meta }) {
   
   ${imports.generate()}
   
+  /**
+   * Helper schema to identify blank Excel cells
+   */
+  const nullOrBlankSchema = z.union([z.null(), z.literal('')])
+
   ${decoders.join('\n')}
 
-  export const ${meta.seed.templateDecoderName} = z
+  export const ${meta.seedData.templateDecoderName} = z
     .object({${tableDecoders.join(',\n')}})
     .transform((item) => ({${renameTransforms.join(',\n')}}))
   `;
@@ -36,10 +42,12 @@ function generateSeedTemplateDecoder({ models, meta }) {
 exports.generateSeedTemplateDecoder = generateSeedTemplateDecoder;
 function generateTableDecoder({ model, meta, imports, }) {
     const fieldDecoders = [];
+    const blankFieldDecoders = [];
     const renameTransforms = [];
     for (const field of model.fields) {
         const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
         renameTransforms.push(`${field.name}: item['${fieldMeta.excelColumnName}']`);
+        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: nullOrBlankSchema`);
         switch (field.kind) {
             case 'id': {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
@@ -81,6 +89,7 @@ function generateTableDecoder({ model, meta, imports, }) {
             }
         }
     }
+    const blankSchemaName = `blank${(0, string_1.capitalize)(meta.seed.decoder.schemaName)}`;
     return `  
 /**
  * The schema for the ${model.name} table
@@ -88,13 +97,20 @@ function generateTableDecoder({ model, meta, imports, }) {
 const ${meta.seed.decoder.schemaName} = z
   .object({${fieldDecoders.join(',\n')}})
   .transform((item) => ({${renameTransforms.join(',\n')}}))
-  
-/**
+
+/** The schema to identify blank rows in the ${model.name} table */
+const ${blankSchemaName} = z
+  .object({${blankFieldDecoders.join(',\n')}})
+  .transform(() => undefined)
+
+  /**
  * 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})
+export const ${meta.seed.decoder.decoderName} = z
+  .array(${meta.seed.decoder.schemaName}.or(${blankSchemaName}))
+  .transform((items) => items.filter(Boolean) as ${meta.seed.decoder.decoderTypeName}[])
 `;
 }
 function toExcelDecoder({ tsTypeName, dbTypeName: typeName, nullable, imports, }) {

package/dist/generators/indices/{seed.generator.d.ts → seeddata-type.generator.d.ts}

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

package/dist/generators/indices/seeddata-type.generator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedDataType = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+/**
+ * Generates a type for all SeedData.
+ */
+function generateSeedDataType({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.types.importPath);
+    imports.addImport({ from: meta.data.importPath, items: [(0, types_1.toClassName)('MockData')] });
+    const modelTypes = [];
+    const mockConverters = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            items: [modelMeta.types.dto.create, modelMeta.types.dto.update, modelMeta.types.dto.upsert],
+            from: modelMeta.types.importPath,
+        });
+        modelTypes.push(`${modelMeta.seed.constantName}?: {
+      create?: ${modelMeta.types.dto.create}[]
+      update?: ${modelMeta.types.dto.update}[]
+      upsert?: ${modelMeta.types.dto.upsert}[]
+      delete?: string[]
+    }`);
+        mockConverters.push(`${modelMeta.seed.constantName}: { create: data.${modelMeta.seed.constantName} }`);
+    }
+    return `
+${imports.generate()}
+
+export type SeedData = {
+  ${modelTypes.join('\n')}
+}
+
+export function mockDataToCreate(data: MockData): SeedData {
+  return {
+    ${mockConverters.join(',\n')}
+  }
+}`;
+}
+exports.generateSeedDataType = generateSeedDataType;

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

@@ -3,7 +3,7 @@ import { Enum, Model } from '../../lib/schema/schema';
 /**
  * Generates an index file that exports all types.
  */
-export declare function generateTypesIndex({ models, enums, meta, }: {
+export declare function generateTypesIndex({ models, enums, meta: schemaMeta, }: {
     models: Model[];
     enums: Enum[];
     meta: SchemaMetaData;

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

@@ -6,16 +6,18 @@ const meta_1 = require("../../lib/meta");
 /**
  * Generates an index file that exports all types.
  */
-function generateTypesIndex({ models, enums, meta, }) {
-    const exports = exports_1.ExportsGenerator.from(meta.types.indexFilePath);
+function generateTypesIndex({ models, enums, meta: schemaMeta, }) {
+    const exports = exports_1.ExportsGenerator.from(schemaMeta.types.indexFilePath);
     for (const model of models) {
-        const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.types.filePath);
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(modelMeta.types.filePath);
     }
     for (const enumerator of enums) {
-        const meta = (0, meta_1.getEnumMetadata)({ enumerator });
-        exports.exportEverythingFromPath(meta.types.filePath);
+        const enumMeta = (0, meta_1.getEnumMetadata)({ enumerator });
+        exports.exportEverythingFromPath(enumMeta.types.filePath);
     }
+    // dto.types contains generic types that are used by all models
+    exports.exportEverythingFromPath(schemaMeta.types.dto.path);
     return exports.generate();
 }
 exports.generateTypesIndex = generateTypesIndex;

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

@@ -0,0 +1,10 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates update business logic for a given model.
+ * The update logic handles all Create/Update/Delete/Upsert operations. See template's readme for more info.
+ */
+export declare function generateModelBusinessLogicUpdate({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;