@postxl/generator 0.33.4 → 0.35.0

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

@@ -1,259 +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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateModelBusinessLogic = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const Types = __importStar(require("../../lib/schema/types"));
-const repository_generator_1 = require("./repository.generator");
-/**
- * Generates business logic for a given model.
- */
-// TODO: https://github.com/PostXL/PostXL/issues/347
-function generateModelBusinessLogic({ model, meta }) {
-    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
-    imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
-    imports.addImport({ from: meta.types.importPath, items: [model.brandedIdType, meta.types.typeName] });
-    /**
-     * The name of the variable that holds the repository instance for the current model
-     * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
-     * would be referenced using `this.data` variable).
-     */
-    const modelRepositoryVariableName = meta.businessLogic.dataRepositoryVariableName;
-    /**
-     * The name of the variable that holds the central business logic service instance.
-     * Instead of injecting a repository instance for each model, we inject this single instance
-     * which then provides access to all models' business logic.
-     */
-    const businessLogicServiceClassName = Types.toVariableName('businessLogic');
-    const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.serviceClassName})) private readonly ${businessLogicServiceClassName}: ${schemaMeta.businessLogic.serviceClassName}`,
-    ];
-    imports.addImport({
-        from: schemaMeta.businessLogic.serviceFilePath,
-        items: [schemaMeta.businessLogic.serviceClassName],
-    });
-    imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
-    /**
-     * Variable names and their definitions indexed by the name of the relation they represent.
-     */
-    const variables = new Map();
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        const refModel = relation.relationToModel;
-        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        const variableGetter = `this.${businessLogicServiceClassName}.${refMeta.businessLogic.serviceVariableName}.get(itemRaw.${relation.name})`;
-        const variablePresenceCheck = `
-    if (!${relation.relatedModelBacklinkFieldName}) {
-        throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
-      }
-      `;
-        const relationVariableName = relation.relatedModelBacklinkFieldName;
-        variables.set(relation.name, {
-            variableName: relationVariableName,
-            variableDefinition: `
-      const ${relationVariableName} = ${relation.isRequired
-                ? `${variableGetter};${variablePresenceCheck}`
-                : `itemRaw.${relation.name} !== null ? ${variableGetter} : null`} 
-      `,
-        });
-    }
-    const hasLinkedItems = variables.size > 0;
-    if (hasLinkedItems) {
-        imports.addImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
-    }
-    const linkedItemsGetterFn = `
-    /**
-     * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
-     * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
-     */
-    public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
-      const itemRaw = this.${modelRepositoryVariableName}.get(id)
-      if (!itemRaw) {
-        return null
-      }
-
-      ${[...variables.values()].map((r) => r.variableDefinition).join('\n')}
-      
-      const item: ${meta.types.linkedTypeName} = {
-        ${model.fields
-        .map((f) => {
-        if (f.kind !== 'relation') {
-            return `${f.name}: itemRaw.${f.name}`;
-        }
-        const linkedRel = variables.get(f.name);
-        if (!linkedRel) {
-            throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
-        }
-        return `${linkedRel.variableName}`;
-    })
-        .join(',\n')}
-      }
-      return item
-    }
-  `;
-    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
-    // prettier-ignore
-    return `
-import { Inject, Injectable, forwardRef } from '@nestjs/common'
-import { FilterOperator } from '@pxl/common'
-
-${imports.generate()}
-
-@Injectable()
-export class ${meta.businessLogic.serviceClassName} {
-  constructor(${constructorParameters.join(',\n')}) {}
-
-  /**
-   * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
-   * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
-   */
-  public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
-    return this.${modelRepositoryVariableName}.get(id)
-  }
-
-  ${hasLinkedItems ? linkedItemsGetterFn : ''}
-
-  /**
-   * Returns a map of all ${meta.userFriendlyName}s.
-   */
-  public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
-    return this.${modelRepositoryVariableName}.getAll()
-  }
-
-    /**
-   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyName}s.
-   */
-  public getList({
-    filter,
-    sort,
-    cursor,
-  }: {
-    filter?: { field: keyof ${model.typeName}; operator: FilterOperator; value: string | number }
-    sort?: { field: keyof ${model.typeName}; ascending: boolean }
-    cursor?: { startRow: number; endRow: number }
-  }) {
-    const items = this.data.getAllAsArray()
-    const filtered = !filter
-      ? items
-      : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))
-
-    const filteredAndSorted = !sort
-      ? filtered
-      : filtered.sort((a, b) => (sort.ascending ? compare(a, b, sort.field) : -compare(a, b, sort.field)))
-
-    const paginated = !cursor ? filteredAndSorted : filteredAndSorted.slice(cursor.startRow, cursor.endRow)
-    return { rows: paginated, count: items.length }
-  }
-
-  /**
-   * Creates a new ${meta.userFriendlyName}.
-   */
-  public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {
-    return this.${modelRepositoryVariableName}.create(item)
-  }
-
-  /**
-   * Updates the given ${meta.userFriendlyName}.
-   */
-  public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
-    return this.${modelRepositoryVariableName}.update(item)
-  }
-
-  /**
-   * Deletes the ${meta.userFriendlyName} with the given id.
-   * 
-   * Note: This does NOT delete any linked items. 
-   * If the items is a dependency of another item, the deletion will fail!
-   */
-  public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
-    return this.${modelRepositoryVariableName}.delete(id)
-  }
-}
-
-const compare = (a: ${model.typeName}, b: ${model.typeName}, field: keyof ${model.typeName}) => {
-  switch (field) {
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-      return (a[field] || '').localeCompare(b[field] || '')`}
-    default:
-      return 0
-  }
-}
-
-const filterFn = (item: ${model.typeName}, field: keyof ${model.typeName}, operator: FilterOperator, value: string | number): boolean => {
-  switch (field) {
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'string')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-            {
-              if (typeof value !== 'string') return false
-              switch (operator) {
-                case 'contains': {
-                  return (item[field] || '').toLowerCase().includes(value.toLowerCase())
-                }
-                default:
-                  return false
-              }
-            }`}
-    ${model.fields.filter((f) => f.kind === 'scalar' && f.tsTypeName === 'number').length === 0
-        ? ''
-        : `${model.fields
-            .filter((f) => f.kind === 'scalar' && f.tsTypeName === 'number')
-            .map((f) => `case '${f.name}':`)
-            .join('\n')}
-            {
-              const toCompare = item[field]
-              if (typeof value !== 'number' || toCompare === null) return false
-              switch (operator) {
-                case 'eq': {
-                  return item[field] === value
-                }
-                case 'gt': {
-                  return toCompare > value
-                }
-                case 'lt': {
-                  return toCompare < value
-                }
-                default:
-                  return false
-              }
-            }`}
-    default:
-      return false
-  }
-}
-`;
-}
-exports.generateModelBusinessLogic = generateModelBusinessLogic;