@oondemand/oon-core-back 0.3.45 → 0.3.47

package/README.md

@@ -21,6 +21,15 @@ Compatibilidade temporária: `CENTRAL_ATIVACAO_BACKEND_URL` e `MEUS_APPS_BACKEND
 
 Campos adicionais podem ser declarados em `activation.fields`; `password` e `secret` são sanitizados na configuração retornada ao frontend. Hooks opcionais: `validate`, `beforeComplete`, `afterComplete`.
 
+## Imagem de entrega
+
+O comando de delivery preserva `central.app.json` em dois pontos da imagem:
+
+- `/src/central.app.json` durante o build do frontend declarativo;
+- `/app/central.app.json` para descoberta pelo backend em runtime.
+
+Centrais legadas sem o manifesto continuam suportadas. O empacotador cria uma pasta intermediária vazia, evitando tornar `central.app.json` obrigatório para aplicações que ainda usam somente `central.config.js`.
+
 ## Rótulos de campos relacionados
 
 Por padrão, campos declarados com `fields.ref(...)` continuam sendo devolvidos pelo CRUD como `ObjectId`. Uma model pode optar pela população segura das referências usadas em grids e cards:
@@ -38,4 +47,4 @@ defineModel({
 });
 ```
 
-Use `populateRefs: true` para todas as referências da model ou informe uma lista explícita. O CRUD devolve somente `_id` e campos usuais de identificação, como nome, razão social, descrição, código, e-mail e campos pesquisáveis da model referenciada. Exportações mantêm os identificadores originais.
+Use `populateRefs: true` para todas as referências da model ou informe uma lista explícita. O CRUD devolve somente `_id` e campos usuais de identificação, como nome, razão social, descrição, código, e-mail e campos pesquisáveis da model referenciada. Exportações mantêm os identificadores originais.

package/package.json

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

package/src/boot/loadCentral.js

@@ -11,6 +11,10 @@ const {
   DOMAIN_MANIFEST_FILENAME,
   loadDomainManifest,
 } = require("../manifest/domainManifest");
+const {
+  PROCESS_MANIFEST_FILENAME,
+  loadProcessManifest,
+} = require("../manifest/processManifest");
 
 const DOMAIN_DIRS = [
   "models",
@@ -76,6 +80,11 @@ function loadCentral(cwd = process.cwd()) {
     loadDomainManifest(domainManifestPath);
   }
 
+  const processManifestPath = path.join(cwd, PROCESS_MANIFEST_FILENAME);
+  if (fs.existsSync(processManifestPath)) {
+    loadProcessManifest(processManifestPath);
+  }
+
   const srcDir = path.join(cwd, "src");
   for (const dir of DOMAIN_DIRS) {
     const full = path.join(srcDir, dir);
@@ -93,4 +102,9 @@ function requireDir(dir) {
   }
 }
 
-module.exports = { loadCentral, DOMAIN_DIRS, APP_CONFIG_KEYS, assertConfigBoundary };
+module.exports = {
+  loadCentral,
+  DOMAIN_DIRS,
+  APP_CONFIG_KEYS,
+  assertConfigBoundary,
+};

package/src/core/define.js

@@ -7,10 +7,6 @@ const auth = require("./middlewares/auth");
 const { rbac } = require("./middlewares/rbac");
 const { mutationAudit } = require("./middlewares/mutationAudit");
 
-/**
- * Constrói o schema Mongoose a partir dos descriptors de `fields`,
- * separando o bloco `__meta` (consumido apenas por /core/metadata).
- */
 function buildSchema(schemaDef, options = {}) {
   const mongooseShape = {};
   const metaFields = {};
@@ -23,12 +19,19 @@ function buildSchema(schemaDef, options = {}) {
       metaFields[key] = { name: key, ...__meta };
       if (__meta.kind === "string" && __meta.searchable) searchableFields.push(key);
     } else {
-      // Descriptor cru (compatível com Mongoose puro).
       mongooseShape[key] = descriptor;
       metaFields[key] = { name: key, kind: "raw" };
     }
   }
 
+  if (!Object.prototype.hasOwnProperty.call(mongooseShape, "__oonInvariantVersion")) {
+    mongooseShape.__oonInvariantVersion = {
+      type: Number,
+      default: 0,
+      select: false,
+    };
+  }
+
   const schema = new mongoose.Schema(mongooseShape, {
     timestamps: true,
     ...options,
@@ -37,10 +40,6 @@ function buildSchema(schemaDef, options = {}) {
   return { schema, metaFields, searchableFields };
 }
 
-/**
- * defineModel — registra a model e gera derivações automáticas
- * (schema, CRUD, RBAC, paginação, validação, auditoria, metadata).
- */
 function defineModel(definition) {
   if (!definition?.name) throw new Error("defineModel requer `name`.");
   if (!definition?.schema) throw new Error(`defineModel("${definition.name}") requer \`schema\`.`);
@@ -50,7 +49,6 @@ function defineModel(definition) {
     definition.options
   );
 
-  // Hooks de domínio (defineTrigger) ligados ao ciclo do documento.
   schema.pre("save", async function (next) {
     try {
       const { before } = registry.getTriggers(definition.name);
@@ -77,7 +75,6 @@ function defineModel(definition) {
     searchableFields,
   });
 
-  // Permissões/actions derivadas para o front.
   if (definition.crud?.enabled !== false) {
     registry.registerFeature(definition.name, {
       model: definition.name,
@@ -89,10 +86,6 @@ function defineModel(definition) {
   return entry;
 }
 
-/**
- * defineCentral — declara metadados da Central (módulos ativos + paths de
- * domínio). Mescla na config de runtime.
- */
 function defineCentral(config = {}) {
   ctx.setConfig(config);
   return ctx.config;
@@ -122,11 +115,6 @@ function defineOmieMapping(name, config) {
   return registry.registerOmieMapping(name, { name, ...config });
 }
 
-/**
- * defineRoutes — rotas customizadas com o contrato de segurança do Core.
- * Entrega `router.private.*` (auth + RBAC + mutationAudit) e
- * `router.public.*`. NUNCA expõe `express.Router()` cru.
- */
 function defineRoutes(basePath, builder) {
   const expressRouter = express.Router();
 
@@ -168,4 +156,4 @@ module.exports = {
   definePipeline,
   defineOmieMapping,
   defineRoutes,
-};
+};

package/src/core/factories/crudController.js

@@ -1,14 +1,14 @@
 const Helpers = require("../utils/helpers");
 const registry = require("../registry");
-const { applyDomainMutation } = require("../../manifest/domainRules");
-
-function toPlainRecord(record) {
-  if (!record || typeof record !== "object") return {};
-  if (typeof record.toObject === "function") {
-    return record.toObject({ depopulate: true });
-  }
-  return { ...record };
-}
+const {
+  prepareProcessMutation,
+  assertAtomicInvariants,
+  assertDeleteAllowed,
+  withProcessTransaction,
+  recalculateDependents,
+  toPlainRecord,
+} = require("../../manifest/processRuntime");
+const { assertReferencePolicies } = require("../../manifest/referencePolicies");
 
 function hasDomainRules(entry) {
   const rules = entry?.definition?.domainRules;
@@ -20,28 +20,31 @@ function hasDomainRules(entry) {
   );
 }
 
-/**
- * Controllers HTTP de CRUD ligados a um service. Aplica regras declarativas do
- * manifesto e validações registradas via `defineValidation` antes de persistir.
- *
- * Atualizações podem chegar parcialmente pelo formulário em abas ou pelo
- * datagrid. Nesses casos, fórmulas e validações recebem o registro consolidado,
- * enquanto o service persiste somente os campos enviados e calculados.
- */
+function hasProcessRules(entry) {
+  const rules = entry?.definition?.processRules;
+  return Boolean(
+    rules
+    && (rules.workflow
+      || (rules.bindings || []).length
+      || (rules.references || []).length
+      || (rules.deleteProtection || []).length
+      || (rules.atomicInvariants || []).length),
+  );
+}
+
 function createCrudController(entry, service) {
   const runCustomValidation = async (data, context) => {
     const validate = registry.getValidation(entry.name);
     if (validate) await validate(data, context);
   };
 
-  const prepareCreate = async (data, method = "post") => {
-    const prepared = applyDomainMutation({
-      rules: entry.definition?.domainRules,
-      current: null,
-      changes: data,
+  const prepareCreate = async (data, method = "post", session = null) => {
+    const prepared = await prepareProcessMutation(entry, {}, data, {
       op: "create",
+      session,
     });
 
+    await assertReferencePolicies(entry, prepared.consolidated, { session });
     await runCustomValidation(prepared.consolidated, {
       op: "create",
       method,
@@ -49,31 +52,33 @@ function createCrudController(entry, service) {
       requestedChanges: prepared.requestedChanges,
       changes: prepared.changes,
       consolidated: prepared.consolidated,
+      changedFields: prepared.changedFields,
+      session,
     });
     return prepared;
   };
 
-  const prepareUpdate = async (id, changes, method) => {
+  const prepareUpdate = async (id, changes, method, session = null) => {
     const validate = registry.getValidation(entry.name);
-    if (!validate && !hasDomainRules(entry)) {
+    if (!validate && !hasDomainRules(entry) && !hasProcessRules(entry)) {
       const normalizedChanges = changes && typeof changes === "object" ? { ...changes } : {};
       return {
         current: null,
         requestedChanges: normalizedChanges,
         changes: normalizedChanges,
         consolidated: normalizedChanges,
+        changedFields: Object.keys(normalizedChanges),
       };
     }
 
-    const currentRecord = await service.getById(id);
+    const currentRecord = await service.getById(id, { session });
     const current = toPlainRecord(currentRecord);
-    const prepared = applyDomainMutation({
-      rules: entry.definition?.domainRules,
-      current,
-      changes,
+    const prepared = await prepareProcessMutation(entry, current, changes, {
       op: "update",
+      session,
     });
 
+    await assertReferencePolicies(entry, prepared.consolidated, { session });
     if (validate) {
       await validate(prepared.consolidated, {
         op: "update",
@@ -83,12 +88,36 @@ function createCrudController(entry, service) {
         requestedChanges: prepared.requestedChanges,
         changes: prepared.changes,
         consolidated: prepared.consolidated,
+        changedFields: prepared.changedFields,
+        session,
       });
     }
 
     return { current, ...prepared };
   };
 
+  async function createOne(data, method, session) {
+    const prepared = await prepareCreate(data, method, session);
+    await assertAtomicInvariants(entry, prepared.consolidated, null, session);
+    const record = await service.create(prepared.changes, { session });
+    await recalculateDependents(entry, null, toPlainRecord(record), {
+      session,
+      changedFields: prepared.changedFields,
+    });
+    return record;
+  }
+
+  async function updateOne(id, changes, method, session) {
+    const prepared = await prepareUpdate(id, changes, method, session);
+    await assertAtomicInvariants(entry, prepared.consolidated, prepared.current, session);
+    const record = await service.update(id, prepared.changes, { session });
+    await recalculateDependents(entry, prepared.current, toPlainRecord(record), {
+      session,
+      changedFields: prepared.changedFields,
+    });
+    return record;
+  }
+
   return {
     async list(req, res) {
       const { pageIndex, pageSize, searchTerm, sort, ...filtros } = req.query;
@@ -108,35 +137,69 @@ function createCrudController(entry, service) {
     },
 
     async create(req, res) {
-      const prepared = await prepareCreate(req.body ?? {}, "post");
-      const registro = await service.create(prepared.changes);
+      const registro = await withProcessTransaction(
+        entry,
+        (session) => createOne(req.body ?? {}, "post", session),
+      );
       Helpers.sendResponse({ res, statusCode: 201, [entry.singular]: registro });
     },
 
     async update(req, res) {
-      const prepared = await prepareUpdate(req.params.id, req.body ?? {}, "put");
-      const registro = await service.update(req.params.id, prepared.changes);
+      const registro = await withProcessTransaction(
+        entry,
+        (session) => updateOne(req.params.id, req.body ?? {}, "put", session),
+      );
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async patch(req, res) {
-      const prepared = await prepareUpdate(req.params.id, req.body ?? {}, "patch");
-      const registro = await service.update(req.params.id, prepared.changes);
+      const registro = await withProcessTransaction(
+        entry,
+        (session) => updateOne(req.params.id, req.body ?? {}, "patch", session),
+      );
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async remove(req, res) {
-      const registro = await service.remove(req.params.id);
+      const registro = await withProcessTransaction(entry, async (session) => {
+        const currentRecord = await service.getById(req.params.id, { session });
+        const current = toPlainRecord(currentRecord);
+        await assertDeleteAllowed(entry, req.params.id, { session });
+        const removed = await service.remove(req.params.id, { session });
+        await recalculateDependents(entry, current, null, {
+          session,
+          changedFields: Object.keys(current),
+        });
+        return removed;
+      });
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async importMany(req, res) {
       const rows = req.body?.rows || req.body;
-      const preparedRows = Array.isArray(rows)
-        ? await Promise.all(rows.map(async (row) => (await prepareCreate(row, "import")).changes))
-        : rows;
-      const result = await service.importMany(preparedRows);
-      Helpers.sendResponse({ res, statusCode: 201, ...result });
+      if (!Array.isArray(rows)) {
+        const result = await service.importMany(rows);
+        Helpers.sendResponse({ res, statusCode: 201, ...result });
+        return;
+      }
+
+      if (!hasProcessRules(entry)) {
+        const preparedRows = await Promise.all(
+          rows.map(async (row) => (await prepareCreate(row, "import")).changes),
+        );
+        const result = await service.importMany(preparedRows);
+        Helpers.sendResponse({ res, statusCode: 201, ...result });
+        return;
+      }
+
+      let inserted = 0;
+      for (const row of rows) {
+        await withProcessTransaction(entry, async (session) => {
+          await createOne(row, "import", session);
+          inserted += 1;
+        });
+      }
+      Helpers.sendResponse({ res, statusCode: 201, inserted });
     },
 
     async exportAll(req, res) {
@@ -146,4 +209,9 @@ function createCrudController(entry, service) {
   };
 }
 
-module.exports = { createCrudController, toPlainRecord, hasDomainRules };
+module.exports = {
+  createCrudController,
+  toPlainRecord,
+  hasDomainRules,
+  hasProcessRules,
+};

package/src/core/factories/crudService.js

@@ -15,11 +15,6 @@ const COMMON_REFERENCE_LABEL_FIELDS = [
   "sigla",
 ];
 
-/**
- * Gera especificações de populate somente quando a model opta explicitamente
- * por `crud.populateRefs`. O select é restrito a campos de identificação para
- * evitar devolver o documento relacionado inteiro nas listagens genéricas.
- */
 function referencePopulateSpecs(entry) {
   const setting = entry.definition?.crud?.populateRefs;
   if (!setting) return [];
@@ -52,10 +47,6 @@ function populateQuery(query, specs) {
   return specs.length ? query.populate(specs) : query;
 }
 
-/**
- * Aceita tanto uma Query Mongoose quanto uma Promise/Document devolvida por
- * uma model que sobrescreveu métodos como `findByIdAndUpdate`.
- */
 async function resolvePopulated(result, specs) {
   if (!specs.length) return result;
   if (result && typeof result.populate === "function") {
@@ -67,10 +58,10 @@ async function resolvePopulated(result, specs) {
   return doc;
 }
 
-/**
- * Gera um service de CRUD genérico para uma model registrada.
- * Cobre paginação, filtros, busca textual, ordenação, import e export.
- */
+function withSession(query, session) {
+  return session && query && typeof query.session === "function" ? query.session(session) : query;
+}
+
 function createCrudService(entry) {
   const { mongooseModel: Model, searchableFields } = entry;
   const populateSpecs = referencePopulateSpecs(entry);
@@ -106,40 +97,44 @@ function createCrudService(entry) {
     };
   }
 
-  async function getById(id) {
-    const doc = await resolvePopulated(Model.findById(id), populateSpecs);
+  async function getById(id, options = {}) {
+    const query = withSession(Model.findById(id), options.session);
+    const doc = await resolvePopulated(query, populateSpecs);
     if (!doc) throw new GenericError("Registro não encontrado.", { statusCode: 404 });
     return doc;
   }
 
-  async function create(data) {
-    const doc = await Model.create(data);
+  async function create(data, options = {}) {
+    const doc = new Model(data);
+    await doc.save({ session: options.session || undefined });
     return resolvePopulated(doc, populateSpecs);
   }
 
-  async function update(id, data) {
-    const doc = await resolvePopulated(
-      Model.findByIdAndUpdate(id, data, {
-        new: true,
-        runValidators: true,
-      }),
-      populateSpecs
-    );
+  async function update(id, data, options = {}) {
+    const query = Model.findByIdAndUpdate(id, data, {
+      new: true,
+      runValidators: true,
+      session: options.session || undefined,
+    });
+    const doc = await resolvePopulated(query, populateSpecs);
     if (!doc) throw new GenericError("Registro não encontrado.", { statusCode: 404 });
     return doc;
   }
 
-  async function remove(id) {
-    const doc = await Model.findByIdAndDelete(id);
+  async function remove(id, options = {}) {
+    const doc = await withSession(Model.findByIdAndDelete(id), options.session);
     if (!doc) throw new GenericError("Registro não encontrado.", { statusCode: 404 });
     return doc;
   }
 
-  async function importMany(rows = []) {
+  async function importMany(rows = [], options = {}) {
     if (!Array.isArray(rows)) {
       throw new GenericError("Esperado um array de registros.", { statusCode: 400 });
     }
-    const docs = await Model.insertMany(rows, { ordered: false });
+    const docs = await Model.insertMany(rows, {
+      ordered: false,
+      session: options.session || undefined,
+    });
     return { inserted: docs.length };
   }
 
@@ -160,7 +155,6 @@ function cleanFilters(filtros) {
 
 function parseSort(sort) {
   if (!sort) return { createdAt: -1 };
-  // "campo:asc" | "campo:desc" | "campo"
   const [field, dir] = String(sort).split(":");
   return { [field]: dir === "asc" ? 1 : -1 };
 }

package/src/delivery/buildImage.js

@@ -10,6 +10,7 @@ WORKDIR /src/frontend
 COPY frontend/package*.json ./
 RUN if [ -f package-lock.json ]; then npm ci; else npm install; fi
 COPY frontend/ ./
+COPY .oon-delivery/app-manifest/ /src/
 ARG VITE_API_URL=/api
 ENV VITE_API_URL=$VITE_API_URL
 RUN npm run build
@@ -25,6 +26,7 @@ RUN apk add --no-cache nginx curl
 WORKDIR /app
 ENV NODE_ENV=production
 COPY --from=backend /app/backend /app/backend
+COPY .oon-delivery/app-manifest/ /app/
 COPY --from=frontend /src/frontend/dist /usr/share/nginx/html
 COPY .oon-delivery/nginx.conf /etc/nginx/http.d/default.conf
 COPY .oon-delivery/entrypoint.sh /entrypoint.sh
@@ -60,9 +62,25 @@ trap 'kill $backend_pid 2>/dev/null || true' TERM INT EXIT
 exec nginx -g 'daemon off;'
 `;
 
+function prepareAppManifest(workspace, deliveryDirectory) {
+  const manifestDirectory = path.join(deliveryDirectory, "app-manifest");
+  const manifestSource = path.join(workspace, "central.app.json");
+  const manifestTarget = path.join(manifestDirectory, "central.app.json");
+
+  fs.rmSync(manifestDirectory, { recursive: true, force: true });
+  fs.mkdirSync(manifestDirectory, { recursive: true });
+
+  if (fs.existsSync(manifestSource)) {
+    fs.copyFileSync(manifestSource, manifestTarget);
+  }
+
+  return manifestTarget;
+}
+
 function prepareDeliveryFiles(workspace) {
   const target = path.join(workspace, ".oon-delivery");
   fs.mkdirSync(target, { recursive: true });
+  prepareAppManifest(workspace, target);
   fs.writeFileSync(path.join(target, "Dockerfile"), DOCKERFILE);
   fs.writeFileSync(path.join(target, "nginx.conf"), NGINX);
   fs.writeFileSync(path.join(target, "entrypoint.sh"), ENTRYPOINT, {
@@ -82,6 +100,7 @@ module.exports = {
   DOCKERFILE,
   NGINX,
   ENTRYPOINT,
+  prepareAppManifest,
   prepareDeliveryFiles,
   buildImage,
 };

package/src/index.js

@@ -11,6 +11,9 @@ const { omie } = require("./modules/omie");
 const appManifest = require("./manifest/appManifest");
 const domainManifest = require("./manifest/domainManifest");
 const domainRules = require("./manifest/domainRules");
+const processManifest = require("./manifest/processManifest");
+const processRuntime = require("./manifest/processRuntime");
+const referencePolicies = require("./manifest/referencePolicies");
 
 module.exports = {
   start,
@@ -49,9 +52,25 @@ module.exports = {
   loadDomainManifest: domainManifest.loadDomainManifest,
   evaluateDomainExpression: domainRules.evaluateDomainExpression,
   applyDomainMutation: domainRules.applyDomainMutation,
+  validateDomainRecord: domainRules.validateDomainRecord,
+  detectChangedFields: domainRules.detectChangedFields,
+
+  PROCESS_MANIFEST_FILENAME: processManifest.PROCESS_MANIFEST_FILENAME,
+  PROCESS_MANIFEST_SCHEMA_VERSION: processManifest.PROCESS_MANIFEST_SCHEMA_VERSION,
+  ProcessManifestError: processManifest.ProcessManifestError,
+  validateProcessManifest: processManifest.validateProcessManifest,
+  registerProcessManifest: processManifest.registerProcessManifest,
+  loadProcessManifest: processManifest.loadProcessManifest,
+  prepareProcessMutation: processRuntime.prepareProcessMutation,
+  resolveProcessBindings: processRuntime.resolveBindingsForRecords,
+  assertReferencePolicies: referencePolicies.assertReferencePolicies,
+  assertAtomicInvariants: processRuntime.assertAtomicInvariants,
+  assertDeleteAllowed: processRuntime.assertDeleteAllowed,
+  recalculateDependents: processRuntime.recalculateDependents,
+  drainProcessJobs: processRuntime.drainProcessJobs,
 
   fields,
   omie,
   GenericError,
   registry,
-};
+};