@oondemand/oon-core-back 0.3.46 → 0.3.48

package/src/manifest/domainRules.js

@@ -23,6 +23,9 @@ const EXPRESSION_OPERATORS = Object.freeze([
   "not",
   "present",
   "in",
+  "if",
+  "concat",
+  "formatCurrency",
 ]);
 
 class DomainRuleError extends GenericError {
@@ -30,7 +33,7 @@ class DomainRuleError extends GenericError {
     const field = options.field || null;
     const rule = options.rule || null;
     super(message, {
-      statusCode: 422,
+      statusCode: options.statusCode || 422,
       details: {
         field,
         message,
@@ -66,9 +69,7 @@ function isEmpty(value) {
 }
 
 function toNumber(value, context = {}) {
-  if (isEmpty(value)) {
-    return context.nullAsZero ? 0 : null;
-  }
+  if (isEmpty(value)) return context.nullAsZero ? 0 : null;
   const numeric = typeof value === "number" ? value : Number(value);
   if (!Number.isFinite(numeric)) {
     throw new DomainRuleError(
@@ -202,6 +203,36 @@ function evaluateDomainExpression(expression, record = {}, context = {}) {
       const list = evaluateDomainExpression(args[1], record, context);
       return Array.isArray(list) && list.some((item) => Object.is(item, value));
     }
+    case "if":
+      return Boolean(evaluateDomainExpression(args[0], record, context))
+        ? evaluateDomainExpression(args[1], record, context)
+        : evaluateDomainExpression(args[2], record, context);
+    case "concat":
+      return args
+        .map((arg) => evaluateDomainExpression(arg, record, context))
+        .filter((value) => value !== null && value !== undefined)
+        .join("");
+    case "formatCurrency": {
+      const value = toNumber(evaluateDomainExpression(args[0], record, context), context);
+      if (value === null) return "";
+      const currency = evaluateDomainExpression(args[1] || { value: "BRL" }, record, context) || "BRL";
+      const locale = evaluateDomainExpression(args[2] || { value: "pt-BR" }, record, context) || "pt-BR";
+      try {
+        return new Intl.NumberFormat(String(locale), {
+          style: "currency",
+          currency: String(currency),
+          minimumFractionDigits: 2,
+          maximumFractionDigits: 2,
+        }).format(value);
+      } catch (error) {
+        throw new DomainRuleError("Não foi possível formatar o valor monetário.", {
+          code: "OON_DOMAIN_FORMULA_ERROR",
+          field: context.field,
+          rule: context.rule,
+          details: { currency, locale, cause: error.message },
+        });
+      }
+    }
     default:
       throw new DomainRuleError(`Operador declarativo não suportado: ${String(operator)}.`, {
         code: "OON_DOMAIN_EXPRESSION_INVALID",
@@ -221,6 +252,11 @@ function roundValue(value, precision) {
 function valuesEquivalent(left, right) {
   if (Object.is(left, right)) return true;
   if (isEmpty(left) && isEmpty(right)) return true;
+  if (left instanceof Date || right instanceof Date) {
+    const leftDate = new Date(left).getTime();
+    const rightDate = new Date(right).getTime();
+    return Number.isFinite(leftDate) && Number.isFinite(rightDate) && leftDate === rightDate;
+  }
   const leftNumber = Number(left);
   const rightNumber = Number(right);
   return Number.isFinite(leftNumber)
@@ -228,6 +264,13 @@ function valuesEquivalent(left, right) {
     && Object.is(leftNumber, rightNumber);
 }
 
+function detectChangedFields(current = {}, next = {}, candidates = null) {
+  const names = candidates
+    ? [...new Set(candidates)]
+    : [...new Set([...Object.keys(current || {}), ...Object.keys(next || {})])];
+  return names.filter((field) => !valuesEquivalent(current?.[field], next?.[field]));
+}
+
 function readonlyViolation(field, rule) {
   throw new DomainRuleError(`O campo ${field} é somente leitura e não pode ser alterado.`, {
     code: "OON_DOMAIN_READONLY_FIELD",
@@ -236,10 +279,43 @@ function readonlyViolation(field, rule) {
   });
 }
 
-function applyDomainMutation({ rules, current = null, changes = {}, op = "update" } = {}) {
+function validateDomainRecord(rules, record) {
+  const domainRules = rules || {};
+  for (const validation of domainRules.validations || []) {
+    const context = {
+      field: validation.field,
+      rule: validation.name || validation.code || "validation",
+    };
+    if (validation.when
+      && !Boolean(evaluateDomainExpression(validation.when, record, context))) {
+      continue;
+    }
+    if (!Boolean(evaluateDomainExpression(validation.assert, record, context))) {
+      throw new DomainRuleError(validation.message, {
+        code: validation.code || "OON_DOMAIN_VALIDATION_FAILED",
+        field: validation.field,
+        rule: validation.name,
+      });
+    }
+  }
+}
+
+function applyDomainMutation({
+  rules,
+  current = null,
+  changes = {},
+  systemChanges = {},
+  op = "update",
+  skipValidations = false,
+} = {}) {
   const requestedChanges = changes && typeof changes === "object" && !Array.isArray(changes)
     ? { ...changes }
     : {};
+  const trustedSystemChanges = systemChanges
+    && typeof systemChanges === "object"
+    && !Array.isArray(systemChanges)
+    ? { ...systemChanges }
+    : {};
   const sanitizedChanges = { ...requestedChanges };
   const currentRecord = current && typeof current === "object" ? { ...current } : {};
   const domainRules = rules || {};
@@ -257,10 +333,9 @@ function applyDomainMutation({ rules, current = null, changes = {}, op = "update
     readonlyViolation(field, "readonly");
   }
 
-  for (const computed of computedFields) {
-    delete sanitizedChanges[computed.field];
-  }
+  for (const computed of computedFields) delete sanitizedChanges[computed.field];
 
+  Object.assign(sanitizedChanges, trustedSystemChanges);
   const consolidated = { ...currentRecord, ...sanitizedChanges };
 
   for (const computed of computedFields) {
@@ -282,28 +357,20 @@ function applyDomainMutation({ rules, current = null, changes = {}, op = "update
     sanitizedChanges[computed.field] = normalized;
   }
 
-  for (const validation of domainRules.validations || []) {
-    const context = {
-      field: validation.field,
-      rule: validation.name || validation.code || "validation",
-    };
-    if (validation.when
-      && !Boolean(evaluateDomainExpression(validation.when, consolidated, context))) {
-      continue;
-    }
-    if (!Boolean(evaluateDomainExpression(validation.assert, consolidated, context))) {
-      throw new DomainRuleError(validation.message, {
-        code: validation.code || "OON_DOMAIN_VALIDATION_FAILED",
-        field: validation.field,
-        rule: validation.name,
-      });
-    }
-  }
+  if (!skipValidations) validateDomainRecord(domainRules, consolidated);
+
+  const candidateFields = [
+    ...Object.keys(sanitizedChanges),
+    ...Object.keys(trustedSystemChanges),
+  ];
+  const changedFields = detectChangedFields(currentRecord, consolidated, candidateFields);
 
   return {
     changes: sanitizedChanges,
     consolidated,
     requestedChanges,
+    systemChanges: trustedSystemChanges,
+    changedFields,
   };
 }
 
@@ -312,7 +379,9 @@ module.exports = {
   DomainRuleError,
   evaluateDomainExpression,
   applyDomainMutation,
+  validateDomainRecord,
+  detectChangedFields,
   getFieldValue,
   roundValue,
   valuesEquivalent,
-};
+};

package/src/manifest/processManifest.js

@@ -0,0 +1,411 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const registry = require("../core/registry");
+const GenericError = require("../core/errors/GenericError");
+const { EXPRESSION_OPERATORS } = require("./domainRules");
+
+const PROCESS_MANIFEST_FILENAME = "central.process.json";
+const PROCESS_MANIFEST_SCHEMA_VERSION = 1;
+const BINDING_KINDS = Object.freeze(["lookup", "aggregate", "expression"]);
+const AGGREGATE_OPERATORS = Object.freeze(["sum", "count", "min", "max"]);
+const RECALCULATION_MODES = Object.freeze(["immediate", "async"]);
+const EXPRESSION_OPERATOR_SET = new Set(EXPRESSION_OPERATORS);
+
+class ProcessManifestError extends GenericError {
+  constructor(message, issues = [], options = {}) {
+    super(message, {
+      statusCode: 422,
+      details: { issues },
+      cause: options.cause,
+    });
+    this.name = "ProcessManifestError";
+    this.code = "OON_PROCESS_MANIFEST_INVALID";
+    this.issues = issues;
+  }
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function addIssue(issues, fieldPath, message) {
+  issues.push({ path: fieldPath, message });
+}
+
+function validateText(value, fieldPath, issues) {
+  if (typeof value !== "string" || !value.trim()) {
+    addIssue(issues, fieldPath, "deve ser texto não vazio.");
+    return false;
+  }
+  return true;
+}
+
+function validateStringList(value, fieldPath, issues) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) {
+    addIssue(issues, fieldPath, "deve ser uma lista de textos não vazios.");
+    return false;
+  }
+  return true;
+}
+
+function validateJsonValue(value, fieldPath, issues, seen = new Set()) {
+  if (value === null || ["string", "boolean"].includes(typeof value)) return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) addIssue(issues, fieldPath, "deve ser um número finito.");
+    return;
+  }
+  if (typeof value !== "object" || seen.has(value)) {
+    addIssue(issues, fieldPath, "deve conter somente valores JSON.");
+    return;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateJsonValue(item, `${fieldPath}[${index}]`, issues, seen));
+  } else {
+    Object.entries(value).forEach(([key, item]) => {
+      validateJsonValue(item, `${fieldPath}.${key}`, issues, seen);
+    });
+  }
+  seen.delete(value);
+}
+
+function validateExpression(expression, fieldPath, issues) {
+  if (!isPlainObject(expression)) {
+    addIssue(issues, fieldPath, "deve ser um objeto de expressão.");
+    return;
+  }
+  const kinds = ["value", "field", "op"].filter((key) => hasOwn(expression, key));
+  if (kinds.length !== 1) {
+    addIssue(issues, fieldPath, "deve declarar exatamente um entre value, field ou op.");
+    return;
+  }
+  if (hasOwn(expression, "value")) {
+    validateJsonValue(expression.value, `${fieldPath}.value`, issues);
+    return;
+  }
+  if (hasOwn(expression, "field")) {
+    validateText(expression.field, `${fieldPath}.field`, issues);
+    return;
+  }
+  if (!EXPRESSION_OPERATOR_SET.has(expression.op)) {
+    addIssue(issues, `${fieldPath}.op`, `operador não suportado: ${String(expression.op)}.`);
+  }
+  if (!Array.isArray(expression.args)) {
+    addIssue(issues, `${fieldPath}.args`, "deve ser uma lista.");
+    return;
+  }
+  expression.args.forEach((arg, index) => validateExpression(arg, `${fieldPath}.args[${index}]`, issues));
+}
+
+function validateMatch(match, fieldPath, issues) {
+  if (!isPlainObject(match)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  for (const [field, condition] of Object.entries(match)) {
+    if (!field || ["__proto__", "prototype", "constructor"].includes(field)) {
+      addIssue(issues, `${fieldPath}.${field}`, "campo inválido.");
+      continue;
+    }
+    if (isPlainObject(condition)) {
+      const operators = Object.keys(condition);
+      if (operators.length !== 1 || !["eq", "neq", "in", "nin"].includes(operators[0])) {
+        addIssue(issues, `${fieldPath}.${field}`, "use somente eq, neq, in ou nin.");
+        continue;
+      }
+      if (["in", "nin"].includes(operators[0]) && !Array.isArray(condition[operators[0]])) {
+        addIssue(issues, `${fieldPath}.${field}.${operators[0]}`, "deve ser uma lista.");
+      }
+      validateJsonValue(condition[operators[0]], `${fieldPath}.${field}.${operators[0]}`, issues);
+    } else {
+      validateJsonValue(condition, `${fieldPath}.${field}`, issues);
+    }
+  }
+}
+
+function validateWorkflow(workflow, fieldPath, issues) {
+  if (!isPlainObject(workflow)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  validateText(workflow.stageField, `${fieldPath}.stageField`, issues);
+
+  if (hasOwn(workflow, "transitions")) {
+    if (!Array.isArray(workflow.transitions)) {
+      addIssue(issues, `${fieldPath}.transitions`, "deve ser uma lista.");
+    } else {
+      workflow.transitions.forEach((transition, index) => {
+        const itemPath = `${fieldPath}.transitions[${index}]`;
+        if (!isPlainObject(transition)) {
+          addIssue(issues, itemPath, "deve ser um objeto.");
+          return;
+        }
+        validateText(transition.from, `${itemPath}.from`, issues);
+        validateText(transition.to, `${itemPath}.to`, issues);
+        if (transition.when) validateExpression(transition.when, `${itemPath}.when`, issues);
+        if (transition.message) validateText(transition.message, `${itemPath}.message`, issues);
+      });
+    }
+  }
+
+  if (hasOwn(workflow, "lockedFieldsByStage")) {
+    if (!isPlainObject(workflow.lockedFieldsByStage)) {
+      addIssue(issues, `${fieldPath}.lockedFieldsByStage`, "deve ser um objeto.");
+    } else {
+      Object.entries(workflow.lockedFieldsByStage).forEach(([stage, fields]) => {
+        validateStringList(fields, `${fieldPath}.lockedFieldsByStage.${stage}`, issues);
+      });
+    }
+  }
+
+  if (hasOwn(workflow, "onEnter")) {
+    if (!Array.isArray(workflow.onEnter)) {
+      addIssue(issues, `${fieldPath}.onEnter`, "deve ser uma lista.");
+    } else {
+      workflow.onEnter.forEach((assignment, index) => {
+        const itemPath = `${fieldPath}.onEnter[${index}]`;
+        if (!isPlainObject(assignment)) {
+          addIssue(issues, itemPath, "deve ser um objeto.");
+          return;
+        }
+        validateText(assignment.stage, `${itemPath}.stage`, issues);
+        if (!isPlainObject(assignment.set)) addIssue(issues, `${itemPath}.set`, "deve ser um objeto.");
+        else validateJsonValue(assignment.set, `${itemPath}.set`, issues);
+      });
+    }
+  }
+
+  if (hasOwn(workflow, "automaticTransitions")) {
+    if (!Array.isArray(workflow.automaticTransitions)) {
+      addIssue(issues, `${fieldPath}.automaticTransitions`, "deve ser uma lista.");
+    } else {
+      workflow.automaticTransitions.forEach((transition, index) => {
+        const itemPath = `${fieldPath}.automaticTransitions[${index}]`;
+        if (!isPlainObject(transition)) {
+          addIssue(issues, itemPath, "deve ser um objeto.");
+          return;
+        }
+        validateExpression(transition.when, `${itemPath}.when`, issues);
+        validateText(transition.to, `${itemPath}.to`, issues);
+        if (transition.set) validateJsonValue(transition.set, `${itemPath}.set`, issues);
+      });
+    }
+  }
+}
+
+function validateBinding(binding, fieldPath, issues) {
+  if (!isPlainObject(binding)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  validateText(binding.field, `${fieldPath}.field`, issues);
+  if (!BINDING_KINDS.includes(binding.kind)) {
+    addIssue(issues, `${fieldPath}.kind`, `use: ${BINDING_KINDS.join(", ")}.`);
+    return;
+  }
+  if (binding.recalculate && !RECALCULATION_MODES.includes(binding.recalculate)) {
+    addIssue(issues, `${fieldPath}.recalculate`, `use: ${RECALCULATION_MODES.join(", ")}.`);
+  }
+  if (binding.watchFields) validateStringList(binding.watchFields, `${fieldPath}.watchFields`, issues);
+  if (binding.match) validateMatch(binding.match, `${fieldPath}.match`, issues);
+
+  if (binding.kind === "lookup") {
+    validateText(binding.sourceModel, `${fieldPath}.sourceModel`, issues);
+    validateText(binding.localField, `${fieldPath}.localField`, issues);
+    validateText(binding.sourceField, `${fieldPath}.sourceField`, issues);
+  }
+  if (binding.kind === "aggregate") {
+    validateText(binding.sourceModel, `${fieldPath}.sourceModel`, issues);
+    validateText(binding.foreignField, `${fieldPath}.foreignField`, issues);
+    if (!AGGREGATE_OPERATORS.includes(binding.operator)) {
+      addIssue(issues, `${fieldPath}.operator`, `use: ${AGGREGATE_OPERATORS.join(", ")}.`);
+    }
+    if (binding.operator !== "count") validateText(binding.sourceField, `${fieldPath}.sourceField`, issues);
+  }
+  if (binding.kind === "expression") {
+    validateExpression(binding.expression, `${fieldPath}.expression`, issues);
+    if (hasOwn(binding, "precision")
+      && (!Number.isInteger(binding.precision) || binding.precision < 0 || binding.precision > 8)) {
+      addIssue(issues, `${fieldPath}.precision`, "deve ser inteiro entre 0 e 8.");
+    }
+  }
+}
+
+function validateDeleteProtection(rule, fieldPath, issues) {
+  if (!isPlainObject(rule)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  validateText(rule.sourceModel, `${fieldPath}.sourceModel`, issues);
+  validateText(rule.foreignField, `${fieldPath}.foreignField`, issues);
+  validateText(rule.message, `${fieldPath}.message`, issues);
+  if (rule.match) validateMatch(rule.match, `${fieldPath}.match`, issues);
+}
+
+function validateAtomicInvariant(rule, fieldPath, issues) {
+  if (!isPlainObject(rule)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  validateText(rule.name, `${fieldPath}.name`, issues);
+  if (rule.kind !== "relatedSumLteParentField") {
+    addIssue(issues, `${fieldPath}.kind`, "use relatedSumLteParentField.");
+  }
+  validateText(rule.parentModel, `${fieldPath}.parentModel`, issues);
+  validateText(rule.parentLocalField, `${fieldPath}.parentLocalField`, issues);
+  validateText(rule.sourceField, `${fieldPath}.sourceField`, issues);
+  validateText(rule.parentField, `${fieldPath}.parentField`, issues);
+  validateText(rule.message, `${fieldPath}.message`, issues);
+  if (rule.match) validateMatch(rule.match, `${fieldPath}.match`, issues);
+  if (hasOwn(rule, "tolerance")
+    && (typeof rule.tolerance !== "number" || !Number.isFinite(rule.tolerance) || rule.tolerance < 0)) {
+    addIssue(issues, `${fieldPath}.tolerance`, "deve ser número finito maior ou igual a zero.");
+  }
+}
+
+function validateModelProcess(config, fieldPath, issues) {
+  if (!isPlainObject(config)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  if (config.workflow) validateWorkflow(config.workflow, `${fieldPath}.workflow`, issues);
+  for (const [key, validator] of [
+    ["bindings", validateBinding],
+    ["deleteProtection", validateDeleteProtection],
+    ["atomicInvariants", validateAtomicInvariant],
+  ]) {
+    if (!hasOwn(config, key)) continue;
+    if (!Array.isArray(config[key])) {
+      addIssue(issues, `${fieldPath}.${key}`, "deve ser uma lista.");
+      continue;
+    }
+    config[key].forEach((item, index) => validator(item, `${fieldPath}.${key}[${index}]`, issues));
+  }
+}
+
+function validateProcessManifest(input) {
+  const issues = [];
+  if (!isPlainObject(input)) {
+    throw new ProcessManifestError("Manifesto de processos inválido.", [
+      { path: "$", message: "o documento deve ser um objeto JSON." },
+    ]);
+  }
+  if (input.schemaVersion !== PROCESS_MANIFEST_SCHEMA_VERSION) {
+    addIssue(issues, "schemaVersion", `versão não suportada. Use ${PROCESS_MANIFEST_SCHEMA_VERSION}.`);
+  }
+  if (!isPlainObject(input.models) || Object.keys(input.models).length === 0) {
+    addIssue(issues, "models", "deve ser um objeto com pelo menos uma model.");
+  } else {
+    Object.entries(input.models).forEach(([modelName, config]) => {
+      validateText(modelName, `models.${modelName}`, issues);
+      validateModelProcess(config, `models.${modelName}`, issues);
+    });
+  }
+  if (issues.length) {
+    throw new ProcessManifestError(
+      `Manifesto de processos inválido: ${issues.length} problema(s) encontrado(s).`,
+      issues,
+    );
+  }
+  return JSON.parse(JSON.stringify(input));
+}
+
+function assertRegisteredContract(manifest) {
+  const issues = [];
+  for (const [modelName, config] of Object.entries(manifest.models)) {
+    const entry = registry.getModel(modelName);
+    if (!entry) {
+      addIssue(issues, `models.${modelName}`, "model não registrada no domínio.");
+      continue;
+    }
+    const ownFields = new Set(Object.keys(entry.metaFields || {}));
+    const assertOwnField = (field, fieldPath) => {
+      if (field && !ownFields.has(field)) addIssue(issues, fieldPath, `campo não declarado em ${modelName}.`);
+    };
+    if (config.workflow) {
+      assertOwnField(config.workflow.stageField, `models.${modelName}.workflow.stageField`);
+      Object.entries(config.workflow.lockedFieldsByStage || {}).forEach(([stage, fields]) => {
+        fields.forEach((field, index) => assertOwnField(
+          field,
+          `models.${modelName}.workflow.lockedFieldsByStage.${stage}[${index}]`,
+        ));
+      });
+    }
+    (config.bindings || []).forEach((binding, index) => {
+      const base = `models.${modelName}.bindings[${index}]`;
+      assertOwnField(binding.field, `${base}.field`);
+      if (binding.localField) assertOwnField(binding.localField, `${base}.localField`);
+      if (binding.sourceModel && !registry.getModel(binding.sourceModel)) {
+        addIssue(issues, `${base}.sourceModel`, "model de origem não registrada.");
+      }
+    });
+    (config.deleteProtection || []).forEach((rule, index) => {
+      if (!registry.getModel(rule.sourceModel)) {
+        addIssue(
+          issues,
+          `models.${modelName}.deleteProtection[${index}].sourceModel`,
+          "model de origem não registrada.",
+        );
+      }
+    });
+    (config.atomicInvariants || []).forEach((rule, index) => {
+      const base = `models.${modelName}.atomicInvariants[${index}]`;
+      assertOwnField(rule.parentLocalField, `${base}.parentLocalField`);
+      assertOwnField(rule.sourceField, `${base}.sourceField`);
+      if (!registry.getModel(rule.parentModel)) {
+        addIssue(issues, `${base}.parentModel`, "model pai não registrada.");
+      }
+    });
+  }
+  if (issues.length) throw new ProcessManifestError("Manifesto referencia domínio inexistente.", issues);
+}
+
+function registerProcessManifest(input) {
+  const manifest = validateProcessManifest(input);
+  assertRegisteredContract(manifest);
+  const entries = [];
+  for (const [modelName, processRules] of Object.entries(manifest.models)) {
+    const entry = registry.getModel(modelName);
+    entry.definition.processRules = JSON.parse(JSON.stringify(processRules));
+    entries.push(entry);
+  }
+  return entries;
+}
+
+function loadProcessManifest(filePath, options = {}) {
+  const resolvedPath = path.resolve(filePath);
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(resolvedPath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ProcessManifestError(
+        `JSON inválido em ${resolvedPath}.`,
+        [{ path: "$", message: error.message }],
+        { cause: error },
+      );
+    }
+    throw error;
+  }
+  const manifest = validateProcessManifest(parsed);
+  const entries = options.register === false ? [] : registerProcessManifest(manifest);
+  return { filePath: resolvedPath, manifest, entries };
+}
+
+module.exports = {
+  PROCESS_MANIFEST_FILENAME,
+  PROCESS_MANIFEST_SCHEMA_VERSION,
+  BINDING_KINDS,
+  AGGREGATE_OPERATORS,
+  RECALCULATION_MODES,
+  ProcessManifestError,
+  validateProcessManifest,
+  registerProcessManifest,
+  loadProcessManifest,
+};