@postxl/generator 0.39.0 → 0.40.1

package/dist/generators/indices/importexport-import-service.generator.js

@@ -0,0 +1,563 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportImportService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const string_1 = require("../../lib/utils/string");
+/**
+ * Generates the Exporter class for the Import-Export module
+ */
+function generateImportExportImportService({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.importService.filePath);
+    const { types, decoder, converterFunctions } = meta.importExport;
+    const { delta_Fields, delta, delta_Model } = types;
+    const { create, errors, unchanged, update } = delta_Model;
+    const { nonUnique, invalidReference, invalidType, isRequiredDependency, missingField } = errors;
+    const { dto } = meta.types;
+    imports.addImports({
+        [meta.data.importPath]: [meta.data.dataService.class, meta.data.types.bulkMutation],
+        [meta.types.importPath]: [dto.genericModel, dto.idType, dto.update],
+        [meta.actions.importPath]: [meta.actions.actionExecution.interface, meta.actions.dispatcherService.class],
+        [types.filePath]: [delta_Fields, delta_Model.type, delta],
+        [decoder.fullDecoderFilePath]: [decoder.decodedPXLModelDataTypeName],
+        [converterFunctions.filePath]: [converterFunctions.deltaToBulkMutations],
+    });
+    const resultAssignments = [];
+    const detectDeltaFunctions = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            from: modelMeta.types.importPath,
+            items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
+        });
+        resultAssignments.push(`${modelMeta.seed.constantName}: await this.detect${modelMeta.internalSingularNameCapitalized}Delta(data.${modelMeta.seed.constantName}),`);
+        detectDeltaFunctions.push(generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta: meta, imports }));
+    }
+    return /* ts */ `
+import { Injectable } from '@nestjs/common'
+import { ExhaustiveSwitchCheck } from '@pxl/common'
+
+${imports.generate()}
+
+import { Action_Import } from './actions'
+
+
+type Delta_Result<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> =
+  | { type: '${create.discriminant}' }
+  | { type: '${update.discriminant}'; delta: ${delta_Fields}<Model, ID>; existingItem: Model }
+  | { type: '${delta_Model.delete.discriminant}'; existingItem: Model }
+  | { type: '${unchanged.discriminant}' }
+
+@Injectable()
+export class ${meta.importExport.importService.name} {
+  constructor(
+    private readonly data: ${meta.data.dataService.class},
+    private readonly dispatcher: ${meta.actions.dispatcherService.class},
+  ) {
+    // We have a circular dependency between DispatcherService and ${meta.importExport.importService.name}. 
+    // In order to avoid trouble, instead of using Nest's forwardRef(), we inject the dispatcher service here
+    // and set the dispatcher's ${meta.importExport.importService.sharedName} to this instance.
+    this.dispatcher.${meta.importExport.importService.sharedName} =this
+  }
+
+  
+  /**
+   * Will be called by the dispatcher service to dispatch the given action.
+   */
+  public async dispatch({ 
+    action, 
+    execution 
+  }: { 
+    action: Action_Import; 
+    execution: ${meta.actions.actionExecution.interface} 
+  }) {
+    switch (action.type) {
+      case 'detect-delta':
+        return this.detectDelta(action.payload.data)
+      case 'execute-upsert':
+        return this.executeUpsert({ delta: action.payload, execution })
+      case 'execute-direct-upsert':
+        return this.executeDirectUpsert({ data: action.payload.data, execution })
+
+      default:
+        throw new ExhaustiveSwitchCheck(action)
+    }
+  }
+
+  public async detectDelta(data: ${decoder.decodedPXLModelDataTypeName}): Promise<{
+    bulkMutations: ${meta.data.types.bulkMutation}[]
+    upsertResult: ${delta}
+  }> {
+    const upsertResult: ${delta} = {
+      ${resultAssignments.join('\n')}
+    }
+
+    const bulkMutations: ${meta.data.types.bulkMutation}[] = ${converterFunctions.deltaToBulkMutations}(upsertResult)
+    return { bulkMutations, upsertResult }
+  }
+
+  public async executeUpsert({ 
+    delta, 
+    execution 
+  }: { 
+    delta: Delta; 
+    execution: ${meta.actions.actionExecution.interface}
+  }) {
+    const bulkMutations = ${converterFunctions.deltaToBulkMutations}(delta)
+    return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })
+  }
+  
+  public async executeDirectUpsert({ 
+    data, 
+    execution 
+  }: { 
+    data: ${meta.importExport.decoder.decodedPXLModelDataTypeName}; 
+    execution: ${meta.actions.actionExecution.interface}
+  }) {
+    const { bulkMutations } = await this.detectDelta(data)
+    return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })
+  }
+
+  /**
+   * Generic function to determine the what action (create/update/delete/unchanged) to take with an item 
+   * In case the type is update it also includes the delta for a given item. In case of delete, it also includes
+   * the existing item.
+   * 
+   * NOTE: The function does not implement any logic to automatically determine if an item should be deleted.
+   *       Implement this logic based on the business requirements!
+   */
+  private async determineDeltaResult<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>({
+    item,
+    getId,
+    getDelta,
+  }: {
+    item: Model
+    getId: (id: ID) => Promise<Model | null>
+    getDelta: ({ item, existingItem }: { item: Model; existingItem: Model }) => ${delta_Fields}<Model, ID>
+  }): Promise<Delta_Result<Model, ID>> {
+    if (item.id === undefined || item.id === '') {
+      return Promise.resolve({ type: '${create.discriminant}' })
+    }
+    const existingItem = await getId(item.id)
+
+    if (!existingItem) {
+      return Promise.resolve({ type: '${create.discriminant}' })
+    }
+
+    const delta = getDelta({ item, existingItem })
+
+    if (Object.keys(delta).length > 0) {
+      return Promise.resolve({ type: '${update.discriminant}', delta, existingItem })
+    }
+
+    // We do not have a default logic to identify deletions. Implement it here, e.g. using a
+    // custom "Action" field in the Excel table. If it is set to "Delete", we can handle the delete here.
+    // return Promise.resolve({type: '${delta_Model.delete.discriminant}', existingItem})
+
+    // If we reach this point, we assume the item has not changed
+    return Promise.resolve({ type: '${unchanged.discriminant}' })
+  }
+
+  private getDelta<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>({
+    item,
+    existingItem,
+    properties,
+  }: {
+    item: Model
+    existingItem: Model
+    properties: (keyof Omit<Model, 'id'>)[]
+  }): ${delta_Fields}<Model, ID> {
+    const delta: ${delta_Fields}<Model, ID> = {}
+
+    for (const property of properties) {
+      addDelta({ delta, existingItem, item, property })
+    }
+
+    return delta
+  }
+
+  /**
+   * Detects changes for a model and returns the result as a Delta_Model object.
+   */
+  private async detectModelDelta<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}, ModelErrors>({
+    items,
+    getId,
+    getDelta,
+    validateCreate,
+    validateUpdate,
+    validateDelete,
+  }: {
+    items?: Model[]
+    getId: (id: ID) => Promise<Model | null>
+    getDelta: (args: { item: Model; existingItem: Model }) => ${delta_Fields}<Model, ID>
+    validateCreate: (args: { item: Model }) => Promise<ModelErrors[]>
+    validateUpdate: (args: { item: Model; existingItem: Model }) => Promise<ModelErrors[]>
+    validateDelete: (args: { existingItem: Model }) => Promise<ModelErrors[]>
+  }): Promise<Delta_Model<Model, ID, ModelErrors>[]> {
+    const upsertResult: Delta_Model<Model, ID, ModelErrors>[] = []
+
+    if (items === undefined || items.length === 0) {
+      return Promise.resolve(upsertResult)
+    }
+
+    for (const item of items) {
+      const deltaResult = await this.determineDeltaResult({ item, getId, getDelta })
+
+      switch (deltaResult.type) {
+        case 'create': {
+          const errors = await validateCreate({ item })
+          if (errors.length === 0) {
+            upsertResult.push({ type: '${create.discriminant}', input: item, createDTO: item })
+          } else {
+            upsertResult.push({ type: '${errors.discriminant}', input: item, errors })
+          }
+          break
+        }
+
+        case 'update': {
+          const errors = await validateUpdate({ item, existingItem: deltaResult.existingItem })
+          if (errors.length === 0) {
+            upsertResult.push({
+              type: '${update.discriminant}',
+              input: item,
+              delta: deltaResult.delta,
+              updateDTO: deltaToUpdateDtoFunction({ id: item.id, delta: deltaResult.delta }),
+            })
+          } else {
+            upsertResult.push({ type: '${errors.discriminant}', input: item, errors })
+          }
+          break
+        }
+
+        case 'delete': {
+          const errors = await validateDelete({ existingItem: deltaResult.existingItem })
+          if (errors.length === 0) {
+            upsertResult.push({ type: '${delta_Model.delete.discriminant}', input: item })
+          } else {
+            upsertResult.push({ type: '${errors.discriminant}', input: item, errors })
+          }
+          break
+        }
+
+        case 'unchanged': {
+          upsertResult.push({ type: '${unchanged.discriminant}', input: item })
+          break
+        }
+
+        default:
+          throw new ExhaustiveSwitchCheck(deltaResult)
+      }
+    }
+
+    return Promise.resolve(upsertResult)
+  }
+
+  /**
+   * Internal helper function that removes undefined values from an array.
+   */
+  private keepErrors<ModelErrors>(errors: (ModelErrors | undefined)[]): ModelErrors[] {
+    return errors.filter((error) => error !== undefined) as ModelErrors[]
+  }
+
+  private validateRequiredFields<
+    Model extends ${dto.genericModel}<ID>, 
+    ID extends ${dto.idType}, 
+    FieldName extends Extract<keyof Omit<Model, 'id'>, string>
+  >({
+    item,
+    fieldNames,
+  }: {
+    item: Model
+    fieldNames: FieldName[]
+  }): ${missingField.type}<FieldName>[] {
+    const errors: ${missingField.type}<FieldName>[] = []
+    for (const fieldName of fieldNames) {
+      if (item[fieldName] === undefined) {
+        errors.push({ error: '${missingField.discriminant}', fieldName })
+      }
+    }
+    if (errors.length > 0) {
+      return errors
+    } else {
+      return []
+    }
+  }
+
+  private async validateReferenceField<
+    Model extends ${dto.genericModel}<ID>,
+    ID extends ${dto.idType},
+    RelatedModel extends ${dto.genericModel}<RelatedID>,
+    RelatedID extends ${dto.idType},
+    FieldName extends keyof Omit<Model, 'id'> & string,
+    Value extends RelatedID,
+    RelatedModelName extends string,
+  >({
+    item,
+    fieldName,
+    relatedModel,
+    getExistingItem,
+  }: {
+    item: Partial<Model>
+    fieldName: FieldName
+    relatedModel: RelatedModelName
+    getExistingItem: (id: RelatedID) => Promise<RelatedModel | null>
+  }): Promise<${invalidReference.type}<RelatedModelName, FieldName, Value> | undefined> {
+    const value: Value | undefined = item[fieldName] as Value | undefined
+    if (value === undefined) {
+      return undefined
+    }
+    const existingItem = await getExistingItem(value)
+    if (!existingItem) {
+      return { error: '${invalidReference.discriminant}', relatedModel, fieldName, value }
+    }
+    return undefined
+  }
+
+  private async validateUniqueField<
+    Model extends ${dto.genericModel}<ID>,
+    ID extends ${dto.idType},
+    FieldName extends keyof Omit<Model, 'id'> & string,
+    Value extends Model[FieldName],
+  >({
+    item,
+    fieldName,
+    getExistingItem,
+  }: {
+    item: Partial<Model>
+    fieldName: FieldName
+    getExistingItem: (fieldValue: Value) => Promise<Model | undefined>
+  }): Promise<${nonUnique.type}<FieldName, Value> | undefined> {
+    const value: Value | undefined = item[fieldName] as Value | undefined
+    if (value === undefined) {
+      return undefined
+    }
+    const existingItem = await getExistingItem(value)
+    if (existingItem) {
+      return { error: '${nonUnique.discriminant}', fieldName, value }
+    }
+    return undefined
+  }
+
+  private validateInt<
+    Model extends ${dto.genericModel}<ID>,
+    ID extends ${dto.idType},
+    FieldName extends keyof Omit<Model, 'id'> & string,
+  >({
+    item,
+    fieldName,
+  }: {
+    item: Model
+    fieldName: FieldName
+  }): ${invalidType.type}<FieldName, 'Int', number> | undefined {
+    const value: number | undefined | null = item[fieldName] as number | undefined | null
+    //we handle undefined and null in other value checks so we can ignore them here
+    if (value === undefined || value === null) {
+      return undefined
+    }
+
+    if (value !== Math.floor(value)) {
+      return { error: '${invalidType.discriminant}', fieldName, typeExpected: 'Int', value }
+    }
+    return undefined
+  }
+
+  private async validateRequiredDependency<
+    Model extends ${dto.genericModel}<ID>,
+    ID extends ${dto.idType},
+    RelatedModelName extends string,
+    RelatedField extends string,
+    RelatedModel extends ${dto.genericModel}<RelatedID>,
+    RelatedID extends ${dto.idType},
+  >({
+    item,
+    relatedModel,
+    relatedField,
+    getReferencedItems,
+  }: {
+    item: Model
+    relatedModel: RelatedModelName
+    relatedField: RelatedField
+    getReferencedItems: (id: ID) => Promise<RelatedModel[]>
+  }): Promise<
+    ${isRequiredDependency.type}<RelatedModelName, RelatedField, RelatedModel, RelatedID> | undefined
+  > {
+    const relatedItems = await getReferencedItems(item.id)
+    if (relatedItems.length > 0) {
+      return undefined
+    }
+    return { error: '${isRequiredDependency.discriminant}', relatedModel, relatedField, relatedItems }
+  }
+
+  ${detectDeltaFunctions.join('\n')}
+}
+
+/**
+ * Adds a delta entry for a property to the given delta object if the property
+ * of the item is different from the existing item
+ */
+function addDelta<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>({
+  delta,
+  existingItem,
+  item,
+  property,
+}: {
+  delta: ${delta_Fields}<Model, ID>
+  existingItem: Model
+  item: Model
+  property: keyof Omit<Model, 'id'>
+}): void {
+  if (existingItem[property] === item[property]) {
+    return
+  }
+  delta[property] = { old: existingItem[property], new: item[property] }
+}
+
+/**
+ * Converts a Delta to an UpdateDTO.
+ */
+function deltaToUpdateDtoFunction<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>({
+  id,
+  delta,
+}: {
+  id: ID
+  delta: ${delta_Fields}<Model, ID>
+}): ${dto.update}<Model, ID> {
+  const updateDTO = {
+    id: id,
+  } as UpdateDTO<Model, ID>
+
+  for (const [key, value] of Object.entries(delta)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+    const updatedValue = value.new as Model[keyof Omit<Model, 'id'>]
+    updateDTO[key as keyof Omit<Model, 'id'>] = updatedValue
+  }
+  return updateDTO
+}`;
+}
+exports.generateImportExportImportService = generateImportExportImportService;
+function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imports, }) {
+    const { types } = schemaMeta.importExport;
+    const { delta_Model } = types;
+    imports.addImport({
+        from: types.filePath,
+        items: [modelMeta.importExport.delta_Model_Errors],
+    });
+    const returnType = `${delta_Model.type}<${model.typeName}, ${modelMeta.types.brandedIdType}, ${modelMeta.importExport.delta_Model_Errors}>[]`;
+    const sharedValidations = [];
+    const requiredFields = [];
+    const fieldNames = [];
+    for (const field of model.fields) {
+        if (field.name === 'id' ||
+            field.attributes.isReadonly ||
+            field.attributes.isCreatedAt ||
+            field.attributes.isUpdatedAt) {
+            continue;
+        }
+        const fieldName = field.name;
+        fieldNames.push(`'${fieldName}'`);
+        if (field.isRequired) {
+            requiredFields.push(`'${fieldName}'`);
+        }
+        if (field.kind === 'scalar') {
+            if (field.isUnique) {
+                imports.addImport({ from: schemaMeta.importExport.types.filePath, items: [delta_Model.errors.nonUnique.type] });
+                const getByName = `getBy${(0, string_1.toPascalCase)(fieldName)}`;
+                sharedValidations.push(`this.validateUniqueField({
+            item,
+            fieldName: '${fieldName}',
+            getExistingItem: (value) => this.data.${modelMeta.data.dataServiceName}.${getByName}(value)
+          })`);
+            }
+            if (field.validation && field.validation.type === 'int') {
+                imports.addImport({
+                    from: schemaMeta.importExport.types.filePath,
+                    items: [delta_Model.errors.invalidType.type],
+                });
+                sharedValidations.push(`this.validateInt({item, fieldName: '${fieldName}'})`);
+            }
+        }
+        else if (field.kind === 'relation') {
+            const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
+            imports.addImport({
+                from: schemaMeta.importExport.types.filePath,
+                items: [delta_Model.errors.invalidReference.type],
+            });
+            sharedValidations.push(`this.validateReferenceField({
+          item,
+          fieldName: '${fieldName}',
+          relatedModel: '${field.relationToModel.name}',
+          getExistingItem: (id: ${field.relationToModel.brandedIdType}) => this.data.${relatedModelMeta.data.dataServiceName}.get(id)
+        })`);
+        }
+    }
+    const deleteValidations = [];
+    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;
+            }
+            imports.addImport({
+                from: schemaMeta.importExport.types.filePath,
+                items: [delta_Model.errors.isRequiredDependency.type],
+            });
+            const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
+            const relatedFieldName = (0, string_1.toPascalCase)(relatedField.name);
+            deleteValidations.push(`
+        await this.validateRequiredDependency({
+          item: existingItem,
+          relatedModel: '${relatedModel.name}',
+          relatedField: '${relatedField.name}',
+          getReferencedItems: async (id: ${modelMeta.types.brandedIdType}) => [
+            ...(await this.data.${relatedModelMeta.data.dataServiceName}.getItemsFor${relatedFieldName}(id)).values()
+          ]
+        })`);
+        }
+    }
+    if (requiredFields.length > 0) {
+        imports.addImport({ from: schemaMeta.importExport.types.filePath, items: [delta_Model.errors.missingField.type] });
+    }
+    const requiredFieldsValidation = requiredFields.length > 0
+        ? `...this.validateRequiredFields({item, fieldNames: [${requiredFields.join(',')}]}),`
+        : '';
+    const sharedValidationsFunction = sharedValidations.length > 0
+        ? `(item: ${model.name}) => Promise.all([${sharedValidations.join(',\n')}])`
+        : 'async () => Promise.resolve([])';
+    const validateDelete = deleteValidations.length > 0
+        ? `async ({ existingItem }) => this.keepErrors([${deleteValidations.join(',\n')}])`
+        : 'async () => Promise.resolve([])';
+    return /* ts */ `
+/**
+ * Detects changes for ${modelMeta.userFriendlyName} and returns the result as a ${delta_Model.type} object.
+ */
+private async detect${modelMeta.internalSingularNameCapitalized}Delta(
+  items?: ${model.typeName}[]
+): Promise<${returnType}> {
+  const sharedValidations: (item: ${model.name}) => Promise<(${modelMeta.importExport.delta_Model_Errors} | undefined)[]> = 
+    ${sharedValidationsFunction}
+
+    return this.detectModelDelta({
+      items,
+      getId: (id: ${model.brandedIdType}) => this.data.${modelMeta.data.dataServiceName}.get(id),
+      getDelta: ({ item, existingItem }: { item: ${model.name}; existingItem: ${model.name} }) =>
+        this.getDelta({
+          item,
+          existingItem,
+          properties: [${fieldNames.join(',')}],
+        }),
+      validateCreate: async ({ item }) =>
+        Promise.resolve(
+          this.keepErrors([
+            ${requiredFieldsValidation}
+            ...(await sharedValidations(item)),
+          ]),
+        ),
+      validateUpdate: async ({ item }) => Promise.resolve(this.keepErrors(await sharedValidations(item))),
+      validateDelete: ${validateDelete},
+    })
+}`;
+}

package/dist/generators/indices/{seeddata-type.generator.d.ts → importexport-types.generator.d.ts}

@@ -1,9 +1,9 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates a type for all SeedData.
+ * Generates types for import export module.
  */
-export declare function generateSeedDataType({ models, meta }: {
+export declare function generateImportExportTypes({ models, meta }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;