@oondemand/oon-core-back 0.3.38 → 0.3.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oondemand/oon-core-back",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oondemand/oon-platform.git",

package/src/boot/loadCentral.js

@@ -1,13 +1,22 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const ctx = require("../core/context");
+const {
+  DOMAIN_MANIFEST_FILENAME,
+  loadDomainManifest,
+} = require("../manifest/domainManifest");
 
 /**
  * Descobre e carrega a Central do consumidor:
  *   1. `central.config.js` na raiz do projeto (mescla na config do Core);
- *   2. arquivos de domínio em `src/{models,validations,triggers,routes,
+ *   2. `central.domain.json` na raiz (registra models declarativas);
+ *   3. arquivos de domínio em `src/{models,validations,triggers,routes,
  *      pipelines,documents,integrations,mappings}` (apenas `require`,
  *      o efeito colateral é registrar via `define*`).
+ *
+ * O carregamento dos diretórios JavaScript permanece ativo durante a migração.
+ * Declarar a mesma model no manifesto e em `src/models` falha explicitamente no
+ * registry, impedindo duas fontes de verdade silenciosas.
  */
 const DOMAIN_DIRS = [
   "models",
@@ -28,6 +37,11 @@ function loadCentral(cwd = process.cwd()) {
     ctx.setConfig(typeof config === "function" ? config() : config);
   }
 
+  const domainManifestPath = path.join(cwd, DOMAIN_MANIFEST_FILENAME);
+  if (fs.existsSync(domainManifestPath)) {
+    loadDomainManifest(domainManifestPath);
+  }
+
   const srcDir = path.join(cwd, "src");
   for (const dir of DOMAIN_DIRS) {
     const full = path.join(srcDir, dir);

package/src/index.js

@@ -15,6 +15,7 @@ const fields = require("./core/fields");
 const registry = require("./core/registry");
 const GenericError = require("./core/errors/GenericError");
 const { omie } = require("./modules/omie");
+const domainManifest = require("./manifest/domainManifest");
 
 module.exports = {
   // boot
@@ -33,6 +34,16 @@ module.exports = {
   defineValidation: define.defineValidation,
   defineTrigger: define.defineTrigger,
 
+  // manifesto declarativo de domínio
+  DOMAIN_MANIFEST_FILENAME: domainManifest.DOMAIN_MANIFEST_FILENAME,
+  DOMAIN_MANIFEST_SCHEMA_VERSION: domainManifest.DOMAIN_MANIFEST_SCHEMA_VERSION,
+  SUPPORTED_DOMAIN_FIELD_KINDS: domainManifest.SUPPORTED_FIELD_KINDS,
+  DomainManifestError: domainManifest.DomainManifestError,
+  validateDomainManifest: domainManifest.validateDomainManifest,
+  domainManifestToDefinitions: domainManifest.domainManifestToDefinitions,
+  registerDomainManifest: domainManifest.registerDomainManifest,
+  loadDomainManifest: domainManifest.loadDomainManifest,
+
   // helpers
   fields,
   omie,

package/src/manifest/domainManifest.js

@@ -0,0 +1,335 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { defineModel } = require("../core/define");
+const fields = require("../core/fields");
+
+const DOMAIN_MANIFEST_FILENAME = "central.domain.json";
+const DOMAIN_MANIFEST_SCHEMA_VERSION = 1;
+const SUPPORTED_FIELD_KINDS = Object.freeze([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "ref",
+  "enum",
+  "currency",
+  "currencyCode",
+  "currencyConverted",
+]);
+const SUPPORTED_FIELD_KIND_SET = new Set(SUPPORTED_FIELD_KINDS);
+
+class DomainManifestError extends Error {
+  constructor(message, issues = [], options = {}) {
+    super(message, options);
+    this.name = "DomainManifestError";
+    this.code = "OON_DOMAIN_MANIFEST_INVALID";
+    this.statusCode = 422;
+    this.issues = issues;
+    this.details = { 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 isJsonValue(value, seen = new Set()) {
+  if (value === null) return true;
+  if (["string", "number", "boolean"].includes(typeof value)) {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (typeof value !== "object" || seen.has(value)) return false;
+
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const valid = value.every((item) => isJsonValue(item, seen));
+    seen.delete(value);
+    return valid;
+  }
+
+  const valid = Object.values(value).every((item) => isJsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+
+function validateBooleanOption(field, optionName, fieldPath, issues) {
+  if (hasOwn(field, optionName) && typeof field[optionName] !== "boolean") {
+    addIssue(issues, `${fieldPath}.${optionName}`, "deve ser booleano.");
+  }
+}
+
+function validateNumberOption(field, optionName, fieldPath, issues) {
+  if (hasOwn(field, optionName)
+    && (typeof field[optionName] !== "number" || !Number.isFinite(field[optionName]))) {
+    addIssue(issues, `${fieldPath}.${optionName}`, "deve ser um número finito.");
+  }
+}
+
+function validateField(fieldName, field, fieldPath, issues) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(fieldName)) {
+    addIssue(issues, fieldPath, "o nome do campo deve ser um identificador JavaScript válido.");
+  }
+  if (!isPlainObject(field)) {
+    addIssue(issues, fieldPath, "deve ser um objeto.");
+    return;
+  }
+  if (!SUPPORTED_FIELD_KIND_SET.has(field.kind)) {
+    addIssue(
+      issues,
+      `${fieldPath}.kind`,
+      `tipo não suportado. Use: ${SUPPORTED_FIELD_KINDS.join(", ")}.`,
+    );
+  }
+  if (hasOwn(field, "label") && typeof field.label !== "string") {
+    addIssue(issues, `${fieldPath}.label`, "deve ser texto.");
+  }
+  if (hasOwn(field, "description") && typeof field.description !== "string") {
+    addIssue(issues, `${fieldPath}.description`, "deve ser texto.");
+  }
+
+  for (const optionName of ["required", "readonly", "searchable", "unique", "index"]) {
+    validateBooleanOption(field, optionName, fieldPath, issues);
+  }
+  for (const optionName of ["min", "max", "minLength", "maxLength"]) {
+    validateNumberOption(field, optionName, fieldPath, issues);
+  }
+  if (typeof field.min === "number" && typeof field.max === "number" && field.min > field.max) {
+    addIssue(issues, fieldPath, "min não pode ser maior que max.");
+  }
+  if (typeof field.minLength === "number"
+    && typeof field.maxLength === "number"
+    && field.minLength > field.maxLength) {
+    addIssue(issues, fieldPath, "minLength não pode ser maior que maxLength.");
+  }
+  if (hasOwn(field, "default") && !isJsonValue(field.default)) {
+    addIssue(issues, `${fieldPath}.default`, "deve conter somente um valor JSON.");
+  }
+
+  if (field.kind === "ref" && (typeof field.ref !== "string" || !field.ref.trim())) {
+    addIssue(issues, `${fieldPath}.ref`, "é obrigatório para campos ref.");
+  }
+  if (field.kind === "enum") {
+    if (!Array.isArray(field.values) || field.values.length === 0) {
+      addIssue(issues, `${fieldPath}.values`, "deve ser uma lista não vazia para campos enum.");
+    } else {
+      const invalid = field.values.some((value) => typeof value !== "string" || !value.length);
+      if (invalid) addIssue(issues, `${fieldPath}.values`, "deve conter somente textos não vazios.");
+      if (new Set(field.values).size !== field.values.length) {
+        addIssue(issues, `${fieldPath}.values`, "não pode conter valores duplicados.");
+      }
+    }
+  }
+  if (field.kind === "currencyConverted"
+    && hasOwn(field, "base")
+    && (typeof field.base !== "string" || !/^[A-Za-z]{3}$/.test(field.base))) {
+    addIssue(issues, `${fieldPath}.base`, "deve ser um código de moeda com três letras.");
+  }
+}
+
+function validateModel(model, index, issues, modelNames) {
+  const modelPath = `models[${index}]`;
+  if (!isPlainObject(model)) {
+    addIssue(issues, modelPath, "deve ser um objeto.");
+    return;
+  }
+  if (typeof model.name !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(model.name)) {
+    addIssue(issues, `${modelPath}.name`, "deve começar com letra maiúscula e conter apenas letras e números.");
+  } else if (modelNames.has(model.name)) {
+    addIssue(issues, `${modelPath}.name`, `model duplicada: ${model.name}.`);
+  } else {
+    modelNames.add(model.name);
+  }
+  if (hasOwn(model, "singular") && (typeof model.singular !== "string" || !model.singular.trim())) {
+    addIssue(issues, `${modelPath}.singular`, "deve ser texto não vazio.");
+  }
+  if (hasOwn(model, "basePath")
+    && (typeof model.basePath !== "string" || !/^\/[a-z0-9][a-z0-9/_-]*$/i.test(model.basePath))) {
+    addIssue(issues, `${modelPath}.basePath`, "deve ser um caminho iniciado por /.");
+  }
+  if (hasOwn(model, "crud") && !isPlainObject(model.crud)) {
+    addIssue(issues, `${modelPath}.crud`, "deve ser um objeto.");
+  }
+  if (hasOwn(model, "options") && !isPlainObject(model.options)) {
+    addIssue(issues, `${modelPath}.options`, "deve ser um objeto.");
+  }
+  if (!isPlainObject(model.fields) || Object.keys(model.fields).length === 0) {
+    addIssue(issues, `${modelPath}.fields`, "deve ser um objeto com pelo menos um campo.");
+    return;
+  }
+
+  for (const [fieldName, field] of Object.entries(model.fields)) {
+    validateField(fieldName, field, `${modelPath}.fields.${fieldName}`, issues);
+  }
+}
+
+function validateDomainManifest(input) {
+  const issues = [];
+  if (!isPlainObject(input)) {
+    throw new DomainManifestError("Manifesto de domínio inválido.", [
+      { path: "$", message: "o documento deve ser um objeto JSON." },
+    ]);
+  }
+  if (input.schemaVersion !== DOMAIN_MANIFEST_SCHEMA_VERSION) {
+    addIssue(
+      issues,
+      "schemaVersion",
+      `versão não suportada. Use ${DOMAIN_MANIFEST_SCHEMA_VERSION}.`,
+    );
+  }
+  if (typeof input.name !== "string" || !input.name.trim()) {
+    addIssue(issues, "name", "é obrigatório e deve ser texto não vazio.");
+  }
+  if (hasOwn(input, "slug")
+    && (typeof input.slug !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input.slug))) {
+    addIssue(issues, "slug", "deve usar letras minúsculas, números e hífens.");
+  }
+  if (!Array.isArray(input.models) || input.models.length === 0) {
+    addIssue(issues, "models", "deve ser uma lista com pelo menos uma model.");
+  } else {
+    const modelNames = new Set();
+    input.models.forEach((model, index) => validateModel(model, index, issues, modelNames));
+  }
+
+  if (issues.length) {
+    throw new DomainManifestError(
+      `Manifesto de domínio inválido: ${issues.length} problema(s) encontrado(s).`,
+      issues,
+    );
+  }
+
+  return JSON.parse(JSON.stringify(input));
+}
+
+function baseFieldOptions(field) {
+  const options = {
+    required: field.required,
+    label: field.label,
+    searchable: field.searchable,
+  };
+  if (hasOwn(field, "default")) options.default = field.default;
+  return options;
+}
+
+function createFieldDescriptor(field) {
+  const options = baseFieldOptions(field);
+  let descriptor;
+
+  switch (field.kind) {
+    case "string":
+      descriptor = fields.string(options);
+      break;
+    case "number":
+      descriptor = fields.number(options);
+      break;
+    case "boolean":
+      descriptor = fields.boolean(options);
+      break;
+    case "date":
+      descriptor = fields.date(options);
+      break;
+    case "ref":
+      descriptor = fields.ref(field.ref, options);
+      break;
+    case "enum":
+      descriptor = fields.enum(field.values, options);
+      break;
+    case "currency":
+      descriptor = fields.currency(options);
+      break;
+    case "currencyCode":
+      descriptor = fields.currencyCode(options);
+      break;
+    case "currencyConverted":
+      descriptor = fields.currencyConverted({ ...options, base: field.base });
+      break;
+    default:
+      throw new DomainManifestError("Tipo de campo não suportado após validação.", [
+        { path: "kind", message: String(field.kind) },
+      ]);
+  }
+
+  if (field.readonly) descriptor.immutable = true;
+  if (field.unique) descriptor.unique = true;
+  if (field.index) descriptor.index = true;
+  if (typeof field.min === "number") descriptor.min = field.min;
+  if (typeof field.max === "number") descriptor.max = field.max;
+  if (typeof field.minLength === "number") descriptor.minlength = field.minLength;
+  if (typeof field.maxLength === "number") descriptor.maxlength = field.maxLength;
+
+  descriptor.__meta = {
+    ...descriptor.__meta,
+    description: field.description,
+    readonly: Boolean(field.readonly),
+    unique: Boolean(field.unique),
+    index: Boolean(field.index),
+  };
+  return descriptor;
+}
+
+function domainManifestToDefinitions(input) {
+  const manifest = validateDomainManifest(input);
+  return manifest.models.map((model) => ({
+    name: model.name,
+    singular: model.singular,
+    basePath: model.basePath,
+    crud: model.crud,
+    options: model.options,
+    schema: Object.fromEntries(
+      Object.entries(model.fields).map(([fieldName, field]) => [
+        fieldName,
+        createFieldDescriptor(field),
+      ]),
+    ),
+  }));
+}
+
+function registerDomainManifest(input) {
+  const definitions = domainManifestToDefinitions(input);
+  return definitions.map((definition) => defineModel(definition));
+}
+
+function loadDomainManifest(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 DomainManifestError(
+        `JSON inválido em ${resolvedPath}.`,
+        [{ path: "$", message: error.message }],
+        { cause: error },
+      );
+    }
+    throw error;
+  }
+
+  const manifest = validateDomainManifest(parsed);
+  const definitions = domainManifestToDefinitions(manifest);
+  const entries = options.register === false
+    ? []
+    : definitions.map((definition) => defineModel(definition));
+
+  return { filePath: resolvedPath, manifest, definitions, entries };
+}
+
+module.exports = {
+  DOMAIN_MANIFEST_FILENAME,
+  DOMAIN_MANIFEST_SCHEMA_VERSION,
+  SUPPORTED_FIELD_KINDS,
+  DomainManifestError,
+  validateDomainManifest,
+  domainManifestToDefinitions,
+  registerDomainManifest,
+  loadDomainManifest,
+};