@oondemand/oon-core-back 0.3.74 → 0.3.76

package/src/core/factories/crudController.js

@@ -1,5 +1,6 @@
 const Helpers = require("../utils/helpers");
 const registry = require("../registry");
+const { scopeMutation } = require("../tenancy");
 const {
   prepareProcessMutation,
   assertAtomicInvariants,
@@ -38,13 +39,27 @@ function createCrudController(entry, service) {
     if (validate) await validate(data, context);
   };
 
-  const prepareCreate = async (data, method = "post", session = null) => {
-    const prepared = await prepareProcessMutation(entry, {}, data, {
+  const prepareCreate = async (
+    data,
+    method = "post",
+    session = null,
+    accessContext = undefined,
+  ) => {
+    const scopedData = scopeMutation(entry, data, accessContext);
+    const prepared = await prepareProcessMutation(entry, {}, scopedData, {
       op: "create",
       session,
+      accessContext,
     });
 
-    await assertReferencePolicies(entry, prepared.consolidated, { session });
+    // Reaplica o escopo depois das regras para impedir que fórmula/hook de
+    // domínio substitua tenantId/usuarioId confiável. O controller usa o
+    // contrato público de tenancy e não exige helpers extras em services
+    // customizados/legados.
+    prepared.changes = scopeMutation(entry, prepared.changes, accessContext);
+    prepared.consolidated = scopeMutation(entry, prepared.consolidated, accessContext);
+
+    await assertReferencePolicies(entry, prepared.consolidated, { session, accessContext });
     await runCustomValidation(prepared.consolidated, {
       op: "create",
       method,
@@ -54,14 +69,24 @@ function createCrudController(entry, service) {
       consolidated: prepared.consolidated,
       changedFields: prepared.changedFields,
       session,
+      accessContext,
     });
     return prepared;
   };
 
-  const prepareUpdate = async (id, changes, method, session = null) => {
+  const prepareUpdate = async (
+    id,
+    changes,
+    method,
+    session = null,
+    accessContext = undefined,
+  ) => {
+    const scopedChanges = scopeMutation(entry, changes, accessContext);
     const validate = registry.getValidation(entry.name);
     if (!validate && !hasDomainRules(entry) && !hasProcessRules(entry)) {
-      const normalizedChanges = changes && typeof changes === "object" ? { ...changes } : {};
+      const normalizedChanges = scopedChanges && typeof scopedChanges === "object"
+        ? { ...scopedChanges }
+        : {};
       return {
         current: null,
         requestedChanges: normalizedChanges,
@@ -71,14 +96,17 @@ function createCrudController(entry, service) {
       };
     }
 
-    const currentRecord = await service.getById(id, { session });
+    const currentRecord = await service.getById(id, { session, accessContext });
     const current = toPlainRecord(currentRecord);
-    const prepared = await prepareProcessMutation(entry, current, changes, {
+    const prepared = await prepareProcessMutation(entry, current, scopedChanges, {
       op: "update",
       session,
+      accessContext,
     });
+    prepared.changes = scopeMutation(entry, prepared.changes, accessContext);
+    prepared.consolidated = scopeMutation(entry, prepared.consolidated, accessContext);
 
-    await assertReferencePolicies(entry, prepared.consolidated, { session });
+    await assertReferencePolicies(entry, prepared.consolidated, { session, accessContext });
     if (validate) {
       await validate(prepared.consolidated, {
         op: "update",
@@ -90,30 +118,33 @@ function createCrudController(entry, service) {
         consolidated: prepared.consolidated,
         changedFields: prepared.changedFields,
         session,
+        accessContext,
       });
     }
 
     return { current, ...prepared };
   };
 
-  async function createOne(data, method, session) {
-    const prepared = await prepareCreate(data, method, session);
+  async function createOne(data, method, session, accessContext) {
+    const prepared = await prepareCreate(data, method, session, accessContext);
     await assertAtomicInvariants(entry, prepared.consolidated, null, session);
-    const record = await service.create(prepared.changes, { session });
+    const record = await service.create(prepared.changes, { session, accessContext });
     await recalculateDependents(entry, null, toPlainRecord(record), {
       session,
       changedFields: prepared.changedFields,
+      accessContext,
     });
     return record;
   }
 
-  async function updateOne(id, changes, method, session) {
-    const prepared = await prepareUpdate(id, changes, method, session);
+  async function updateOne(id, changes, method, session, accessContext) {
+    const prepared = await prepareUpdate(id, changes, method, session, accessContext);
     await assertAtomicInvariants(entry, prepared.consolidated, prepared.current, session);
-    const record = await service.update(id, prepared.changes, { session });
+    const record = await service.update(id, prepared.changes, { session, accessContext });
     await recalculateDependents(entry, prepared.current, toPlainRecord(record), {
       session,
       changedFields: prepared.changedFields,
+      accessContext,
     });
     return record;
   }
@@ -127,19 +158,27 @@ function createCrudController(entry, service) {
         searchTerm,
         sort,
         filtros,
+        accessContext: req.accessContext,
       });
       Helpers.sendPaginatedResponse({ res, statusCode: 200, results, pagination });
     },
 
     async getById(req, res) {
-      const registro = await service.getById(req.params.id);
+      const registro = await service.getById(req.params.id, {
+        accessContext: req.accessContext,
+      });
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async create(req, res) {
       const registro = await withProcessTransaction(
         entry,
-        (session) => createOne(req.body ?? {}, "post", session),
+        (session) => createOne(
+          req.body ?? {},
+          "post",
+          session,
+          req.accessContext,
+        ),
       );
       Helpers.sendResponse({ res, statusCode: 201, [entry.singular]: registro });
     },
@@ -147,7 +186,13 @@ function createCrudController(entry, service) {
     async update(req, res) {
       const registro = await withProcessTransaction(
         entry,
-        (session) => updateOne(req.params.id, req.body ?? {}, "put", session),
+        (session) => updateOne(
+          req.params.id,
+          req.body ?? {},
+          "put",
+          session,
+          req.accessContext,
+        ),
       );
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
@@ -155,20 +200,36 @@ function createCrudController(entry, service) {
     async patch(req, res) {
       const registro = await withProcessTransaction(
         entry,
-        (session) => updateOne(req.params.id, req.body ?? {}, "patch", session),
+        (session) => updateOne(
+          req.params.id,
+          req.body ?? {},
+          "patch",
+          session,
+          req.accessContext,
+        ),
       );
       Helpers.sendResponse({ res, statusCode: 200, [entry.singular]: registro });
     },
 
     async remove(req, res) {
       const registro = await withProcessTransaction(entry, async (session) => {
-        const currentRecord = await service.getById(req.params.id, { session });
+        const currentRecord = await service.getById(req.params.id, {
+          session,
+          accessContext: req.accessContext,
+        });
         const current = toPlainRecord(currentRecord);
-        await assertDeleteAllowed(entry, req.params.id, { session });
-        const removed = await service.remove(req.params.id, { session });
+        await assertDeleteAllowed(entry, req.params.id, {
+          session,
+          accessContext: req.accessContext,
+        });
+        const removed = await service.remove(req.params.id, {
+          session,
+          accessContext: req.accessContext,
+        });
         await recalculateDependents(entry, current, null, {
           session,
           changedFields: Object.keys(current),
+          accessContext: req.accessContext,
         });
         return removed;
       });
@@ -178,16 +239,22 @@ function createCrudController(entry, service) {
     async importMany(req, res) {
       const rows = req.body?.rows || req.body;
       if (!Array.isArray(rows)) {
-        const result = await service.importMany(rows);
+        const result = await service.importMany(rows, {
+          accessContext: req.accessContext,
+        });
         Helpers.sendResponse({ res, statusCode: 201, ...result });
         return;
       }
 
       if (!hasProcessRules(entry)) {
         const preparedRows = await Promise.all(
-          rows.map(async (row) => (await prepareCreate(row, "import")).changes),
+          rows.map(async (row) => (
+            await prepareCreate(row, "import", null, req.accessContext)
+          ).changes),
         );
-        const result = await service.importMany(preparedRows);
+        const result = await service.importMany(preparedRows, {
+          accessContext: req.accessContext,
+        });
         Helpers.sendResponse({ res, statusCode: 201, ...result });
         return;
       }
@@ -195,7 +262,7 @@ function createCrudController(entry, service) {
       let inserted = 0;
       for (const row of rows) {
         await withProcessTransaction(entry, async (session) => {
-          await createOne(row, "import", session);
+          await createOne(row, "import", session, req.accessContext);
           inserted += 1;
         });
       }
@@ -203,7 +270,9 @@ function createCrudController(entry, service) {
     },
 
     async exportAll(req, res) {
-      const results = await service.exportAll(req.query);
+      const results = await service.exportAll(req.query, {
+        accessContext: req.accessContext,
+      });
       Helpers.sendResponse({ res, statusCode: 200, results });
     },
   };
@@ -214,4 +283,4 @@ module.exports = {
   toPlainRecord,
   hasDomainRules,
   hasProcessRules,
-};
+};

package/src/core/factories/crudService.js

@@ -1,5 +1,12 @@
 const GenericError = require("../errors/GenericError");
 const registry = require("../registry");
+const {
+  dataScope,
+  scopeFilter,
+  mergeScopedFilter,
+  scopeMutation,
+  scopedIdFilter,
+} = require("../tenancy");
 
 const COMMON_REFERENCE_LABEL_FIELDS = [
   "nome",
@@ -15,7 +22,7 @@ const COMMON_REFERENCE_LABEL_FIELDS = [
   "sigla",
 ];
 
-function referencePopulateSpecs(entry) {
+function referencePopulateSpecs(entry, accessContext) {
   const setting = entry.definition?.crud?.populateRefs;
   if (!setting) return [];
 
@@ -35,10 +42,15 @@ function referencePopulateSpecs(entry) {
         ...COMMON_REFERENCE_LABEL_FIELDS,
         ...(referencedEntry?.searchableFields || []),
       ];
+      let match;
+      if (referencedEntry && dataScope(referencedEntry) !== "legacy") {
+        match = scopeFilter(referencedEntry, accessContext);
+      }
 
       return {
         path: field.name,
         select: [...new Set(select)].join(" "),
+        ...(match && Object.keys(match).length ? { match } : {}),
       };
     });
 }
@@ -62,21 +74,47 @@ function withSession(query, session) {
   return session && query && typeof query.session === "function" ? query.session(session) : query;
 }
 
+function scopeDenied() {
+  return new GenericError("Registro fora do contexto de acesso atual.", {
+    statusCode: 403,
+    code: "TENANT_SCOPE_DENIED",
+  });
+}
+
+function notFound() {
+  return new GenericError("Registro não encontrado.", { statusCode: 404 });
+}
+
 function createCrudService(entry) {
   const { mongooseModel: Model, searchableFields } = entry;
-  const populateSpecs = referencePopulateSpecs(entry);
 
-  async function listPaginated({ pageIndex = 0, pageSize = 20, searchTerm, sort, filtros = {} } = {}) {
+  async function assertScopedMiss(id, accessContext, session) {
+    const scope = dataScope(entry);
+    if (scope === "legacy" || scope === "system") throw notFound();
+    const exists = await withSession(Model.exists({ _id: id }), session);
+    if (exists) throw scopeDenied();
+    throw notFound();
+  }
+
+  async function listPaginated({
+    pageIndex = 0,
+    pageSize = 20,
+    searchTerm,
+    sort,
+    filtros = {},
+    accessContext,
+  } = {}) {
     const page = Math.max(0, Number(pageIndex) || 0);
     const limit = Math.min(200, Math.max(1, Number(pageSize) || 20));
 
-    const query = { ...cleanFilters(filtros) };
+    const query = mergeScopedFilter(entry, cleanFilters(filtros), accessContext);
     if (searchTerm && searchableFields.length) {
       const rx = new RegExp(escapeRegex(searchTerm), "i");
       query.$or = searchableFields.map((f) => ({ [f]: rx }));
     }
 
     const sortSpec = parseSort(sort);
+    const populateSpecs = referencePopulateSpecs(entry, accessContext);
     const listQuery = populateQuery(
       Model.find(query).sort(sortSpec).skip(page * limit).limit(limit),
       populateSpecs
@@ -98,32 +136,48 @@ function createCrudService(entry) {
   }
 
   async function getById(id, options = {}) {
-    const query = withSession(Model.findById(id), options.session);
+    const populateSpecs = referencePopulateSpecs(entry, options.accessContext);
+    const query = withSession(
+      Model.findOne(scopedIdFilter(entry, id, options.accessContext)),
+      options.session,
+    );
     const doc = await resolvePopulated(query, populateSpecs);
-    if (!doc) throw new GenericError("Registro não encontrado.", { statusCode: 404 });
+    if (!doc) await assertScopedMiss(id, options.accessContext, options.session);
     return doc;
   }
 
   async function create(data, options = {}) {
-    const doc = new Model(data);
+    const scopedData = scopeMutation(entry, data, options.accessContext);
+    const doc = new Model(scopedData);
     await doc.save({ session: options.session || undefined });
-    return resolvePopulated(doc, populateSpecs);
+    return resolvePopulated(doc, referencePopulateSpecs(entry, options.accessContext));
   }
 
   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 });
+    const scopedData = scopeMutation(entry, data, options.accessContext);
+    const query = Model.findOneAndUpdate(
+      scopedIdFilter(entry, id, options.accessContext),
+      scopedData,
+      {
+        new: true,
+        runValidators: true,
+        session: options.session || undefined,
+      },
+    );
+    const doc = await resolvePopulated(
+      query,
+      referencePopulateSpecs(entry, options.accessContext),
+    );
+    if (!doc) await assertScopedMiss(id, options.accessContext, options.session);
     return doc;
   }
 
   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 });
+    const doc = await withSession(
+      Model.findOneAndDelete(scopedIdFilter(entry, id, options.accessContext)),
+      options.session,
+    );
+    if (!doc) await assertScopedMiss(id, options.accessContext, options.session);
     return doc;
   }
 
@@ -131,18 +185,38 @@ function createCrudService(entry) {
     if (!Array.isArray(rows)) {
       throw new GenericError("Esperado um array de registros.", { statusCode: 400 });
     }
-    const docs = await Model.insertMany(rows, {
+    const scopedRows = rows.map((row) => scopeMutation(entry, row, options.accessContext));
+    const docs = await Model.insertMany(scopedRows, {
       ordered: false,
       session: options.session || undefined,
     });
     return { inserted: docs.length };
   }
 
-  async function exportAll(filtros = {}) {
-    return Model.find(cleanFilters(filtros)).lean();
+  async function exportAll(filtros = {}, options = {}) {
+    const query = mergeScopedFilter(entry, cleanFilters(filtros), options.accessContext);
+    return Model.find(query).lean();
+  }
+
+  function scopeQuery(filter = {}, accessContext) {
+    return mergeScopedFilter(entry, filter, accessContext);
+  }
+
+  function scopedData(data = {}, accessContext) {
+    return scopeMutation(entry, data, accessContext);
   }
 
-  return { listPaginated, getById, create, update, remove, importMany, exportAll };
+  return {
+    listPaginated,
+    getById,
+    create,
+    update,
+    remove,
+    importMany,
+    exportAll,
+    scopeQuery,
+    scopedData,
+  };
 }
 
 function cleanFilters(filtros) {
@@ -163,4 +237,9 @@ function escapeRegex(str) {
   return String(str).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-module.exports = { createCrudService, referencePopulateSpecs, resolvePopulated };
+module.exports = {
+  createCrudService,
+  referencePopulateSpecs,
+  resolvePopulated,
+  cleanFilters,
+};

package/src/core/factories/modelRouter.js

@@ -2,16 +2,14 @@ const express = require("express");
 const { asyncHandler } = require("../utils/helpers");
 const auth = require("../middlewares/auth");
 const { rbac } = require("../middlewares/rbac");
+const { requirePermission } = require("../middlewares/permissions");
 const { mutationAudit } = require("../middlewares/mutationAudit");
 const { createCrudService } = require("./crudService");
 const { createCrudController } = require("./crudController");
 
 /**
- * Monta o router de CRUD de uma model. Todas as rotas são privadas
- * (auth obrigatório). Mutações passam por RBAC + mutationAudit.
- *
- * Endpoints (Seção 2.9): GET list, GET :id, POST, PUT :id, PATCH :id,
- * DELETE :id, POST /import, GET /export.
+ * Monta o router de CRUD de uma model. `crud.permissions` é o contrato
+ * canônico; `crud.roles` permanece como fallback para Centrais legadas.
  */
 function buildModelRouter(entry) {
   const router = express.Router();
@@ -20,43 +18,48 @@ function buildModelRouter(entry) {
 
   const crud = entry.definition.crud || {};
   const roles = crud.roles || {};
-  const readRoles = roles.read || [];
-  const writeRoles = roles.write || [];
+  const permissions = crud.permissions || {};
+  const readGuard = permissions.read
+    ? requirePermission(permissions.read)
+    : rbac(roles.read || []);
+  const writeGuard = permissions.write
+    ? requirePermission(permissions.write)
+    : rbac(roles.write || []);
   const entidade = entry.name;
 
   router.use(auth);
 
-  router.get("/", rbac(readRoles), asyncHandler(controller.list));
-  router.get("/export", rbac(readRoles), asyncHandler(controller.exportAll));
-  router.get("/:id", rbac(readRoles), asyncHandler(controller.getById));
+  router.get("/", readGuard, asyncHandler(controller.list));
+  router.get("/export", readGuard, asyncHandler(controller.exportAll));
+  router.get("/:id", readGuard, asyncHandler(controller.getById));
 
   router.post(
     "/import",
-    rbac(writeRoles),
+    writeGuard,
     mutationAudit({ entidade, acao: "adicionado" }),
     asyncHandler(controller.importMany)
   );
   router.post(
     "/",
-    rbac(writeRoles),
+    writeGuard,
     mutationAudit({ entidade, acao: "adicionado" }),
     asyncHandler(controller.create)
   );
   router.put(
     "/:id",
-    rbac(writeRoles),
+    writeGuard,
     mutationAudit({ entidade, acao: "alterado" }),
     asyncHandler(controller.update)
   );
   router.patch(
     "/:id",
-    rbac(writeRoles),
+    writeGuard,
     mutationAudit({ entidade, acao: "alterado" }),
     asyncHandler(controller.patch)
   );
   router.delete(
     "/:id",
-    rbac(writeRoles),
+    writeGuard,
     mutationAudit({ entidade, acao: "excluido" }),
     asyncHandler(controller.remove)
   );