@postxl/generator 0.38.2 → 0.40.0

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportTypes = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates types for import export module.
+ */
+function generateImportExportTypes({ models, meta }) {
+    const { types } = meta.importExport;
+    const imports = imports_1.ImportsGenerator.from(types.filePath);
+    const dto = meta.types.dto;
+    imports.addImports({
+        [meta.types.importPath]: [dto.create, dto.update, dto.genericModel, dto.idType],
+        [meta.data.importPath]: [meta.data.types.bulkMutation],
+    });
+    const deltaTypes = [];
+    const errorTypes = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
+            from: modelMeta.types.importPath,
+        });
+        const missingFields = [];
+        const invalidReferenceFieldErrors = [];
+        const nonUniqueFieldErrors = [];
+        const invalidTypeFieldErrors = [];
+        const isRequiredDependencyErrors = [];
+        // Prepare field specific error types
+        for (const field of model.fields) {
+            if (field.attributes.ignore || field.kind === 'id') {
+                continue;
+            }
+            if (field.isRequired) {
+                missingFields.push(`"${field.name}"`);
+            }
+            if (field.kind === 'relation') {
+                invalidReferenceFieldErrors.push(`
+          ${types.delta_Model.errors.invalidReference.type}<"${field.relationToModel.name}", "${field.name}", ${field.relationToModel.brandedIdType}>
+        `);
+            }
+            if (field.kind === 'scalar' && field.isUnique) {
+                nonUniqueFieldErrors.push(`
+          ${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName}>
+        `);
+            }
+            if (field.kind === 'scalar' && field.validation) {
+                invalidTypeFieldErrors.push(`
+          ${types.delta_Model.errors.invalidType.type}<"${field.name}", "${field.schemaType}", ${field.tsTypeName}>
+        `);
+            }
+        }
+        // Prepare isRequiredDependency errors
+        for (const relatedModel of models) {
+            if (relatedModel.name === model.name) {
+                continue;
+            }
+            for (const relatedField of relatedModel.fields) {
+                if (relatedField.kind !== 'relation' ||
+                    relatedField.relationToModel.name !== model.name ||
+                    !relatedField.isRequired) {
+                    continue;
+                }
+                isRequiredDependencyErrors.push(`
+        ${types.delta_Model.errors.isRequiredDependency.type}<
+            '${relatedModel.name}',
+            '${relatedField.name}',
+            ${relatedModel.typeName},
+            ${relatedModel.brandedIdType}
+          >
+        `);
+            }
+        }
+        const missingFieldError = missingFields.length > 0
+            ? `${types.delta_Model.errors.missingField.type}<${missingFields.join(' | ')}> `
+            : undefined;
+        const modelErrorTypes = [
+            missingFieldError,
+            ...invalidReferenceFieldErrors,
+            ...nonUniqueFieldErrors,
+            ...invalidTypeFieldErrors,
+            ...isRequiredDependencyErrors,
+        ].filter((t) => t !== undefined);
+        if (modelErrorTypes.length === 0) {
+            modelErrorTypes.push(`never`);
+        }
+        errorTypes.push(`export type ${modelMeta.importExport.delta_Model_Errors} = ${modelErrorTypes.join('\n| ')}`);
+        deltaTypes.push(`${modelMeta.seed.constantName}?: ${types.delta_Model.type}<
+        ${modelMeta.types.typeName}, 
+        ${modelMeta.types.brandedIdType},
+        ${modelMeta.importExport.delta_Model_Errors}
+      >[]`);
+    }
+    return /* ts */ `
+${imports.generate()}
+
+/**
+ * Generic type that contains all changes between an existing item and an updated item.
+ */
+export type ${types.delta_Fields}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = Partial<{
+  [K in keyof Omit<Model, 'id'>]?: { old: Model[K]; new: Model[K] }
+}>
+
+/**
+ * For a given imported item of a model, this type contains the determined action to take - create, update, delete or unchanged.
+ */
+export type ${types.delta_Model.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}, ModelErrors> =
+  | ${types.delta_Model.unchanged.type}<Model, ID>
+  | ${types.delta_Model.create.type}<Model, ID>
+  | ${types.delta_Model.update.type}<Model, ID>
+  | ${types.delta_Model.delete.type}<Model, ID>
+  | ${types.delta_Model.errors.type}<Model, ID, ModelErrors>
+
+export type ${types.delta_Model.unchanged.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.unchanged.discriminant}'
+  input: Model
+}
+
+export function ${types.delta_Model.unchanged.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.unchanged.type}<Model, ID> {
+  return delta.type === 'unchanged'
+}
+
+export type ${types.delta_Model.create.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.create.discriminant}'
+  input: Model
+  createDTO: ${dto.create}<Model, ID>
+}
+
+export function ${types.delta_Model.create.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.create.type}<Model, ID> {
+  return delta.type === 'create'
+}
+
+export type ${types.delta_Model.update.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.update.discriminant}'
+  input: Model
+  updateDTO: ${dto.update}<Model, ID>
+  delta: ${types.delta_Fields}<Model, ID>
+}
+
+export function ${types.delta_Model.update.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.update.type}<Model, ID> {
+  return delta.type === 'update'
+}
+
+export type ${types.delta_Model.delete.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.delete.discriminant}'
+  input: Model
+}
+
+export function ${types.delta_Model.delete.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.delete.type}<Model, ID> {
+  return delta.type === 'delete'
+}
+
+export type ${types.delta_Model.errors.type}<Model extends GenericModel<ID>, ID extends IDType, ModelErrors> = {
+  type: '${types.delta_Model.errors.discriminant}'
+  input: Model
+  errors: ModelErrors[]
+}
+
+export function ${types.delta_Model.errors.typeGuard}<Model extends GenericModel<ID>, ID extends IDType, ModelErrors>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.errors.type}<Model, ID, ModelErrors> {
+  return delta.type === 'errors'
+}
+
+export type ${types.delta_Model.errors.missingField.type}<FieldName extends string> = {
+  error: '${types.delta_Model.errors.missingField.discriminant}'
+  fieldName: FieldName
+}
+
+export type ${types.delta_Model.errors.invalidReference.type}<
+  RelatedModel extends string, FieldName extends string, Value
+  > = {
+  error: '${types.delta_Model.errors.invalidReference.discriminant}'
+  relatedModel: RelatedModel
+  fieldName: FieldName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.nonUnique.type}<FieldName extends string, Value> = {
+  error: '${types.delta_Model.errors.nonUnique.discriminant}'
+  fieldName: FieldName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.invalidType.type}<FieldName extends string, TypeName extends string, Value> = {
+  error: '${types.delta_Model.errors.invalidType.discriminant}'
+  fieldName: FieldName
+  typeExpected: TypeName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.isRequiredDependency.type}<
+    RelatedModelName extends string,
+    RelatedField extends string,
+    RelatedModel extends GenericModel<ID>,
+   ID extends IDType
+  > = { 
+  error: '${types.delta_Model.errors.isRequiredDependency.discriminant}'
+  relatedModel: RelatedModelName
+  relatedField: RelatedField
+  relatedItems: RelatedModel[]
+}
+
+${errorTypes.join('\n')}
+
+/**
+ * The delta of for all models.
+ */
+export type ${types.delta} = {
+  ${deltaTypes.join('\n')}
+}
+
+export type DataChanges = {
+  /**
+   * The delta of all models.
+   */
+  delta: ${types.delta}
+
+  /**
+   * The bulk mutations derived from the delta.
+   */
+  bulkMutations: ${meta.data.types.bulkMutation}[]
+}`;
+}
+exports.generateImportExportTypes = generateImportExportTypes;

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

@@ -8,12 +8,12 @@ const meta_1 = require("../../lib/meta");
  * Generates an index file that exports all repository stubs.
  */
 function generateRepositoriesIndex({ models, meta }) {
-    const exports = exports_1.ExportsGenerator.from(meta.data.repositoriesIndexFilePath);
+    const exports = exports_1.ExportsGenerator.from(meta.data.repository.indexFilePath);
     for (const model of models) {
         const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.data.repoFilePath);
+        exports.exportEverythingFromPath(meta.data.repository.filePath);
     }
-    exports.exportEverythingFromPath(meta.data.repositoriesConstFilePath);
+    exports.exportEverythingFromPath(meta.data.repository.constFilePath);
     return exports.generate();
 }
 exports.generateRepositoriesIndex = generateRepositoriesIndex;
@@ -22,18 +22,18 @@ exports.generateRepositoriesIndex = generateRepositoriesIndex;
  */
 function generateRepositoriesArray({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.repositoriesConstFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.data.repository.constFilePath);
     for (const { meta } of mm) {
         imports.addImport({
-            items: [meta.data.repositoryClassName],
-            from: meta.data.repoFilePath,
+            items: [meta.data.repository.className],
+            from: meta.data.repository.filePath,
         });
     }
-    return `  
+    return /* ts */ `  
     ${imports.generate()}
 
     export const repositories = [${models
-        .map((model) => (0, meta_1.getModelMetadata)({ model }).data.repositoryClassName)
+        .map((model) => (0, meta_1.getModelMetadata)({ model }).data.repository.className)
         .join(', ')}]`;
 }
 exports.generateRepositoriesArray = generateRepositoriesArray;

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

@@ -17,7 +17,7 @@ function generateSeedMigration({ models, meta }) {
         });
         modelTypes.push(`${modelMeta.seed.constantName}: { create: ${modelMeta.seed.constantName} }`);
     }
-    return `
+    return /* ts */ `
 import { createActionSeedData } from '${meta.seed.importPath}'
 ${imports.generate()}
 

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

@@ -62,7 +62,7 @@ function initializeWorkbook() {
 function addModel({ model, meta, wb }) {
     const ws = wb.addWorksheet(model.name);
     const table = ws.addTable({
-        name: meta.seed.excel.tableName,
+        name: meta.importExport.tableName,
         ref: 'A1',
         headerRow: true,
         totalsRow: false,

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

@@ -0,0 +1,7 @@
+/**
+ * Generates list of component selectors for Cypress tests.
+ *
+ * Note: This generator does not need the models or meta data passed in.
+ * Instead it uses the SelectorCollector singleton that already collected all ids during the generation process of the individual models.
+ */
+export declare function generateSelectors(): string;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSelectors = void 0;
+const id_collector_1 = require("../../lib/id-collector");
+/**
+ * List of ids that are not generated but hardcoded across the template.
+ */
+const HARDCODED_IDS = [
+    'indexPage-buttons-create',
+    'confirmationModal-buttons-confirm',
+    'confirmationModal-buttons-cancel',
+];
+/**
+ * Generates list of component selectors for Cypress tests.
+ *
+ * Note: This generator does not need the models or meta data passed in.
+ * Instead it uses the SelectorCollector singleton that already collected all ids during the generation process of the individual models.
+ */
+function generateSelectors() {
+    // SelectorCollector is a static singleton that collects all ids during the generation process. We flush it here to get all ids.
+    const collectedIds = id_collector_1.SelectorCollector.flush();
+    const object = {};
+    const ids = [...HARDCODED_IDS, ...collectedIds];
+    ids.sort();
+    ids.map((id) => {
+        addCypressSelectorToNestedObject({ object, id });
+    });
+    const selectors = JSON.stringify(object, null, 2);
+    return /* ts */ `
+  export const SELECTORS =
+  ${selectors}
+  `;
+}
+exports.generateSelectors = generateSelectors;
+/**
+ * Converts an id like `post-create-name` to a nested object like `{post: {create: {name: '[data-cy=post-create-name]'}}}`.
+ */
+function addCypressSelectorToNestedObject({ object, id, }) {
+    const keys = id.split('-');
+    extendObject(object, keys, `[data-cy=${id}]`);
+}
+/**
+ * Recursively traverses the keys and adds the value to the object in a nested way.
+ * E.g. `{object, keys: ['post', 'create', 'name'], value}` will extend `object` with `{post: {create: {name: value}}}`.
+ *
+ */
+function extendObject(object, keys, value) {
+    const key = keys.shift();
+    // no item left -> we are at the end of the recursion
+    if (!key) {
+        return;
+    }
+    // create the nested object if it does not exist yet
+    object[key] = object[key] || {};
+    // In case the object already has a value, we check if it is a string (and not a nested object).
+    // If it is a string, it we check if the value is the same as the new value. In this case is is a duplicate and hence fine.
+    // However, if it is a string and a different value, it means we have an inconsistent ID structure.
+    // E.g. this can happen when we have three entries: "post-create", "post-create-name", "post-create-description".
+    // In this case, the "post-create" entry will be a string - and we cannot nest `{name: ..., description: ...}` in it.
+    if (key in object && typeof object[key] === 'string') {
+        if (keys.length !== 0) {
+            throw new Error(`Key ${key} already exists with value: ${object[key]} but we are trying to nest ${keys.join('-')}`);
+        }
+        if (object[key] !== value) {
+            throw new Error(`Duplicate key ${key} with different values: ${object[key]} and ${value}`);
+        }
+        return;
+    }
+    // If there are still keys left, we recursively call this function with the nested object and the remaining keys.
+    if (keys.length !== 0) {
+        extendObject(object[key], keys, value);
+        return;
+    }
+    // If there are no keys left, we need to verify that the object might not already have a nested object.
+    // This can happen, e.g. when we have two entries: "post-create-name" and "post-create".
+    // In this case, the `post.create` entry will be a nested object`{name: ...}`.
+    // If we would set `post.create` to a string, we would lose the nested object.
+    if (key in object && typeof object[key] !== 'string' && Object.keys(object[key]).length !== 0) {
+        throw new Error(`Key ${key} already has nested object ${JSON.stringify(object[key])} but we are trying to set it to ${value}`);
+    }
+    object[key] = value;
+}

package/dist/generators/indices/{seed-template-decoder.generator.d.ts → testdata-service.generator.d.ts}

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestDataService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+/**
+ * Generates the TestDataService class.
+ */
+function generateTestDataService({ models, meta: schemaMeta, }) {
+    const imports = imports_1.ImportsGenerator.from(schemaMeta.data.testDataServiceFilePath);
+    imports.addImports({
+        [schemaMeta.actions.importPath]: [(0, types_1.toClassName)('ActionExecutionFactory')],
+        [schemaMeta.data.importPath]: [schemaMeta.data.dataService.class, schemaMeta.data.dataMockDataType],
+        [schemaMeta.importExport.importPath]: [schemaMeta.importExport.converterFunctions.mockDataToBulkMutations],
+        [schemaMeta.seed.importPath]: [(0, types_1.toClassName)('createActionSeedData')],
+    });
+    const reInitCalls = [];
+    const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    for (const { model, meta } of modelMetas) {
+        if (model.defaultField) {
+            imports.addImport({ items: [meta.data.stubGenerationFnName], from: meta.data.importPath });
+            const stubDefault = `${meta.data.stubGenerationFnName}({ ${model.defaultField.name}: true })`;
+            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [${stubDefault}], execution: actionExecution })`);
+        }
+        else {
+            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [], execution: actionExecution })`);
+        }
+    }
+    return /* ts */ `
+import { Injectable, Logger } from '@nestjs/common'
+
+import { DbService } from '@pxl/db'
+${imports.generate()}
+
+@Injectable()
+export class TestDataService {
+  private logger = new Logger(TestDataService.name)
+
+  constructor(
+    private db: DbService,
+    private dataService: ${schemaMeta.data.dataService.class},
+    private actionExecutionFactory: ActionExecutionFactory,
+  ) {}
+
+  public async resetTestData(data: MockData) {
+    await this.db.emptyDatabase()
+
+    // We need to init the user repository first so the root user is created
+    await this.dataService.users.init()
+
+    const mockData = ${schemaMeta.importExport.converterFunctions.mockDataToBulkMutations}(data)
+    const action = createActionSeedData({ name: 'E2E', order: 0, data: [] })
+    const actionExecution = await this.actionExecutionFactory.create({
+      action,
+      dbService: this.db,
+      user: this.dataService.users.rootUser,
+    })
+    try {
+      ${reInitCalls.join('\n')}
+      
+      await actionExecution.success()
+      this.logger.log(\`✅ Reset test data\`)
+    } catch (e) {
+      await actionExecution.error(e)
+      throw e
+    }
+  }
+}`;
+}
+exports.generateTestDataService = generateTestDataService;

package/dist/generators/models/businesslogic-update.generator.js

@@ -13,12 +13,12 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repositoryClassName,
-        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecutionInterface,
+        [meta.data.importPath]: meta.data.repository.className,
+        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecution.interface,
         [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
         [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repositoryClassName],
+        [meta.data.importPath]: [meta.data.repository.className],
     });
     /**
      * The name of the variable that holds the repository instance for the current model
@@ -36,12 +36,12 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const actionBlocks = generateActionsBuildingBlocks({ model, meta });
     imports.addImport({ from: meta.types.importPath, items: actionBlocks.importTypes });
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly ${updateServiceClassName}: ${schemaMeta.businessLogic.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
-    return `
+    return /* ts */ `
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { ExhaustiveSwitchCheck } from '@pxl/common'
 
@@ -145,7 +145,7 @@ function generateActionsBuildingBlocks({ model, meta }) {
         dispatcher: `
       public async dispatch<A extends Action_${meta.businessLogic.update.actionNameModelPart}>({ action, execution }: {
         action: A; 
-        execution: ${schemaMeta.actions.actionExecutionInterface} 
+        execution: ${schemaMeta.actions.actionExecution.interface} 
       }) {
         switch (action.type) {
           ${dispatcher.join('\n')}

package/dist/generators/models/businesslogic-view.generator.js

@@ -13,10 +13,10 @@ function generateModelBusinessLogicView({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repositoryClassName,
+        [meta.data.importPath]: meta.data.repository.className,
         [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repositoryClassName],
+        [meta.data.importPath]: [meta.data.repository.className],
     });
     /**
      * The name of the variable that holds the repository instance for the current model
@@ -31,7 +31,7 @@ function generateModelBusinessLogicView({ model, meta }) {
      */
     const viewServiceClassName = 'viewService';
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     /**
@@ -92,7 +92,7 @@ function generateModelBusinessLogicView({ model, meta }) {
       return item
     }
   `;
-    return `
+    return /* ts */ `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { FilterOperator } from '@pxl/common'

package/dist/generators/models/importexport-decoder.generator.d.ts

@@ -0,0 +1,23 @@
+import { ModelMetaData, SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates a decoder for the Seed Excel template.
+ */
+export declare function generateModelImportExportDecoder({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+export declare function generateImportExportDecoder({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;
+/**
+ * Generates the index file for all the routes.
+ */
+export declare function generateImportExportDecoderIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;