@postxl/generator 0.74.2 → 1.0.1

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

@@ -1,573 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportService = void 0;
-const imports_1 = require("../../../lib/imports");
-const meta_1 = require("../../../lib/meta");
-const types_1 = require("../../../lib/schema/types");
-const string_1 = require("../../../lib/utils/string");
-/**
- * Generates the Import Service class for the Import module
- */
-function generateImportService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.import.importService.location.path);
-    const { types, decoder, converterFunctions } = meta.import;
-    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.dataService.location.import]: [meta.data.dataService.class],
-        [meta.data.types.location.import]: [(0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation)],
-        [meta.types.importPath]: [
-            (0, types_1.toAnnotatedTypeName)(dto.genericModel),
-            (0, types_1.toAnnotatedTypeName)(dto.idType),
-            (0, types_1.toAnnotatedTypeName)(dto.update),
-        ],
-        [meta.actions.execution.interfaceLocation.import]: [meta.actions.execution.interface],
-        [meta.actions.dispatcher.classLocation.import]: [meta.actions.dispatcher.class],
-        [types.location.path]: [
-            (0, types_1.toAnnotatedTypeName)(delta),
-            (0, types_1.toAnnotatedTypeName)(delta_Fields),
-            (0, types_1.toAnnotatedTypeName)(delta_Model.type),
-            (0, types_1.toAnnotatedTypeName)(delta_Model.errors.invalidReference.type),
-            (0, types_1.toAnnotatedTypeName)(delta_Model.errors.isRequiredDependency.type),
-        ],
-        [decoder.location.path]: [(0, types_1.toAnnotatedTypeName)(decoder.decodedPXLModelDataTypeName)],
-        [converterFunctions.location.path]: [converterFunctions.deltaToBulkMutations],
-    });
-    const resultAssignments = [];
-    const detectDeltaFunctions = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addTypeImport({
-            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 '@postxl/runtime'
-
-${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.import.importService.name} {
-  constructor(
-    private readonly data: ${meta.data.dataService.class},
-    private readonly dispatcher: ${meta.actions.dispatcher.class},
-  ) {
-    // We have a circular dependency between DispatcherService and ${meta.import.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.import.importService.sharedName} to this instance.
-    this.dispatcher.${meta.import.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.execution.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.execution.interface}
-  }) {
-    const bulkMutations = ${converterFunctions.deltaToBulkMutations}(delta)
-    return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })
-  }
-  
-  public async executeDirectUpsert({ 
-    data, 
-    execution 
-  }: { 
-    data: ${meta.import.decoder.decodedPXLModelDataTypeName}; 
-    execution: ${meta.actions.execution.interface}
-  }) {
-    const { bulkMutations } = await this.detectDelta(data)
-    return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })
-  }
-
-  /**
-   * Generic function to determine 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 { type: '${create.discriminant}' }
-    }
-    const existingItem = await getId(item.id)
-
-    if (!existingItem) {
-      return { type: '${create.discriminant}' }
-    }
-
-    const delta = getDelta({ item, existingItem })
-
-    if (Object.keys(delta).length > 0) {
-      return { 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 {type: '${delta_Model.delete.discriminant}', existingItem}
-
-    // If we reach this point, we assume the item has not changed
-    return { 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 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 upsertResult
-  }
-
-  /**
-   * Internal helper function that removes undefined values from an array.
-   */
-  private keepErrors<O, I extends O | undefined>(errors: I[]): O[] {
-    return errors.filter((error) => error !== undefined) as O[]
-  }
-  
-  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.generateImportService = generateImportService;
-function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imports, }) {
-    const { types } = schemaMeta.import;
-    const { delta_Model } = types;
-    imports.addTypeImport({
-        from: types.location.path,
-        items: [modelMeta.import.delta_Model_Errors],
-    });
-    const returnType = `${delta_Model.type}<${model.typeName}, ${modelMeta.types.brandedIdType}, ${modelMeta.import.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.addTypeImport({
-                    from: schemaMeta.import.types.location.path,
-                    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.addTypeImport({
-                    from: schemaMeta.import.types.location.path,
-                    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 });
-            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;
-            }
-            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.addTypeImport({
-            from: schemaMeta.import.types.location.path,
-            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.import.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<${modelMeta.import.delta_Model_Errors}[]> =>
-        this.keepErrors([
-          ${requiredFieldsValidation}
-          ...(await sharedValidations(item)),
-        ]),
-      validateUpdate: async ({ item }): Promise<${modelMeta.import.delta_Model_Errors}[]> => 
-        this.keepErrors(await sharedValidations(item)),
-      validateDelete: ${validateDelete},
-    })
-}`;
-}

package/dist/generators/indices/import/types.generator.d.ts

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