@postxl/generator 0.33.4 → 0.35.0

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;

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;