@oondemand/oon-core-back 0.3.46 → 0.3.48

package/src/manifest/processRuntime.js

@@ -0,0 +1,578 @@
+"use strict";
+
+const mongoose = require("mongoose");
+const registry = require("../core/registry");
+const {
+  DomainRuleError,
+  applyDomainMutation,
+  evaluateDomainExpression,
+  roundValue,
+  valuesEquivalent,
+} = require("./domainRules");
+
+const MAX_AUTOMATIC_TRANSITIONS = 8;
+const MAX_TRANSACTION_ATTEMPTS = 3;
+let asynchronousQueue = Promise.resolve();
+
+function toPlainRecord(record) {
+  if (!record || typeof record !== "object") return {};
+  if (typeof record.toObject === "function") {
+    return record.toObject({ depopulate: true, getters: false, virtuals: false });
+  }
+  return { ...record };
+}
+
+function idKey(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "object" && value._id) return String(value._id);
+  return String(value);
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function queryWithSession(query, session) {
+  return session && query && typeof query.session === "function" ? query.session(session) : query;
+}
+
+function compileMongoMatch(match = {}) {
+  const query = {};
+  for (const [field, condition] of Object.entries(match || {})) {
+    if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+      if (hasOwn(condition, "eq")) query[field] = { $eq: condition.eq };
+      else if (hasOwn(condition, "neq")) query[field] = { $ne: condition.neq };
+      else if (hasOwn(condition, "in")) query[field] = { $in: condition.in };
+      else if (hasOwn(condition, "nin")) query[field] = { $nin: condition.nin };
+      else query[field] = condition;
+    } else {
+      query[field] = condition;
+    }
+  }
+  return query;
+}
+
+function recordMatches(record, match = {}) {
+  for (const [field, condition] of Object.entries(match || {})) {
+    const value = record?.[field];
+    if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+      if (hasOwn(condition, "eq") && !valuesEquivalent(value, condition.eq)) return false;
+      if (hasOwn(condition, "neq") && valuesEquivalent(value, condition.neq)) return false;
+      if (hasOwn(condition, "in")
+        && !condition.in.some((candidate) => valuesEquivalent(value, candidate))) return false;
+      if (hasOwn(condition, "nin")
+        && condition.nin.some((candidate) => valuesEquivalent(value, candidate))) return false;
+    } else if (!valuesEquivalent(value, condition)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function evaluateCondition(expression, record, context = {}) {
+  if (!expression) return true;
+  return Boolean(evaluateDomainExpression(expression, record, context));
+}
+
+function workflowError(message, field, rule, details = {}) {
+  throw new DomainRuleError(message, {
+    code: "OON_WORKFLOW_TRANSITION_INVALID",
+    statusCode: 409,
+    field,
+    rule,
+    details,
+  });
+}
+
+function applyWorkflowRules({ processRules, current = {}, changes = {}, op = "update", system = false }) {
+  const workflow = processRules?.workflow;
+  if (!workflow) return { changes: {}, stageChanged: false };
+
+  const stageField = workflow.stageField;
+  const previousStage = current?.[stageField];
+  const requestedStage = changes?.[stageField];
+  const stageChanged = hasOwn(changes, stageField)
+    && !valuesEquivalent(previousStage, requestedStage);
+  const systemChanges = {};
+
+  if (!system) {
+    const lockedFields = workflow.lockedFieldsByStage?.[previousStage] || [];
+    const changedLockedField = lockedFields.find(
+      (field) => hasOwn(changes, field) && !valuesEquivalent(current?.[field], changes[field]),
+    );
+    if (changedLockedField) {
+      workflowError(
+        workflow.lockedMessage || "Os dados de negócio estão bloqueados nesta etapa.",
+        changedLockedField,
+        "lockedFieldsByStage",
+        { stage: previousStage },
+      );
+    }
+
+    if (op === "create" && workflow.initialStages?.length) {
+      const initialStage = requestedStage ?? workflow.defaultStage;
+      if (!workflow.initialStages.includes(initialStage)) {
+        workflowError(
+          workflow.initialStageMessage || "O registro deve iniciar em uma etapa permitida.",
+          stageField,
+          "initialStages",
+          { stage: initialStage },
+        );
+      }
+    }
+
+    if (op !== "create" && stageChanged) {
+      const intended = { ...current, ...changes };
+      const transition = (workflow.transitions || []).find(
+        (item) => valuesEquivalent(item.from, previousStage)
+          && valuesEquivalent(item.to, requestedStage)
+          && evaluateCondition(item.when, intended, { field: stageField, rule: "transition" }),
+      );
+      if (!transition) {
+        workflowError(
+          `Transição inválida de ${String(previousStage)} para ${String(requestedStage)}.`,
+          stageField,
+          "transitions",
+          { from: previousStage, to: requestedStage },
+        );
+      }
+    }
+  }
+
+  if (stageChanged || (op === "create" && requestedStage !== undefined)) {
+    for (const assignment of workflow.onEnter || []) {
+      if (valuesEquivalent(assignment.stage, requestedStage)) Object.assign(systemChanges, assignment.set || {});
+    }
+  }
+
+  return { changes: systemChanges, stageChanged };
+}
+
+function applyAutomaticTransitions(processRules, record) {
+  const workflow = processRules?.workflow;
+  if (!workflow?.automaticTransitions?.length) return {};
+  const stageField = workflow.stageField;
+  const next = { ...record };
+  const systemChanges = {};
+
+  for (let attempt = 0; attempt < MAX_AUTOMATIC_TRANSITIONS; attempt += 1) {
+    const transition = workflow.automaticTransitions.find((item) => (
+      !valuesEquivalent(next[stageField], item.to)
+      && evaluateCondition(item.when, next, { field: stageField, rule: "automaticTransition" })
+    ));
+    if (!transition) break;
+
+    next[stageField] = transition.to;
+    systemChanges[stageField] = transition.to;
+    Object.assign(next, transition.set || {});
+    Object.assign(systemChanges, transition.set || {});
+    for (const assignment of workflow.onEnter || []) {
+      if (valuesEquivalent(assignment.stage, transition.to)) {
+        Object.assign(next, assignment.set || {});
+        Object.assign(systemChanges, assignment.set || {});
+      }
+    }
+  }
+
+  return systemChanges;
+}
+
+function bindingDefault(binding) {
+  if (hasOwn(binding, "default")) return binding.default;
+  return binding.kind === "aggregate" ? 0 : null;
+}
+
+async function loadLookupValues(binding, states, session) {
+  const sourceEntry = registry.getModel(binding.sourceModel);
+  if (!sourceEntry) throw new Error(`Model ${binding.sourceModel} não registrada.`);
+  const ids = [...new Set(states.map((state) => idKey(state[binding.localField])).filter(Boolean))];
+  if (!ids.length) return new Map();
+  let query = sourceEntry.mongooseModel
+    .find({ _id: { $in: ids } })
+    .select(`_id ${binding.sourceField}`);
+  query = queryWithSession(query, session);
+  const rows = await query.lean();
+  return new Map(rows.map((row) => [idKey(row._id), row[binding.sourceField]]));
+}
+
+async function loadAggregateValues(binding, states, session) {
+  const sourceEntry = registry.getModel(binding.sourceModel);
+  if (!sourceEntry) throw new Error(`Model ${binding.sourceModel} não registrada.`);
+  const parentIds = [...new Map(
+    states.map((state) => [idKey(state._id), state._id]).filter(([key]) => Boolean(key)),
+  ).values()];
+  if (!parentIds.length) return new Map();
+
+  const match = {
+    [binding.foreignField]: { $in: parentIds },
+    ...compileMongoMatch(binding.match),
+  };
+  let accumulator;
+  switch (binding.operator) {
+    case "count": accumulator = { $sum: 1 }; break;
+    case "min": accumulator = { $min: `$${binding.sourceField}` }; break;
+    case "max": accumulator = { $max: `$${binding.sourceField}` }; break;
+    case "sum":
+    default: accumulator = { $sum: { $ifNull: [`$${binding.sourceField}`, 0] } }; break;
+  }
+  let aggregate = sourceEntry.mongooseModel.aggregate([
+    { $match: match },
+    { $group: { _id: `$${binding.foreignField}`, value: accumulator } },
+  ]);
+  if (session && typeof aggregate.session === "function") aggregate = aggregate.session(session);
+  const rows = await aggregate;
+  return new Map(rows.map((row) => [idKey(row._id), row.value]));
+}
+
+async function resolveBindingsForRecords(entry, records, options = {}) {
+  const bindings = entry.definition?.processRules?.bindings || [];
+  const states = records.map((record) => ({ ...record }));
+  const derived = states.map(() => ({}));
+
+  for (const binding of bindings) {
+    if (binding.kind === "lookup") {
+      const values = await loadLookupValues(binding, states, options.session);
+      states.forEach((state, index) => {
+        const value = values.has(idKey(state[binding.localField]))
+          ? values.get(idKey(state[binding.localField]))
+          : bindingDefault(binding);
+        state[binding.field] = value;
+        derived[index][binding.field] = value;
+      });
+      continue;
+    }
+
+    if (binding.kind === "aggregate") {
+      const values = await loadAggregateValues(binding, states, options.session);
+      states.forEach((state, index) => {
+        const value = values.has(idKey(state._id))
+          ? values.get(idKey(state._id))
+          : bindingDefault(binding);
+        state[binding.field] = value;
+        derived[index][binding.field] = value;
+      });
+      continue;
+    }
+
+    states.forEach((state, index) => {
+      const raw = evaluateDomainExpression(binding.expression, state, {
+        field: binding.field,
+        rule: "processBinding",
+        nullAsZero: binding.nullAsZero !== false,
+      });
+      const value = typeof raw === "number" && hasOwn(binding, "precision")
+        ? roundValue(raw, binding.precision)
+        : raw;
+      state[binding.field] = value;
+      derived[index][binding.field] = value;
+    });
+  }
+
+  return { states, derived };
+}
+
+async function prepareProcessMutations(entry, currents, requestedChanges, options = {}) {
+  const processRules = entry.definition?.processRules || {};
+  const domainRules = entry.definition?.domainRules;
+  const op = options.op || "update";
+  const bases = currents.map((current, index) => {
+    const requested = requestedChanges[index] || {};
+    const workflow = applyWorkflowRules({
+      processRules,
+      current,
+      changes: requested,
+      op,
+      system: Boolean(options.system),
+    });
+    const prepared = applyDomainMutation({
+      rules: domainRules,
+      current,
+      changes: requested,
+      systemChanges: workflow.changes,
+      op: op === "create" ? "create" : "update",
+      skipValidations: true,
+    });
+    return { requested, workflow, prepared };
+  });
+
+  const resolved = await resolveBindingsForRecords(
+    entry,
+    bases.map((base) => base.prepared.consolidated),
+    options,
+  );
+
+  return bases.map((base, index) => {
+    const automaticChanges = applyAutomaticTransitions(processRules, resolved.states[index]);
+    const systemChanges = {
+      ...base.workflow.changes,
+      ...resolved.derived[index],
+      ...automaticChanges,
+    };
+    return applyDomainMutation({
+      rules: domainRules,
+      current: currents[index],
+      changes: base.requested,
+      systemChanges,
+      op: op === "create" ? "create" : "update",
+    });
+  });
+}
+
+async function prepareProcessMutation(entry, current, changes, options = {}) {
+  const [prepared] = await prepareProcessMutations(
+    entry,
+    [toPlainRecord(current)],
+    [changes || {}],
+    options,
+  );
+  return prepared;
+}
+
+function invariantError(rule, total, limit) {
+  const message = String(rule.message)
+    .replaceAll("{total}", Number(total).toFixed(2))
+    .replaceAll("{limit}", Number(limit).toFixed(2));
+  throw new DomainRuleError(message, {
+    code: rule.code || "OON_ATOMIC_INVARIANT_FAILED",
+    statusCode: 409,
+    field: rule.sourceField,
+    rule: rule.name,
+    details: { total, limit },
+  });
+}
+
+async function assertAtomicInvariants(entry, candidate, current, session) {
+  for (const rule of entry.definition?.processRules?.atomicInvariants || []) {
+    if (rule.kind !== "relatedSumLteParentField") continue;
+    const parentId = candidate?.[rule.parentLocalField];
+    if (!parentId) continue;
+    const parentEntry = registry.getModel(rule.parentModel);
+    if (!parentEntry) throw new Error(`Model pai ${rule.parentModel} não registrada.`);
+
+    let parentQuery = parentEntry.mongooseModel.findOneAndUpdate(
+      { _id: parentId },
+      { $inc: { __oonInvariantVersion: 1 } },
+      { new: true, session, projection: { [rule.parentField]: 1 } },
+    );
+    parentQuery = queryWithSession(parentQuery, session);
+    const parent = await parentQuery.lean();
+    if (!parent) {
+      throw new DomainRuleError("Registro pai da invariável não encontrado.", {
+        code: "OON_ATOMIC_PARENT_NOT_FOUND",
+        statusCode: 422,
+        field: rule.parentLocalField,
+        rule: rule.name,
+      });
+    }
+
+    const match = {
+      [rule.parentLocalField]: parentId,
+      ...compileMongoMatch(rule.match),
+    };
+    if (current?._id) match._id = { $ne: current._id };
+    let aggregate = entry.mongooseModel.aggregate([
+      { $match: match },
+      { $group: { _id: null, total: { $sum: { $ifNull: [`$${rule.sourceField}`, 0] } } } },
+    ]);
+    if (session && typeof aggregate.session === "function") aggregate = aggregate.session(session);
+    const rows = await aggregate;
+    const existing = Number(rows[0]?.total || 0);
+    const candidateValue = recordMatches(candidate, rule.match)
+      ? Number(candidate?.[rule.sourceField] || 0)
+      : 0;
+    const total = existing + candidateValue;
+    const limit = Number(parent?.[rule.parentField] || 0);
+    if (total > limit + Number(rule.tolerance || 0)) invariantError(rule, total, limit);
+  }
+}
+
+async function assertDeleteAllowed(entry, id, options = {}) {
+  for (const rule of entry.definition?.processRules?.deleteProtection || []) {
+    const sourceEntry = registry.getModel(rule.sourceModel);
+    if (!sourceEntry) throw new Error(`Model ${rule.sourceModel} não registrada.`);
+    let query = sourceEntry.mongooseModel.exists({
+      [rule.foreignField]: id,
+      ...compileMongoMatch(rule.match),
+    });
+    query = queryWithSession(query, options.session);
+    if (await query) {
+      throw new DomainRuleError(rule.message, {
+        code: rule.code || "OON_DELETE_PROTECTED",
+        statusCode: 409,
+        field: null,
+        rule: "deleteProtection",
+        details: { sourceModel: rule.sourceModel, foreignField: rule.foreignField },
+      });
+    }
+  }
+}
+
+function isTransientTransactionError(error) {
+  return Boolean(
+    error?.hasErrorLabel?.("TransientTransactionError")
+    || error?.hasErrorLabel?.("UnknownTransactionCommitResult")
+    || [112, 244, 251].includes(error?.code),
+  );
+}
+
+async function withProcessTransaction(entry, work) {
+  const requiresTransaction = Boolean(
+    entry.definition?.processRules?.atomicInvariants?.length,
+  );
+  if (!requiresTransaction) return work(null);
+
+  for (let attempt = 1; attempt <= MAX_TRANSACTION_ATTEMPTS; attempt += 1) {
+    const session = await mongoose.startSession();
+    try {
+      let result;
+      await session.withTransaction(async () => {
+        result = await work(session);
+      }, {
+        readConcern: { level: "snapshot" },
+        writeConcern: { w: "majority" },
+      });
+      return result;
+    } catch (error) {
+      if (attempt === MAX_TRANSACTION_ATTEMPTS || !isTransientTransactionError(error)) throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  throw new Error("Não foi possível concluir a transação de domínio.");
+}
+
+function bindingAffectedBySource(binding, sourceName, changedFields) {
+  if (binding.sourceModel !== sourceName) return false;
+  const watched = binding.watchFields?.length
+    ? binding.watchFields
+    : [binding.sourceField].filter(Boolean);
+  return !watched.length || watched.some((field) => changedFields.includes(field));
+}
+
+function collectDependentTargets(sourceEntry, before, after, changedFields) {
+  const targets = new Map();
+  for (const targetEntry of registry.listModels()) {
+    for (const binding of targetEntry.definition?.processRules?.bindings || []) {
+      if (!bindingAffectedBySource(binding, sourceEntry.name, changedFields)) continue;
+      const ids = [];
+      if (binding.kind === "lookup") {
+        const sourceId = after?._id || before?._id;
+        if (sourceId) ids.push({ field: binding.localField, value: sourceId });
+      } else if (binding.kind === "aggregate") {
+        for (const record of [before, after]) {
+          if (record?.[binding.foreignField]) {
+            ids.push({ field: "_id", value: record[binding.foreignField] });
+          }
+        }
+      }
+      if (!ids.length) continue;
+      const current = targets.get(targetEntry.name) || {
+        entry: targetEntry,
+        selectors: [],
+        mode: "immediate",
+      };
+      current.selectors.push(...ids);
+      if (binding.recalculate === "async") current.mode = "async";
+      targets.set(targetEntry.name, current);
+    }
+  }
+  return [...targets.values()];
+}
+
+async function recalculateTarget(entry, selectors, options = {}) {
+  const clauses = selectors.map(({ field, value }) => ({ [field]: value }));
+  if (!clauses.length) return { matched: 0, modified: 0 };
+  let query = entry.mongooseModel.find(clauses.length === 1 ? clauses[0] : { $or: clauses });
+  query = queryWithSession(query, options.session);
+  const documents = await query.lean();
+  if (!documents.length) return { matched: 0, modified: 0 };
+
+  const prepared = await prepareProcessMutations(
+    entry,
+    documents,
+    documents.map(() => ({})),
+    { ...options, op: "system", system: true },
+  );
+  const operations = [];
+  prepared.forEach((result, index) => {
+    const changed = Object.fromEntries(
+      result.changedFields
+        .filter((field) => hasOwn(result.changes, field))
+        .map((field) => [field, result.changes[field]]),
+    );
+    if (Object.keys(changed).length) {
+      operations.push({
+        updateOne: {
+          filter: { _id: documents[index]._id },
+          update: { $set: changed },
+        },
+      });
+    }
+  });
+  if (!operations.length) return { matched: documents.length, modified: 0 };
+  const result = await entry.mongooseModel.bulkWrite(operations, {
+    ordered: false,
+    session: options.session || undefined,
+  });
+  return { matched: documents.length, modified: result.modifiedCount || 0 };
+}
+
+function enqueueAsynchronousRecalculation(target) {
+  asynchronousQueue = asynchronousQueue
+    .then(() => new Promise((resolve) => setImmediate(resolve)))
+    .then(() => recalculateTarget(target.entry, target.selectors, { session: null }))
+    .catch((error) => {
+      // A fila não pode morrer silenciosamente nem bloquear novas tarefas.
+      console.error("OON_PROCESS_ASYNC_RECALCULATION_FAILED", {
+        model: target.entry.name,
+        message: error.message,
+      });
+    });
+  return asynchronousQueue;
+}
+
+async function recalculateDependents(entry, before, after, options = {}) {
+  const previous = toPlainRecord(before);
+  const next = toPlainRecord(after);
+  const changedFields = options.changedFields || [
+    ...new Set([...Object.keys(previous), ...Object.keys(next)]),
+  ].filter((field) => !valuesEquivalent(previous[field], next[field]));
+  if (!changedFields.length) return [];
+
+  const targets = collectDependentTargets(entry, previous, next, changedFields);
+  const results = [];
+  for (const target of targets) {
+    if (target.mode === "async") {
+      enqueueAsynchronousRecalculation(target);
+      results.push({ model: target.entry.name, mode: "async" });
+    } else {
+      results.push({
+        model: target.entry.name,
+        mode: "immediate",
+        ...(await recalculateTarget(target.entry, target.selectors, options)),
+      });
+    }
+  }
+  return results;
+}
+
+async function drainProcessJobs() {
+  await asynchronousQueue;
+}
+
+module.exports = {
+  compileMongoMatch,
+  recordMatches,
+  applyWorkflowRules,
+  applyAutomaticTransitions,
+  resolveBindingsForRecords,
+  prepareProcessMutation,
+  prepareProcessMutations,
+  assertAtomicInvariants,
+  assertDeleteAllowed,
+  withProcessTransaction,
+  recalculateDependents,
+  recalculateTarget,
+  drainProcessJobs,
+  toPlainRecord,
+};

package/src/manifest/referencePolicies.js

@@ -0,0 +1,121 @@
+"use strict";
+
+const registry = require("../core/registry");
+const { DomainRuleError, valuesEquivalent } = require("./domainRules");
+
+function idKey(value) {
+  if (value === null || value === undefined || value === "") return null;
+  if (typeof value === "object") {
+    if (value._id) return idKey(value._id);
+    if (typeof value.toHexString === "function") return String(value.toHexString());
+    return null;
+  }
+  return String(value);
+}
+
+function referenceValuesEquivalent(left, right) {
+  if (valuesEquivalent(left, right)) return true;
+  const leftKey = idKey(left);
+  const rightKey = idKey(right);
+  return leftKey !== null && rightKey !== null && leftKey === rightKey;
+}
+
+function queryWithSession(query, session) {
+  return session && query && typeof query.session === "function" ? query.session(session) : query;
+}
+
+function referenceError(rule, message, details = {}) {
+  throw new DomainRuleError(message || rule.message || "Referência inválida.", {
+    code: rule.code || "OON_REFERENCE_POLICY_FAILED",
+    statusCode: 422,
+    field: rule.field,
+    rule: "referencePolicy",
+    details,
+  });
+}
+
+function requiredProjection(rules) {
+  const fields = new Set(["_id"]);
+  for (const rule of rules) {
+    if (rule.active?.field) fields.add(rule.active.field);
+    for (const constraint of rule.constraints || []) {
+      if (constraint.sourceField) fields.add(constraint.sourceField);
+    }
+  }
+  return [...fields].join(" ");
+}
+
+function constraintMatches(constraint, source, local) {
+  const value = source?.[constraint.sourceField];
+  if (constraint.equalsField) {
+    return referenceValuesEquivalent(value, local?.[constraint.equalsField]);
+  }
+  if (Object.prototype.hasOwnProperty.call(constraint, "equals")) {
+    return valuesEquivalent(value, constraint.equals);
+  }
+  if (constraint.in) return constraint.in.some((candidate) => valuesEquivalent(value, candidate));
+  if (constraint.nin) return !constraint.nin.some((candidate) => valuesEquivalent(value, candidate));
+  if (constraint.empty === true) return value === null || value === undefined || value === "";
+  if (constraint.present === true) return value !== null && value !== undefined && value !== "";
+  return true;
+}
+
+async function assertReferencePolicies(entry, candidate, options = {}) {
+  const rules = entry.definition?.processRules?.references || [];
+  if (!rules.length) return;
+
+  const grouped = new Map();
+  for (const rule of rules) {
+    const id = idKey(candidate?.[rule.field]);
+    if (!id) {
+      if (rule.required !== false) referenceError(rule, rule.message || "Selecione um registro válido.");
+      continue;
+    }
+    const sourceEntry = registry.getModel(rule.sourceModel);
+    if (!sourceEntry) {
+      referenceError(rule, `Model de referência ${rule.sourceModel} não registrada.`);
+    }
+    const group = grouped.get(rule.sourceModel) || { entry: sourceEntry, rules: [], ids: new Map() };
+    group.rules.push({ rule, id });
+    group.ids.set(id, candidate[rule.field]);
+    grouped.set(rule.sourceModel, group);
+  }
+
+  for (const group of grouped.values()) {
+    let query = group.entry.mongooseModel
+      .find({ _id: { $in: [...group.ids.values()] } })
+      .select(requiredProjection(group.rules.map((item) => item.rule)));
+    query = queryWithSession(query, options.session);
+    const records = await query.lean();
+    const byId = new Map(records.map((record) => [idKey(record._id), record]));
+
+    for (const { rule, id } of group.rules) {
+      const source = byId.get(id);
+      if (!source) referenceError(rule, rule.message || "Registro relacionado não encontrado.", { id });
+      if (rule.active) {
+        const activeValue = Object.prototype.hasOwnProperty.call(rule.active, "value")
+          ? rule.active.value
+          : "Ativo";
+        if (!valuesEquivalent(source[rule.active.field], activeValue)) {
+          referenceError(rule, rule.active.message || rule.message || "Selecione um registro ativo.", {
+            id,
+            activeField: rule.active.field,
+          });
+        }
+      }
+      for (const constraint of rule.constraints || []) {
+        if (!constraintMatches(constraint, source, candidate)) {
+          referenceError(rule, constraint.message || rule.message, {
+            id,
+            sourceField: constraint.sourceField,
+          });
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  assertReferencePolicies,
+  constraintMatches,
+};