@postxl/generator 0.34.0 → 0.36.0

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

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelBusinessLogicUpdate = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const jsdoc_1 = require("../../lib/utils/jsdoc");
+const repository_generator_1 = require("./repository.generator");
+/**
+ * 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.
+ */
+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.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],
+    });
+    /**
+     * 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 updateServiceClassName = 'updateService';
+    const viewServiceClassName = 'viewService';
+    const actionBlocks = generateActionsBuildingBlocks({ model, meta });
+    imports.addImport({ from: meta.types.importPath, items: actionBlocks.importTypes });
+    const constructorParameters = [
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `@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 `
+import { Inject, Injectable, forwardRef } from '@nestjs/common'
+import { ExhaustiveSwitchCheck } from '@pxl/common'
+
+${imports.generate()}
+
+${actionBlocks.actionTypeDefinition}
+
+${actionBlocks.resultMap}
+
+${actionBlocks.typeDefinitionWithCreateFunction}
+
+@Injectable()
+export class ${meta.businessLogic.update.serviceClassName} {
+  constructor(${constructorParameters.join(',\n')}) {}
+
+  ${actionBlocks.dispatcher}
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
+  public async create(
+    { item, execution }: ${methodTypeSignatures.create.parameters[0]}
+  ): ${methodTypeSignatures.create.returnType} {
+    return this.${modelRepositoryVariableName}.create({ item, execution })
+  }
+
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
+  public async createMany(
+    { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
+  ): ${methodTypeSignatures.createMany.returnType} {
+    return this.${modelRepositoryVariableName}.createMany({ items, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
+  public async update(
+    { item, execution }: ${methodTypeSignatures.update.parameters[0]}
+  ): ${methodTypeSignatures.update.returnType} {
+    return this.${modelRepositoryVariableName}.update({ item, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
+  public async updateMany(
+    { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
+  ): ${methodTypeSignatures.updateMany.returnType} {
+    return this.${modelRepositoryVariableName}.updateMany({ items, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
+  public async upsert(
+    { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
+  ): ${methodTypeSignatures.upsert.returnType} {
+    return this.${modelRepositoryVariableName}.upsert({ item, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
+  public async upsertMany(
+    { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
+  ): ${methodTypeSignatures.upsertMany.returnType} {
+    return this.${modelRepositoryVariableName}.upsertMany({ items, execution })
+  }
+  
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
+  public async delete(
+    { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
+  ): ${methodTypeSignatures.delete.returnType} {
+    return this.${modelRepositoryVariableName}.delete({ id, execution })
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
+  public async deleteMany(
+    { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
+  ): ${methodTypeSignatures.deleteMany.returnType} {
+    return this.${modelRepositoryVariableName}.deleteMany({ ids, execution })
+  }
+
+}`;
+}
+exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
+function generateActionsBuildingBlocks({ model, meta }) {
+    const actionTypeDefinition = [];
+    const resultMap = [];
+    const typeDefinitionWithCreateFunction = [];
+    const importTypes = [];
+    const dispatcher = [];
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    const actionDefinitions = prepareActionDefinitions({ model, meta });
+    for (const [type, config] of Object.entries(actionDefinitions)) {
+        const def = generateAction({ model, meta, type: type, config });
+        actionTypeDefinition.push(def.actionName),
+            resultMap.push(def.resultMap),
+            typeDefinitionWithCreateFunction.push(def.typeDefinition, def.createFunction, ''),
+            importTypes.push(...def.importTypes),
+            dispatcher.push(def.dispatchCaseExpression);
+    }
+    return {
+        importTypes,
+        actionTypeDefinition: `export type Action_${meta.businessLogic.update.actionNameModelPart} = ${actionTypeDefinition.join(' | ')}`,
+        resultMap: `export type ActionResult_${meta.businessLogic.update.actionNameModelPart} = { 
+      ${resultMap.join('\n')} 
+    }`,
+        typeDefinitionWithCreateFunction: `${typeDefinitionWithCreateFunction.join('\n')}`,
+        dispatcher: `
+      public async dispatch<A extends Action_${meta.businessLogic.update.actionNameModelPart}>({ action, execution }: {
+        action: A; 
+        execution: ${schemaMeta.actions.actionExecutionInterface} 
+      }) {
+        switch (action.type) {
+          ${dispatcher.join('\n')}
+          default: {
+            throw new ExhaustiveSwitchCheck(action)
+          }
+        }
+      }`,
+    };
+}
+function prepareActionDefinitions({ model, meta, }) {
+    return {
+        create: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Create`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreate,
+            payload: meta.types.dto.create,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.create],
+            dispatcherParameterName: 'item',
+        },
+        createMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_CreateMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreateMany,
+            payload: `${meta.types.dto.create}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.create],
+            dispatcherParameterName: 'items',
+        },
+        update: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Update`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdate,
+            payload: meta.types.dto.update,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.update],
+            dispatcherParameterName: 'item',
+        },
+        updateMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpdateMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdateMany,
+            payload: `${meta.types.dto.update}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.update],
+            dispatcherParameterName: 'items',
+        },
+        upsert: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Upsert`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsert,
+            payload: meta.types.dto.upsert,
+            resultType: meta.types.typeName,
+            imports: [meta.types.dto.upsert],
+            dispatcherParameterName: 'item',
+        },
+        upsertMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpsertMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsertMany,
+            payload: `${meta.types.dto.upsert}[]`,
+            resultType: `${meta.types.typeName}[]`,
+            imports: [meta.types.dto.upsert],
+            dispatcherParameterName: 'items',
+        },
+        delete: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Delete`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameDelete,
+            payload: model.brandedIdType,
+            resultType: model.brandedIdType,
+            imports: [model.brandedIdType],
+            dispatcherParameterName: 'id',
+        },
+        deleteMany: {
+            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_DeleteMany`,
+            createFunctionName: meta.businessLogic.update.createActionFunctionNameDeleteMany,
+            payload: `${model.brandedIdType}[]`,
+            resultType: `${model.brandedIdType}[]`,
+            imports: [model.brandedIdType],
+            dispatcherParameterName: 'ids',
+        },
+    };
+}
+function generateAction({ meta, type, config: { imports, actionName, payload, createFunctionName, resultType, dispatcherParameterName }, }) {
+    return {
+        actionName,
+        actionType: type,
+        importTypes: imports,
+        resultMap: `${type}: ${resultType}`,
+        typeDefinition: `
+      export type ${actionName} = { scope: '${meta.actions.actionScopeConstType}'; type: '${type}'; payload: ${payload} }`,
+        createFunction: `
+      export function ${createFunctionName}(payload: ${payload}): ${actionName} {
+        return { scope: '${meta.actions.actionScopeConstType}', type: '${type}', payload }
+      }`,
+        dispatchCaseExpression: `
+      case '${type}':
+        return this.${type}({ ${dispatcherParameterName}: action.payload, execution })`,
+    };
+}

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

@@ -0,0 +1,10 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates view business logic for a given model.
+ * The view  logic exposes all information and links of a model. See template's readme for more info.
+ */
+export declare function generateModelBusinessLogicView({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

package/dist/generators/models/{businesslogic.generator.js → businesslogic-view.generator.js}

@@ -1,44 +1,23 @@
 "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;
+exports.generateModelBusinessLogicView = 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 ast_1 = require("../../lib/utils/ast");
-const repository_generator_1 = require("./repository.generator");
 /**
- * Generates business logic for a given model.
+ * Generates view business logic for a given model.
+ * The view  logic exposes all information and links of a model. See template's readme for more info.
  */
-// TODO: https://github.com/PostXL/PostXL/issues/347
-function generateModelBusinessLogic({ model, meta }) {
+function generateModelBusinessLogicView({ 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] });
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
+    imports.addImports({
+        [meta.data.importPath]: meta.data.repositoryClassName,
+        [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
+        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
+        [meta.data.importPath]: [meta.data.repositoryClassName],
+    });
     /**
      * 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
@@ -50,16 +29,11 @@ function generateModelBusinessLogic({ model, meta }) {
      * 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 viewServiceClassName = 'viewService';
     const constructorParameters = [
         `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.serviceClassName})) private readonly ${businessLogicServiceClassName}: ${schemaMeta.businessLogic.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.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.
      */
@@ -67,9 +41,9 @@ function generateModelBusinessLogic({ model, meta }) {
     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 variableGetter = `this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
         const variablePresenceCheck = `
-    if (!${relation.relatedModelBacklinkFieldName}) {
+      if (!${relation.relatedModelBacklinkFieldName}) {
         throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
       }
       `;
@@ -114,19 +88,19 @@ function generateModelBusinessLogic({ model, meta }) {
     })
         .join(',\n')}
       }
+
       return item
     }
   `;
-    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
-    // prettier-ignore
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { FilterOperator } from '@pxl/common'
 
 ${imports.generate()}
 
 @Injectable()
-export class ${meta.businessLogic.serviceClassName} {
+export class ${meta.businessLogic.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
 
   /**
@@ -140,14 +114,14 @@ export class ${meta.businessLogic.serviceClassName} {
   ${hasLinkedItems ? linkedItemsGetterFn : ''}
 
   /**
-   * Returns a map of all ${meta.userFriendlyName}s.
+   * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
   public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
     return this.${modelRepositoryVariableName}.getAll()
   }
 
-    /**
-   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyName}s.
+  /**
+   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyNamePlural}.
    */
   public getList({
     filter,
@@ -171,29 +145,6 @@ export class ${meta.businessLogic.serviceClassName} {
     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 item 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)
-  }
 }
 
 // Utility Functions
@@ -203,7 +154,7 @@ ${_createModelCompareFn({ model })}
 ${_createModelFilterFn({ model })}
 `;
 }
-exports.generateModelBusinessLogic = generateModelBusinessLogic;
+exports.generateModelBusinessLogicView = generateModelBusinessLogicView;
 /**
  * Generates a utility filter function for the given model that can be used to filter out instances
  * of a model using a given operator on a given field.
@@ -221,8 +172,9 @@ function _createModelFilterFn({ model }) {
           case 'contains': {
             return (item[field] || '').toLowerCase().includes(value.toLowerCase())
           }
-          default:
+          default: {
             return false
+          }
         }
       `,
         };

package/dist/generators/models/react.generator/modals.generator.js

@@ -198,7 +198,7 @@ export const ${components.modals.editComponentName} = ({
       <Typed.Formik
         initialValues={{
 					${fields
-        .filter((f) => !f.attributes.isReadonly)
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         switch (field.kind) {
             case 'enum':
@@ -500,7 +500,7 @@ function getEditFormInputFields({ model }) {
 }
 function getEditFormikMutationData({ model: { fields } }) {
     return fields
-        .filter((f) => !f.attributes.isReadonly)
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {

package/dist/generators/models/repository.generator.d.ts

@@ -31,6 +31,10 @@ type FnSignature = {
      * The return type of the function.
      */
     returnType: string;
+    /**
+     * The JSDoc comment of the function.
+     */
+    jsDoc?: string[];
 };
 /**
  * Returns a collection of type signatures for the repository methods of a given model.
@@ -40,7 +44,12 @@ export declare function getRepositoryMethodsTypeSignatures({ model, meta }: {
     meta: ModelMetaData;
 }): {
     create: FnSignature;
+    createMany: FnSignature;
     update: FnSignature;
+    updateMany: FnSignature;
+    upsert: FnSignature;
+    upsertMany: FnSignature;
     delete: FnSignature;
+    deleteMany: FnSignature;
 };
 export {};