@postxl/generator 0.74.1 → 1.0.1

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

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportTypes = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-/**
- * Generates types for import module.
- */
-function generateImportTypes({ models, meta }) {
-    const { types } = meta.import;
-    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.genericModel, dto.idType],
-    })
-        .addTypeImport({
-        from: meta.data.types.location.import,
-        items: [meta.data.types.bulkMutation],
-    });
-    const deltaTypes = [];
-    const errorTypes = [];
-    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,
-        });
-        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) {
-                if (field.isRequired) {
-                    nonUniqueFieldErrors.push(`${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName}>`);
-                }
-                else {
-                    nonUniqueFieldErrors.push(`${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName} | null>`);
-                }
-            }
-            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.import.delta_Model_Errors} = ${modelErrorTypes.join('\n| ')}`);
-        deltaTypes.push(`${modelMeta.seed.constantName}?: ${types.delta_Model.type}<
-        ${modelMeta.types.typeName}, 
-        ${modelMeta.types.brandedIdType},
-        ${modelMeta.import.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.generateImportTypes = generateImportTypes;

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

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates a an array that contains all the repositories.
- */
-export declare function generateRepositoriesArray({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRepositoriesArray = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates a an array that contains all the repositories.
- */
-function generateRepositoriesArray({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.repository.constFilePath);
-    for (const { meta } of mm) {
-        imports.addImport({
-            items: [meta.data.repository.className],
-            from: meta.data.repository.location.path,
-        });
-    }
-    return /* ts */ `  
-    ${imports.generate()}
-
-    export const repositories = [${models
-        .map((model) => (0, meta_1.getModelMetadata)({ model }).data.repository.className)
-        .join(', ')}]`;
-}
-exports.generateRepositoriesArray = generateRepositoriesArray;

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

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

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

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRoutesIndex = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates the index file for all the routes.
- */
-function generateRoutesIndex({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.trpc.routesFilePath);
-    for (const { meta } of mm) {
-        imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
-    }
-    return /* ts */ `
-      ${imports.generate()}
-
-      import { viewer } from './viewer.router'
-  
-      /**
-       * Object with all generated routes.
-       */
-      export const routes = {
-        viewer,
-        ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
-      }
-    `;
-}
-exports.generateRoutesIndex = generateRoutesIndex;

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

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates the initial migration based on the generated seed data.
- */
-export declare function generateSeedMigration({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSeedMigration = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const types_1 = require("../../lib/schema/types");
-/**
- * Generates the initial migration based on the generated seed data.
- */
-function generateSeedMigration({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seedData.initialMigrationLocation.path);
-    const modelTypes = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addImports({
-            [modelMeta.seed.location.path]: [modelMeta.seed.constantName],
-            [meta.import.converterFunctions.location.import]: [meta.import.converterFunctions.importedDataToBulkMutations],
-            [meta.seed.actionsLocation.import]: [(0, types_1.toTypeName)('Action_Seed_Data')],
-        });
-        modelTypes.push(`${modelMeta.seed.constantName}`);
-    }
-    return /* ts */ `
-${imports.generate()}
-
-export const MIGRATION_001_BASEDATA: Action_Seed_Data = {
-  scope: 'seed',
-  type: 'data',
-  name: 'Base data',
-  order: 1,
-  payload: ${meta.import.converterFunctions.importedDataToBulkMutations}({
-    ${modelTypes.join(',\n')}
-  }),
-}
-`;
-}
-exports.generateSeedMigration = generateSeedMigration;

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

@@ -1,9 +0,0 @@
-/// <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

@@ -1,80 +0,0 @@
-"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(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ models }) {
-        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.import.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/indices/testids.generator.d.ts

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

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

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTestIds = void 0;
-const test_id_collector_1 = require("../../lib/test-id-collector");
-/**
- * Generates list of test ids for E2E tests.
- *
- * Note: This generator does not need the models or meta data passed in.
- * Instead it uses the TestIdCollector singleton that already collected all ids during the generation process of the individual models.
- */
-function generateTestIds() {
-    // TestIdCollector is a static singleton that collects all ids during the generation process. We flush it here to get all ids.
-    const collectedIds = test_id_collector_1.TestIdCollector.flush();
-    const object = {};
-    const ids = collectedIds;
-    ids.sort();
-    for (const id of ids) {
-        const keys = id.split('-');
-        extendObject(object, keys, id);
-    }
-    const testIds = JSON.stringify(object, null, 2);
-    return /* ts */ `
-  /**
-   * Object with all generated test ids.
-   */
-  export const MODEL_TEST_IDS =
-  ${testIds}
-  `;
-}
-exports.generateTestIds = generateTestIds;
-/**
- * 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/types.generator.d.ts

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

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypesIndex = void 0;
-const exports_1 = require("../../lib/exports");
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates an index file that exports all types.
- */
-function generateTypesIndex({ models, enums, meta: schemaMeta, }) {
-    const imports = imports_1.ImportsGenerator.from(schemaMeta.types.indexFilePath);
-    const exports = exports_1.ExportsGenerator.from(schemaMeta.types.indexFilePath);
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(modelMeta.types.filePath);
-        imports.addTypeImport({ from: modelMeta.types.importPath, items: [modelMeta.types.brandedIdType] });
-    }
-    for (const enumerator of enums) {
-        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 /* ts */ `
-    ${imports.generate()}
-
-    ${exports.generate()}
-
-    export type ${schemaMeta.types.idTypesIndex} = {
-      ${models.map((model) => `${model.typeName}: ${model.brandedIdType}`).join('\n')}
-    }
-
-  `;
-}
-exports.generateTypesIndex = generateTypesIndex;

package/dist/generators/indices/update/actiontypes.generator.d.ts

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

package/dist/generators/indices/update/actiontypes.generator.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateBusinessLogicActionTypes = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-const file_1 = require("../../../lib/utils/file");
-/**
- * Generates the action types for the BusinessLogicModule.
- */
-function generateBusinessLogicActionTypes({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.update.actionTypesFilePath).addImport({
-        from: meta.actions.definition.importPath,
-        items: [meta.actions.definition.payload, meta.actions.definition.resultDict],
-    });
-    const updateServiceImports = [];
-    const modelNameTypeElements = [];
-    const actionsTypeElements = [];
-    const actionResultTypeElements = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        const className = modelMeta.update.serviceClassName;
-        const scope = modelMeta.update.actionModelDiscriminantName;
-        modelNameTypeElements.push(`'${scope}'`);
-        const relativeImportPath = (0, file_1.getRelativePath)({
-            from: meta.update.actionTypesFilePath,
-            to: modelMeta.update.serviceClassLocation.path,
-        });
-        updateServiceImports.push(`import type * as ${className} from '${relativeImportPath}'`);
-        actionsTypeElements.push(`${meta.actions.definition.payload}<${className}.Scope, ${className}.Actions>`);
-        actionResultTypeElements.push(`${scope}: ${meta.actions.definition.resultDict}<${className}.Actions>`);
-    }
-    return /* ts */ `
-${imports.generate()}
-
-${updateServiceImports.join('\n')}
-
-/**
-* Used by any of the default actions (create, update, delete) to identify the model.
-*/
-export type ModelName = ${modelNameTypeElements.join(' | ')}
-
-export type Action_BusinessLogic = ${actionsTypeElements.join(' | ')}
-
-export type ActionResult_BusinessLogic = {
-  ${actionResultTypeElements.join('\n')}
-}
-  `;
-}
-exports.generateBusinessLogicActionTypes = generateBusinessLogicActionTypes;

package/dist/generators/indices/update/module.generator.d.ts

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