@postxl/generators 0.2.2

package/dist/backend-import/generators/detect-delta/detect-delta-all-models.generator.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDetectDeltaAllModels = generateDetectDeltaAllModels;
+const generator_1 = require("@postxl/generator");
+function generateDetectDeltaAllModels(context) {
+    const { decoders, import: { detectDelta }, } = context;
+    const { allModels } = detectDelta;
+    const imports = generator_1.ImportGenerator
+        //
+        .from(allModels.location)
+        .add(context.repositories.dataService)
+        .addType(decoders.dataModel.decodedType)
+        .add(context.import.detectDelta.types.generic.modelType)
+        .addType(context.import.detectDelta.types.generic.errors.type)
+        .add(context.import.detectDelta.types.generic.errors.typeGuard)
+        .addImport({
+        from: (0, generator_1.toPackageName)('@postxl/utils'),
+        items: [(0, generator_1.toFunctionName)('red'), (0, generator_1.toFunctionName)('format'), (0, generator_1.toFunctionName)('pluralize')],
+    });
+    const { resultAssignments, idMapTypes, idMapInit, deltaTypes } = prepareModelDeltaTypes({ context, imports });
+    return `
+${imports.generate()}
+
+/**
+ * The delta of for all models.
+ */
+export type ${context.import.detectDelta.allModels.type.name} = {
+  ${deltaTypes.join('\n')}
+}
+
+export type ${context.import.detectDelta.allModels.idMapType.name} = {
+  ${idMapTypes.join('\n')}
+}
+
+function getIdMap(data: DataModel): ${context.import.detectDelta.allModels.idMapType.name} {
+  const result: IdMap = {
+    ${idMapInit.join(',\n')}
+  }
+  return result
+}
+
+function toIdMap<Model extends {id: ID}, ID extends string>(items?: Model[]): Map<ID, Model> {
+  const result = new Map<ID, Model>()
+  if (!items) return result
+  for (const item of items) {
+    result.set(item.id, item)
+  }
+  return result
+}
+
+export async function detectDelta(
+  dataService: ${context.repositories.dataService.name},
+  data: ${decoders.dataModel.decodedType.name},
+  throwInCaseOfError = true,
+): Promise<${allModels.type.name}> {
+  const idMap = getIdMap(data)
+  const result: ${allModels.type.name} = {
+    ${resultAssignments.join(',\n')}
+  }
+  const errors = ${allModels.extractErrors.name}(result)
+  if (Object.keys(errors).length > 0 && throwInCaseOfError) {
+    throw new Error(${allModels.summarizeErrors.name}(errors))
+  }
+  return result
+}
+
+export function ${allModels.extractErrors.name}(delta: ${allModels.type.name}): Record<string, ${detectDelta.types.generic.errors.type.name}<any, any, any>[]> {
+  const result: Record<string, ${detectDelta.types.generic.errors.type.name}<any, any, any>[]> = {}
+  for (const [key, value] of Object.entries(delta)) {
+    const errors = value?.filter((e: Delta_Model<any, any, any>) => ${detectDelta.types.generic.errors.typeGuard.name}(e)) as ${detectDelta.types.generic.errors.type.name}<
+      any,
+      any,
+      any
+    >[]
+    if (errors && errors.length > 0) {
+      result[key] = errors
+    }
+  }
+  return result
+}
+
+export function ${allModels.summarizeErrors.name}(errors: Record<string, ${detectDelta.types.generic.errors.type.name}<any, any, any>[]>): string {
+  let modelsWithErrors = 0
+  let totalErrors = 0
+  const modelCounts: string[] = []
+
+  for (const [key, value] of Object.entries(errors)) {
+    modelsWithErrors++
+    totalErrors += value.length
+    modelCounts.push(\`\${key}: \${format(value.length)} \${pluralize('error', value.length)}\`)
+  }
+  return (
+    red(
+      \`\${format(totalErrors)} \${pluralize('error', totalErrors)} in \${modelsWithErrors} \${pluralize('model', modelsWithErrors)} detected in delta!\`,
+    ) +
+    \`
+\${modelCounts.join('\\n')}
+Details:
+\${JSON.stringify(errors, null, 2)}
+\${red('Please fix the errors and try importing again!')}\`
+  )
+}
+`;
+}
+function prepareModelDeltaTypes({ context, imports }) {
+    const deltaTypes = [];
+    const resultAssignments = [];
+    const idMapTypes = [];
+    const idMapInit = [];
+    for (const model of context.models.values()) {
+        imports
+            //
+            .addType(model.types)
+            .addType(model.types.id)
+            .add(model.import.delta.errors)
+            .add(model.import.delta.detect);
+        deltaTypes.push(`${model.decoder.dataModelEntry}?: ${context.import.detectDelta.types.generic.modelType.name}<
+        ${model.types.name}, 
+        ${model.types.id.name},
+        ${model.import.delta.errors.name}
+        >[]`);
+        idMapTypes.push(`'${model.decoder.dataModelEntry}': Map<${model.types.id.name}, ${model.types.name}>`);
+        idMapInit.push(`${model.decoder.dataModelEntry}: toIdMap(data.${model.decoder.dataModelEntry})`);
+        resultAssignments.push(`${model.decoder.dataModelEntry}: await ${model.import.delta.detect.name}(dataService, data.${model.decoder.dataModelEntry} ?? [], idMap)`);
+    }
+    return { resultAssignments, deltaTypes, idMapTypes, idMapInit };
+}
+//# sourceMappingURL=detect-delta-all-models.generator.js.map

package/dist/backend-import/generators/detect-delta/detect-delta-all-models.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-delta-all-models.generator.js","sourceRoot":"","sources":["../../../../src/backend-import/generators/detect-delta/detect-delta-all-models.generator.ts"],"names":[],"mappings":"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"}

package/dist/backend-import/generators/detect-delta/detect-delta-functions.generator.d.ts

@@ -0,0 +1,2 @@
+import { ContextResult } from '../../import.generator';
+export declare function generateDetectDeltaFunctions(context: ContextResult): string;

package/dist/backend-import/generators/detect-delta/detect-delta-functions.generator.js

@@ -0,0 +1,391 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDetectDeltaFunctions = generateDetectDeltaFunctions;
+const Generator = __importStar(require("@postxl/generator"));
+function generateDetectDeltaFunctions(context) {
+    const { import: { detectDelta }, } = context;
+    const dto = context.types.dto;
+    const generic = detectDelta.types.generic;
+    const { create, update, errors, unchanged, delta_Fields, modelType } = generic;
+    const imports = Generator.ImportGenerator
+        //
+        .from(detectDelta._utils.getDelta.location)
+        .addType(dto.genericModel)
+        .addType(dto.idType)
+        .addType(dto.update)
+        .addType(delta_Fields)
+        .addType(modelType)
+        .addType(errors.invalidReference.type)
+        .addType(errors.invalidType.type)
+        .addType(errors.missingField.type)
+        .addType(errors.nonUnique.type)
+        .addType(errors.isRequiredDependency.type);
+    return /* ts */ `
+import { ExhaustiveSwitchCheck } from '@postxl/utils'
+${imports.generate()}
+
+type Delta_Result<Model extends GenericModel<ID>, ID extends IdType> =
+  | Delta_Result_Create<Model, ID>
+  | Delta_Result_Update<Model, ID>
+  | Delta_Result_Delete<Model, ID>
+  | { type: '${unchanged.discriminant}' }
+
+type Delta_Result_Create<Model extends GenericModel<ID>, ID extends IdType> = { type: '${create.discriminant}'; newItem: Model }
+type Delta_Result_Update<Model extends GenericModel<ID>, ID extends IdType> = {
+  type: '${update.discriminant}'
+  delta: ${delta_Fields.name}<Model, ID>
+  existingItem: Model
+  updatedItem: Model
+}
+type Delta_Result_Delete<Model extends GenericModel<ID>, ID extends IdType> = { type: '${generic.delete.discriminant}'; existingItem: Model }
+
+export type ${detectDelta._utils.validation.params.name}<Model extends ${dto.genericModel.name}<ID>, ID extends IdType, ModelErrors> = {
+  create: (params: Omit<Delta_Result_Create<Model, ID>, 'type'>) => Promise<ModelErrors[]>
+  update: (params: Omit<Delta_Result_Update<Model, ID>, 'type' | 'delta'>) => Promise<ModelErrors[]>
+  delete: (params: Omit<Delta_Result_Delete<Model, ID>, 'type'>) => Promise<ModelErrors[]>
+}
+
+/**
+ * Detects changes for a model and returns the result as a Delta_Model object.
+ */
+export async function ${detectDelta._utils.detectModelDelta.name}<Model extends ${dto.genericModel.name}<ID>, ID extends ${dto.idType.name}, ModelErrors>({
+  items,
+  getId,
+  getDelta,
+  validate
+}: {
+  items?: Model[]
+  getId: (id: ID) => Promise<Model | null>
+  getDelta: (args: { item: Model; existingItem: Model }) => ${delta_Fields.name}<Model, ID>
+  validate: ${detectDelta._utils.validation.params.name}<Model, ID, ModelErrors>
+}): Promise<${modelType.name}<Model, ID, ModelErrors>[]> {
+  const upsertResult: ${modelType.name}<Model, ID, ModelErrors>[] = []
+
+  if (items === undefined || items.length === 0) {
+    return upsertResult
+  }
+
+  for (const item of items) {
+    const deltaResult = await determineDeltaResult({ item, getId, getDelta })
+    const errors = deltaResult.type === 'unchanged' ? [] : await validate[deltaResult.type](deltaResult as any)
+
+    if (errors.length !== 0) {
+      upsertResult.push({ type: 'errors', input: item, errors })
+      continue
+    }
+    switch (deltaResult.type) {
+      case '${create.discriminant}':
+        upsertResult.push({ type: '${create.discriminant}', input: item, createDto: item })
+        break
+
+      case '${update.discriminant}':
+        upsertResult.push({
+          type: '${update.discriminant}',
+          input: item,
+          delta: deltaResult.delta,
+          updateDto: deltaToUpdateDtoFunction({ id: item.id, delta: deltaResult.delta }),
+        })
+        break
+
+      case '${generic.delete.discriminant}':
+        upsertResult.push({ type: 'errors', input: item, errors })
+        break
+
+      case '${unchanged.discriminant}': {
+        upsertResult.push({ type: '${unchanged.discriminant}', input: item })
+        break
+      }
+
+      default:
+        throw new ExhaustiveSwitchCheck(deltaResult)
+    }
+  }
+
+  return upsertResult
+}
+
+/**
+ * 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.
+ *
+ * **Important**: The function does not implement any logic to automatically determine if an item should be deleted.
+ * Implement this logic based on the business requirements!
+ */
+async function determineDeltaResult<Model extends ${dto.genericModel.name}<ID>, ID extends ${dto.idType.name}>({
+  item,
+  getId,
+  getDelta,
+}: {
+  item: Model
+  getId: (id: ID) => Promise<Model | null>
+  getDelta: ({ item, existingItem }: { item: Model; existingItem: Model }) => ${delta_Fields.name}<Model, ID>
+}): Promise<Delta_Result<Model, ID>> {
+  if (item.id === undefined || item.id === '') {
+    return { type: '${create.discriminant}', newItem: item }
+  }
+  const existingItem = await getId(item.id)
+
+  if (!existingItem) {
+    return { type: '${create.discriminant}', newItem: item }
+  }
+
+  const delta = getDelta({ item, existingItem })
+
+  if (Object.keys(delta).length > 0) {
+    return { type: '${update.discriminant}', delta, existingItem, updatedItem: item }
+  }
+
+  // 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: '${generic.delete.discriminant}', existingItem}
+
+  // If we reach this point, we assume the item has not changed
+  return { type: '${unchanged.discriminant}' }
+}
+
+export function ${detectDelta._utils.getDelta.name}<Model extends ${dto.genericModel.name}<ID>, ID extends ${dto.idType.name}>({
+  item,
+  existingItem,
+  properties,
+}: {
+  item: Model
+  existingItem: Model
+  properties: (keyof Omit<Model, 'id'>)[]
+}): ${delta_Fields.name}<Model, ID> {
+  const delta: ${delta_Fields.name}<Model, ID> = {}
+
+  for (const property of properties) {
+    addDelta({ delta, existingItem, item, property })
+  }
+
+  return delta
+}
+
+/**
+ * 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.name}<ID>, ID extends ${dto.idType.name}>({
+  delta,
+  existingItem,
+  item,
+  property,
+}: {
+  delta: ${delta_Fields.name}<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.name}<ID>, ID extends ${dto.idType.name}>({
+  id,
+  delta,
+}: {
+  id: ID
+  delta: ${delta_Fields.name}<Model, ID>
+}): ${dto.update.name}<Model, ID> {
+  const updateDto = {
+    id: id,
+  } as UpdateDto<Model, ID>
+
+  for (const [key, value] of Object.entries(delta)) {
+    const updatedValue = value.new as Model[keyof Omit<Model, 'id'>]
+    updateDto[key as keyof Omit<Model, 'id'>] = updatedValue
+  }
+  return updateDto
+}
+
+/**
+ * Helper function that removes undefined values from an array.
+ */
+export function ${detectDelta._utils.keepErrors.name}<O, I extends O | undefined>(errors: I[]): O[] {
+  return errors.filter((error) => error !== undefined) as O[]
+}
+
+/**
+ * Validates that the model has all required fields.
+ */
+export function ${detectDelta._utils.validation.requiredFields.name}<
+  Model extends ${dto.genericModel.name}<ID>,
+  ID extends ${dto.idType.name},
+  FieldName extends Extract<keyof Omit<Model, 'id'>, string>
+>({
+  item,
+  fieldNames,
+}: {
+  item: Model
+  fieldNames: FieldName[]
+}): ${errors.missingField.type.name}<FieldName>[] {
+  const errors: ${errors.missingField.type.name}<FieldName>[] = []
+  for (const fieldName of fieldNames) {
+    if (item[fieldName] === undefined) {
+      errors.push({ error: '${errors.missingField.discriminant}', fieldName })
+    }
+  }
+  if (errors.length > 0) {
+    return errors
+  } else {
+    return []
+  }
+}
+
+/**
+ * Validates that the field is a reference to an existing item.
+ */
+export async function ${detectDelta._utils.validation.referenceField.name}<
+  Model extends ${dto.genericModel.name}<ID>,
+  ID extends ${dto.idType.name},
+  RelatedModel extends ${dto.genericModel.name}<RelatedID>,
+  RelatedID extends ${dto.idType.name},
+  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<${errors.invalidReference.type.name}<RelatedModelName, FieldName, Value> | undefined> {
+  const value: Value | undefined | null = item[fieldName] as Value | undefined | null
+  if (value === undefined || value === null) {  
+    return undefined
+  }
+  const existingItem = await getExistingItem(value)
+  if (!existingItem) {
+    return { error: '${errors.invalidReference.discriminant}', relatedModel, fieldName, value }
+  }
+  return undefined
+}
+
+/**
+ * Validates that the field value is unique.
+ */
+export async function ${detectDelta._utils.validation.uniqueField.name}<
+  Model extends ${dto.genericModel.name}<ID>,
+  ID extends ${dto.idType.name},
+  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<${errors.nonUnique.type.name}<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: '${errors.nonUnique.discriminant}', fieldName, value }
+  }
+  return undefined
+}
+
+/**
+ * Validates that the field value is an integer.
+ */
+export function ${detectDelta._utils.validation.int.name}<
+  Model extends ${dto.genericModel.name}<ID>,
+  ID extends ${dto.idType.name},
+  FieldName extends keyof Omit<Model, 'id'> & string,
+>({
+  item,
+  fieldName,
+}: {
+  item: Model
+  fieldName: FieldName
+}): ${errors.invalidType.type.name}<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: '${errors.invalidType.discriminant}', fieldName, typeExpected: 'Int', value }
+  }
+  return undefined
+}
+
+/**
+ * Validates that the field is a reference to an existing item.
+ */
+export async function ${detectDelta._utils.validation.requiredDependency.name}<
+  Model extends ${dto.genericModel.name}<ID>,
+  ID extends ${dto.idType.name},
+  RelatedModelName extends string,
+  RelatedField extends string,
+  RelatedModel extends ${dto.genericModel.name}<RelatedID>,
+  RelatedID extends ${dto.idType.name},
+>({
+  item,
+  relatedModel,
+  relatedField,
+  getReferencedItems,
+}: {
+  item: Model
+  relatedModel: RelatedModelName
+  relatedField: RelatedField
+  getReferencedItems: (id: ID) => Promise<RelatedModel[]>
+}): Promise<
+  ${errors.isRequiredDependency.type.name}<RelatedModelName, RelatedField, RelatedModel, RelatedID> | undefined
+> {
+  const relatedItems = await getReferencedItems(item.id)
+  if (relatedItems.length > 0) {
+    return undefined
+  }
+  return { error: '${errors.isRequiredDependency.discriminant}', relatedModel, relatedField, relatedItems }
+}`;
+}
+//# sourceMappingURL=detect-delta-functions.generator.js.map

package/dist/backend-import/generators/detect-delta/detect-delta-functions.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-delta-functions.generator.js","sourceRoot":"","sources":["../../../../src/backend-import/generators/detect-delta/detect-delta-functions.generator.ts"],"names":[],"mappings":"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"}

package/dist/backend-import/generators/detect-delta/model-function.generator.d.ts

@@ -0,0 +1,2 @@
+import { ContextResult, ModelResult } from '../../import.generator';
+export declare function generateDetectModelDeltaFunction(context: ContextResult, model: ModelResult): string;