feat(auth): per-service authz branch on /auth/module-identity

When the ingress annotation carries permission (+project_uuid), authorize against the tenant's orchest-api /api/authz/check (host derived from the JWT, allowlist-guarded); relay allow/deny, fail-closed 502. All-or-nothing on incomplete params; param-less requests stay identity-only (webserver case). Co-Authored-By: WOZCODE <contact@withwoz.com>
feat(orchest-identity): tenant orchest-api host derivation + allowlist
2026-09-17 18:24:49 +00:00 · 2026-08-20 10:12:45 -03:00 · 2026-08-20 10:10:43 -03:00 · 2026-08-20 10:09:31 -03:00 · 2026-08-20 10:06:02 -03:00 · 2026-08-20 10:05:26 -03:00
107 changed files with 12340 additions and 4129 deletions
@@ -0,0 +1,12 @@
+node_modules
+dist
+.git
+*.log
+npm-debug.log*
+.DS_Store
+.env
+.env.*
+coverage
+.nyc_output
+*.tgz
+!protospack.tgz
@@ -56,9 +56,9 @@ jobs:

      - name: Install Helmfile
        run: |
-          wget https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
+          curl -fsSLO https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
          tar -xzf helmfile_0.148.0_linux_amd64.tar.gz
-          mv helmfile /usr/local/bin/
+          sudo mv helmfile /usr/local/bin/
          helmfile --version

      - name: Install Helm Diff Plugin
@@ -105,7 +105,7 @@ jobs:

      - name: Install Helmfile
        run: |
-          wget https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
+          curl -fsSLO https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
          tar -xzf helmfile_0.148.0_linux_amd64.tar.gz
          sudo mv helmfile /usr/local/bin/
          helmfile --version
@@ -66,13 +66,21 @@ jobs:

      - name: Install Helmfile
        run: |
-          wget https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
+          curl -fsSLO https://github.com/helmfile/helmfile/releases/download/v0.148.0/helmfile_0.148.0_linux_amd64.tar.gz
          tar -xzf helmfile_0.148.0_linux_amd64.tar.gz
          sudo mv helmfile /usr/local/bin/
          helmfile --version

-      - name: Install Helm Diff Plugin
-        run: helm plugin install https://github.com/databus23/helm-diff || true
+      - name: Install Helm Diff plugin
+        run: |
+          helm plugin install https://github.com/databus23/helm-diff --version v3.9.3
+          helm diff version
+
+      - name: Debug Helm env
+        run: |
+          helm env
+          echo "HOME=$HOME"
+          ls -R $HOME/.local/share/helm || true

      - name: Authenticate with OKE cluster
        env:
@@ -99,4 +107,5 @@ jobs:
      - name: Run Helmfile Diff
        env:
          ENV: ${{ needs.extract_environment.outputs.environment }}
+          HELM_PLUGINS: /home/runner/.local/share/helm/plugins
        run: helmfile -f deploy/helmfiles/${ENV}.yaml diff
@@ -1,4 +1,5 @@
-FROM node:18.17-alpine AS base_image
+FROM node:20-alpine AS base_image
+RUN npm install -g npm@10.8.2

 FROM base_image AS build_base
 WORKDIR /app
@@ -21,7 +22,7 @@ ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true \
 # run aws cli without mounting secret, because CI already has AWS credentials
 FROM build_base AS ci_image
 RUN aws codeartifact login --tool npm --namespace @dadosfera --repository dadosfera-npm --domain dadosfera --domain-owner 611330257153 --region us-east-1
-RUN npm ci
+RUN npm ci --ignore-scripts
 COPY . .


@@ -36,7 +37,7 @@ FROM build_base AS dev
 RUN --mount=type=secret,id=aws,target=/root/.aws/credentials \
  aws codeartifact login --tool npm --namespace @dadosfera --repository dadosfera-npm --domain dadosfera --domain-owner 611330257153 --region us-east-1
 # flag --build-from-source is required to force-build sqlite3
-RUN npm ci
+RUN npm ci --ignore-scripts
 COPY . .
 ENTRYPOINT npm run start:dev

@@ -0,0 +1,47 @@
+FROM node:22-alpine AS base_image
+RUN npm install -g npm@latest
+
+FROM base_image AS build_base
+WORKDIR /app
+RUN apk update
+RUN apk add --no-cache \
+      aws-cli \
+      chromium \
+      nss \
+      freetype \
+      harfbuzz \
+      ca-certificates \
+      ttf-freefont
+COPY package*.json ./
+
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true \
+    PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
+
+
+# Local build with secrets
+FROM build_base AS build
+RUN --mount=type=secret,id=aws,target=/root/.aws/credentials \
+  aws codeartifact login --tool npm --namespace @dadosfera --repository dadosfera-npm --domain dadosfera --domain-owner 611330257153 --region us-east-1
+RUN  npm ci --ignore-scripts
+COPY . .
+RUN npm run build
+
+
+FROM base_image
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/node_modules ./node_modules
+COPY --from=build /app/package*.json ./
+RUN apk update
+RUN apk add --no-cache \
+      chromium \
+      nss \
+      freetype \
+      harfbuzz \
+      ca-certificates \
+      ttf-freefont
+
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true \
+    PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
+
+ENTRYPOINT ["npm", "run", "start:prod"]
@@ -2,9 +2,9 @@
  <image src="./assets/maestro.svg" style="width:10rem">
 </p>

-
 # Maestro

+
 Maestro é a API principal da Dadosfera. É responsável pela comunicação do Frontend com nossos microsserviços.

 ```mermaid
@@ -48,6 +48,9 @@ spec:
            {{- toYaml .Values.resources | nindent 12 }}
          {{- end }}
          env:
+            # Auth Provider Configuration (cognito or keycloak)
+            - name: AUTH_PROVIDER
+              value: {{ .Values.maestro.auth_provider | default "cognito" | quote }}
            - name: AWS_IDENTITY_POOL_ID
              value: {{ .Values.maestro.aws_identity_pool_id }}
            - name: AWS_REGION
@@ -104,6 +107,16 @@ spec:
              value: {{ .Values.maestro.redis_host }}
            - name: REDIS_PORT
              value: "{{ .Values.maestro.redis_port }}"
+            - name: REDIS_TLS
+              value: "{{ .Values.maestro.redis_tls }}"
+            - name: PLATFORM_API_URL
+              value: {{ .Values.maestro.platform_api_url }}
+            - name: CONNECTIONS_API_URL
+              value: {{ .Values.maestro.connections_api_url | default "" | quote }}
+            - name: STORAGE_EXPLORER_API_URL
+              value: {{ .Values.maestro.storage_explorer_api_url | quote }}
+            - name: FIREBASE_BASE_URL
+              value: {{ .Values.maestro.firebase_base_url }}
            - name: JWT_PRIVATE_KEY
              valueFrom:
                secretKeyRef:
@@ -124,3 +137,14 @@ spec:
                secretKeyRef:
                  name: prd-{{ .Values.app_name }}
                  key: AWS_DEFAULT_REGION
+            # Elasticsearch
+            - name: ELASTICSEARCH_URL
+              valueFrom:
+                secretKeyRef:
+                  name: prd-{{ .Values.app_name }}
+                  key: ELASTICSEARCH_URL
+            - name: ELASTICSEARCH_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: prd-{{ .Values.app_name }}
+                  key: ELASTICSEARCH_API_KEY
@@ -4,9 +4,18 @@ metadata:
  annotations:
    nginx.ingress.kubernetes.io/whitelist-source-range: "69.49.241.121/32" # hostgator ip 
    nginx.ingress.kubernetes.io/proxy-body-size: "0"
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
+    nginx.ingress.kubernetes.io/proxy-connect-timeout: "300"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "300"
    nginx.ingress.kubernetes.io/server-snippet: |
      underscores_in_headers on;
      ignore_invalid_headers on;
+    nginx.ingress.kubernetes.io/proxy-buffer-size: "16k"
+    nginx.ingress.kubernetes.io/proxy-buffers-number: "8"
+    nginx.ingress.kubernetes.io/proxy-busy-buffers-size: "64k"
+    {{- if .Values.maestro.restricted_ip}}
+    nginx.ingress.kubernetes.io/whitelist-source-range: {{ .Values.maestro.restricted_ip }}
+    {{- end }}
      
  generation: 1
  labels:
@@ -38,3 +38,15 @@ spec:
      version: "AWSCURRENT"
      property: token

+  - secretKey: ELASTICSEARCH_URL
+    remoteRef:
+      key: {{ .Values.maestro.env }}/microservices/elasticsearch
+      version: "AWSCURRENT"
+      property: ELASTICSEARCH_URL
+
+  - secretKey: ELASTICSEARCH_API_KEY
+    remoteRef:
+      key: {{ .Values.maestro.env }}/microservices/elasticsearch
+      version: "AWSCURRENT"
+      property: ELASTICSEARCH_API_KEY
+
@@ -8,6 +8,10 @@ maestro:
  open_group_id: e3f98a2f-7748-4981-8505-7695c8ca8218
  cookie_secret: "ff7bc13823edb2ae50d248e5780bddc9d4b31c36"
  redis_database: "1"
+  platform_api_url: https://xs2hkhq07k.execute-api.us-east-1.amazonaws.com
+  connections_api_url: https://iy40eans64.execute-api.us-east-1.amazonaws.com
+  storage_explorer_api_url: "http://storage-explorer-{customer}.data-apps.svc.cluster.local:8000/api"
+  firebase_base_url: https://feature-flag-25bf6-default-rtdb.firebaseio.com/stg

 hostname: maestro.stg.dadosfera.ai

@@ -27,6 +27,9 @@ resources:
    cpu: 2000m
    memory: 2Gi
 maestro:
+  # Auth provider: "cognito" (default) or "keycloak"
+  # Note: maestro doesn't connect to Keycloak directly, only duc does
+  auth_provider: "cognito"
  aws_identity_pool_id: "us-east-1_Mrezsw9Sn"
  duc_url: duc.dadosfera.ai
  in_factory_url: in-factory.dadosfera.ai
@@ -43,12 +46,16 @@ maestro:
  upload_file_agent_connection: cbc2f881-58c4-4d60-8003-0979b0b5b911
  open_customer_id: f239718a-a271-4ef9-ae7e-02a2f0f3aa6e
  open_group_id: 401573bb-334f-44b2-b30e-88d4cea31ae9
+  platform_api_url: https://oz8v2zid1e.execute-api.us-east-1.amazonaws.com
+  storage_explorer_api_url: "https://storage-explorer-{customer}.dadosfera.ai/api"
  dedicated_proxy: ""
  restricted_ip: ""
  redis_host: "aaapzppmlyamkocqwstpo7zvopczyyiyuy6xzm2g6c5k4mq3a66be4a-0.redis.sa-saopaulo-1.oci.oraclecloud.com"
  redis_port: "6379"
  redis_database: "0"
+  redis_tls: "true"
  cookie_secret: "13cc5e136d3074bcc05bec8697092ec1f5f376bf"
+  firebase_base_url: https://feature-flag-25bf6-default-rtdb.firebaseio.com/prd
 autoscaling:
  enabled: false
  minReplicas: 1
@@ -0,0 +1,759 @@
+# Orchest Module Identity Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a Maestro endpoint `GET /auth/module-identity` that translates a Dadosfera session into the `X-Auth-*` identity headers Orchest's RBAC trusts, gating on a module permission and (for service ingresses) authorizing per-project against orchest-api.
+
+**Architecture:** One route serves two nginx `auth_request` callers, keyed on whether the ingress annotation carries authz query params. Phase 1: authenticate the `ddf-auth` cookie via Maestro's existing JWKS verify, gate on the module permission (seqid 31), emit identity headers, set `X-Auth-Roles: admin` for Super Admin (seqid 34). Phase 2: when the annotation carries `permission`+`project_uuid`, additionally call the calling tenant's orchest-api `/api/authz/check` (host derived from the JWT's `customer_name` + the `orchest-{module}-{customer_name}` namespace convention) and relay allow/deny, fail-closed. A small orchest-side change flips `service_access_auth_url` to build a scoped URL in Maestro mode.
+
+**Tech Stack:** NestJS (controllers/providers, Jest via `Test.createTestingModule`), Express `Request`/`Response`, `jsonwebtoken`, plain `process.env` config. Orchest side: Python (`lib/python/orchest-internals`).
+
+**Spec:** `dbt-to-orchest` repo — `docs/superpowers/specs/2026-08-20-maestro-module-identity-design.md` (the Maestro repo does not hold the spec; executors read it there).
+
+## Global Constraints
+
+- **Config via `process.env`** — Maestro reads env directly (no ConfigService). Pattern: `const X = process.env.X || '<default>'` (see `authentication.guard.ts:140`).
+- **Config values (verbatim):** `ORCHEST_MODULE_PERMISSION_SEQID` default `31` (Intelligence/"Orchest Module", `intelligence:open`); `ORCHEST_ADMIN_PERMISSION_SEQIDS` default `34` (Super Admin, `users:admin`), a comma-separated list parsed to numbers; `ORCHEST_NAMESPACE_MODULE` default `intelli` (∈ `intelli`|`process`).
+- **Token source is the `ddf-auth` COOKIE**, not the `Authorization` header (the nginx `auth_request` subrequest carries the browser cookie). Never read `Authorization` in this route.
+- **`permission`/`project_uuid` come from `request.query`** (the orchest-api-authored annotation), never from the end-user URL. The end-user URL is `X-Original-URI` and MUST NOT be read for authz.
+- **Fail-closed:** any error reaching orchest-api, or an unexpected status, → deny (never allow).
+- **`/auth/me` is not modified.** Other services depend on it.
+- **No orchest-api code change.** `/api/authz/check`, the `AuthCustom/AuthUrl` ingress path, and RBAC already exist.
+- **Namespace pattern:** `orchest-{module}-{customer_name}`. `dadosferademo2` is the one exception (being removed) — explicitly unsupported, no special-casing.
+- Branch: `feat/orchest-module-identity` (off `origin/beta`), already created.
+
+---
+
+## File Structure
+
+**Maestro (`feat/orchest-module-identity` off beta):**
+- Modify `src/modules/auth/auth.service.ts` — make `validateJwtToken` public (or add a public `verifyAccessToken` wrapper); add `authorizeOrchestServiceAccess(...)` helper (Phase 2).
+- Modify `src/modules/auth/auth.controller.ts` — add the `GET /auth/module-identity` route.
+- Create `src/modules/auth/orchest-identity.ts` — pure, testable helpers: `parseAdminSeqids(env)`, `isModuleAllowed(perms, gateSeqid)`, `isAdmin(perms, adminSeqids)`, `tenantOrchestApiHost(customerName, module)`, `isAllowedOrchestApiHost(host)`. Keeps set-membership/string logic out of the controller so it unit-tests without HTTP.
+- Create `src/modules/auth/orchest-identity.spec.ts` — unit tests for the helpers.
+- Create `src/modules/auth/module-identity.controller.spec.ts` — controller tests (mock `AuthClientService`, fake `Request`/`Response`).
+
+**dbt-to-orchest repo (Phase 2 orchest-side, separate branch there):**
+- Modify `lib/python/orchest-internals/_orchest/internals/utils.py:19-51` — `service_access_auth_url` Maestro branch.
+- Modify `lib/python/orchest-internals/tests/…` (or wherever `utils` is tested) — add the Maestro-mode case.
+
+---
+
+## PHASE 1 — Identity (webserver ingress)
+
+### Task 1: Pure helpers for permission mapping
+
+**Files:**
+- Create: `src/modules/auth/orchest-identity.ts`
+- Test: `src/modules/auth/orchest-identity.spec.ts`
+
+**Interfaces:**
+- Consumes: nothing.
+- Produces:
+  - `parseAdminSeqids(raw: string | undefined): number[]` — parse `"34"` / `"34,40"` → `[34]` / `[34,40]`; empty/undefined → `[34]`.
+  - `moduleGateSeqid(raw: string | undefined): number` — parse `ORCHEST_MODULE_PERMISSION_SEQID` → number; default `31`.
+  - `isModuleAllowed(perms: number[], gateSeqid: number): boolean`
+  - `isAdmin(perms: number[], adminSeqids: number[]): boolean`
+
+- [ ] **Step 1: Write the failing test**
+
+```typescript
+import {
+  parseAdminSeqids,
+  moduleGateSeqid,
+  isModuleAllowed,
+  isAdmin,
+} from './orchest-identity';
+
+describe('orchest-identity mapping', () => {
+  it('parseAdminSeqids: default, single, list, whitespace', () => {
+    expect(parseAdminSeqids(undefined)).toEqual([34]);
+    expect(parseAdminSeqids('')).toEqual([34]);
+    expect(parseAdminSeqids('34')).toEqual([34]);
+    expect(parseAdminSeqids('34,40')).toEqual([34, 40]);
+    expect(parseAdminSeqids(' 34 , 40 ')).toEqual([34, 40]);
+  });
+
+  it('moduleGateSeqid: default and override', () => {
+    expect(moduleGateSeqid(undefined)).toBe(31);
+    expect(moduleGateSeqid('43')).toBe(43);
+  });
+
+  it('isModuleAllowed', () => {
+    expect(isModuleAllowed([31, 5], 31)).toBe(true);
+    expect(isModuleAllowed([5, 7], 31)).toBe(false);
+    expect(isModuleAllowed([], 31)).toBe(false);
+  });
+
+  it('isAdmin: intersection', () => {
+    expect(isAdmin([31, 34], [34])).toBe(true);
+    expect(isAdmin([31], [34])).toBe(false);
+    expect(isAdmin([99], [34, 99])).toBe(true);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx jest src/modules/auth/orchest-identity.spec.ts -t 'orchest-identity mapping'`
+Expected: FAIL — `Cannot find module './orchest-identity'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+```typescript
+// src/modules/auth/orchest-identity.ts
+export function parseAdminSeqids(raw: string | undefined): number[] {
+  if (!raw || !raw.trim()) return [34];
+  return raw
+    .split(',')
+    .map((s) => Number(s.trim()))
+    .filter((n) => Number.isInteger(n));
+}
+
+export function moduleGateSeqid(raw: string | undefined): number {
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : 31;
+}
+
+export function isModuleAllowed(perms: number[], gateSeqid: number): boolean {
+  return Array.isArray(perms) && perms.includes(gateSeqid);
+}
+
+export function isAdmin(perms: number[], adminSeqids: number[]): boolean {
+  return (
+    Array.isArray(perms) && perms.some((p) => adminSeqids.includes(p))
+  );
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx jest src/modules/auth/orchest-identity.spec.ts -t 'orchest-identity mapping'`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/modules/auth/orchest-identity.ts src/modules/auth/orchest-identity.spec.ts
+git commit -m "feat(orchest-identity): permission-mapping helpers"
+```
+
+---
+
+### Task 2: Expose JWKS verify on AuthClientService
+
+**Files:**
+- Modify: `src/modules/auth/auth.service.ts:413-425`
+
+**Interfaces:**
+- Consumes: existing `getPublicKeys()`.
+- Produces: `public async verifyAccessToken(token: string): Promise<any>` — verifies the JWT against JWKS and returns its payload; throws on missing/invalid token or unknown `kid`. (Rename of the existing private `validateJwtToken`, kept callable by `validateUserSession`.)
+
+- [ ] **Step 1: Make the method public and rename**
+
+The method already does exactly the needed decode+verify. Rename `validateJwtToken` → `verifyAccessToken`, change `private` → `public`, and update its one caller.
+
+In `src/modules/auth/auth.service.ts`, change line 413:
+
+```typescript
+  public async verifyAccessToken(token: string) {
+    const decoded: any = token && jwt.decode(token, { complete: true });
+    if (!decoded) throw new Error('Invalid token');
+
+    const { kid } = decoded.header;
+    const { keys } = await this.getPublicKeys();
+    const pemValue = keys.find((k) => k.kid === kid)?.pem;
+    if (!pemValue) throw new Error('Public key not found');
+    jwt.verify(token, pemValue);
+
+    return decoded.payload;
+  }
+```
+
+And update the caller in `validateUserSession` (was line 310):
+
+```typescript
+    const payload = await this.verifyAccessToken(accessToken);
+```
+
+- [ ] **Step 2: Verify existing suite still compiles/passes for auth.service**
+
+Run: `npx jest src/modules/auth`
+Expected: PASS (no behavior change; `/auth/me` path unaffected). If there is no existing auth.service spec, run `npx tsc --noEmit` to confirm the rename compiles.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/modules/auth/auth.service.ts
+git commit -m "refactor(auth): expose verifyAccessToken (was private validateJwtToken)"
+```
+
+---
+
+### Task 3: `GET /auth/module-identity` — identity + module gate
+
+**Files:**
+- Modify: `src/modules/auth/auth.controller.ts` (add route beside `getMe`, ~after line 533)
+- Test: `src/modules/auth/module-identity.controller.spec.ts`
+
+**Interfaces:**
+- Consumes: `AuthClientService.verifyAccessToken` (Task 2); `parseAdminSeqids`/`moduleGateSeqid`/`isModuleAllowed`/`isAdmin` (Task 1).
+- Produces: route `GET /auth/module-identity`. On 200 sets response headers `X-Auth-User`, `X-Auth-Username`, and (admin only) `X-Auth-Roles: admin`; empty body. 401 (no/invalid cookie), 403 (lacks module gate).
+
+- [ ] **Step 1: Write the failing test**
+
+```typescript
+import { Test } from '@nestjs/testing';
+import { AuthController } from './auth.controller';
+import { AuthClientService } from './auth.service';
+
+function res() {
+  const headers: Record<string, string> = {};
+  const r: any = {
+    _status: 0,
+    _sent: undefined,
+    set: (k: string, v: string) => { headers[k] = v; return r; },
+    status: (c: number) => { r._status = c; return r; },
+    send: (b?: any) => { r._sent = b ?? ''; return r; },
+    json: (b?: any) => { r._sent = b; return r; },
+    _headers: headers,
+  };
+  return r;
+}
+function req(cookie?: string, query: Record<string, string> = {}) {
+  return { cookies: cookie ? { 'ddf-auth': cookie } : {}, query } as any;
+}
+
+describe('GET /auth/module-identity — identity', () => {
+  let controller: AuthController;
+  const auth = { verifyAccessToken: jest.fn() } as unknown as AuthClientService;
+
+  beforeEach(async () => {
+    jest.resetAllMocks();
+    process.env.ORCHEST_MODULE_PERMISSION_SEQID = '31';
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34';
+    const mod = await Test.createTestingModule({
+      controllers: [AuthController],
+      providers: [{ provide: AuthClientService, useValue: auth }],
+    })
+      // Any other providers AuthController injects must be stubbed here the
+      // same way (ApiKeyService, DadosferaLogger, etc.). Add them as the
+      // compile step reports missing providers.
+      .compile();
+    controller = mod.get(AuthController);
+  });
+
+  it('no cookie → 401', async () => {
+    const r = res();
+    await controller.moduleIdentity(req(undefined), r);
+    expect(r._status).toBe(401);
+  });
+
+  it('valid + module + admin → 200 with X-Auth-Roles: admin', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1', username: 'alice', permissions: [31, 34],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(200);
+    expect(r._headers['X-Auth-User']).toBe('u-1');
+    expect(r._headers['X-Auth-Username']).toBe('alice');
+    expect(r._headers['X-Auth-Roles']).toBe('admin');
+  });
+
+  it('valid + module, not admin → 200, no X-Auth-Roles', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-2', username: 'bob', permissions: [31],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(200);
+    expect(r._headers['X-Auth-Roles']).toBeUndefined();
+  });
+
+  it('valid, lacks module → 403', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-3', username: 'carol', permissions: [5],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(403);
+  });
+
+  it('verify throws (expired/bad) → 401', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockRejectedValue(new Error('bad'));
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(401);
+  });
+
+  it('admin seqids extended by config → 200 admin', async () => {
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34,99';
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-4', username: 'dana', permissions: [31, 99],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._headers['X-Auth-Roles']).toBe('admin');
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx jest src/modules/auth/module-identity.controller.spec.ts`
+Expected: FAIL — `controller.moduleIdentity is not a function` (and possibly missing-provider errors, which tell you which providers to stub — add them to the `providers` array per the comment).
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add to `auth.controller.ts` (import the helpers at top; `AuthClientService` is already injected as `this.authClient`):
+
+```typescript
+import {
+  parseAdminSeqids,
+  moduleGateSeqid,
+  isModuleAllowed,
+  isAdmin,
+} from './orchest-identity';
+```
+
+```typescript
+  @Get('module-identity')
+  async moduleIdentity(@Req() req: Request, @Res() res: Response) {
+    const token = req.cookies?.['ddf-auth'];
+    if (!token) {
+      return res.status(401).send();
+    }
+
+    let payload: any;
+    try {
+      payload = await this.authClient.verifyAccessToken(token);
+    } catch (e) {
+      return res.status(401).send();
+    }
+
+    const perms: number[] = payload?.permissions ?? [];
+    const gate = moduleGateSeqid(process.env.ORCHEST_MODULE_PERMISSION_SEQID);
+    if (!isModuleAllowed(perms, gate)) {
+      return res.status(403).send();
+    }
+
+    res.set('X-Auth-User', String(payload.user_id));
+    res.set('X-Auth-Username', String(payload.username ?? ''));
+    if (isAdmin(perms, parseAdminSeqids(process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS))) {
+      res.set('X-Auth-Roles', 'admin');
+    }
+
+    // Phase 2 authz branch is inserted here (Task 5) before the 200.
+    return res.status(200).send();
+  }
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx jest src/modules/auth/module-identity.controller.spec.ts`
+Expected: PASS (all identity cases).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/modules/auth/auth.controller.ts src/modules/auth/module-identity.controller.spec.ts
+git commit -m "feat(auth): GET /auth/module-identity — identity + module gate"
+```
+
+---
+
+## PHASE 2 — Per-service authz
+
+### Task 4: Tenant orchest-api host derivation + allowlist
+
+**Files:**
+- Modify: `src/modules/auth/orchest-identity.ts`
+- Modify: `src/modules/auth/orchest-identity.spec.ts`
+
+**Interfaces:**
+- Consumes: nothing.
+- Produces:
+  - `tenantOrchestApiHost(customerName: string, module: string): string` — returns `orchest-api.orchest-{module}-{customerName}.svc.cluster.local`.
+  - `isAllowedOrchestApiHost(host: string): boolean` — matches `^orchest-api\.orchest-(intelli|process)-[a-z0-9-]+\.svc\.cluster\.local$`.
+  - `namespaceModule(raw: string | undefined): 'intelli' | 'process'` — parse `ORCHEST_NAMESPACE_MODULE`; default `intelli`; anything not `process` → `intelli`.
+
+- [ ] **Step 1: Write the failing test (append to orchest-identity.spec.ts)**
+
+```typescript
+import {
+  tenantOrchestApiHost,
+  isAllowedOrchestApiHost,
+  namespaceModule,
+} from './orchest-identity';
+
+describe('orchest-identity tenant routing', () => {
+  it('namespaceModule default and values', () => {
+    expect(namespaceModule(undefined)).toBe('intelli');
+    expect(namespaceModule('process')).toBe('process');
+    expect(namespaceModule('garbage')).toBe('intelli');
+  });
+
+  it('tenantOrchestApiHost builds the namespace pattern', () => {
+    expect(tenantOrchestApiHost('acme', 'intelli')).toBe(
+      'orchest-api.orchest-intelli-acme.svc.cluster.local',
+    );
+    expect(tenantOrchestApiHost('acme', 'process')).toBe(
+      'orchest-api.orchest-process-acme.svc.cluster.local',
+    );
+  });
+
+  it('isAllowedOrchestApiHost guards against malformed values', () => {
+    expect(
+      isAllowedOrchestApiHost('orchest-api.orchest-intelli-acme.svc.cluster.local'),
+    ).toBe(true);
+    expect(isAllowedOrchestApiHost('evil.example.com')).toBe(false);
+    expect(
+      isAllowedOrchestApiHost('orchest-api.orchest-intelli-.svc.cluster.local'),
+    ).toBe(false);
+    expect(
+      isAllowedOrchestApiHost('orchest-api.orchest-other-acme.svc.cluster.local'),
+    ).toBe(false);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx jest src/modules/auth/orchest-identity.spec.ts -t 'tenant routing'`
+Expected: FAIL — the three functions are not exported.
+
+- [ ] **Step 3: Write minimal implementation (append to orchest-identity.ts)**
+
+```typescript
+export function namespaceModule(raw: string | undefined): 'intelli' | 'process' {
+  return raw === 'process' ? 'process' : 'intelli';
+}
+
+export function tenantOrchestApiHost(
+  customerName: string,
+  module: string,
+): string {
+  return `orchest-api.orchest-${module}-${customerName}.svc.cluster.local`;
+}
+
+const ORCHEST_API_HOST_RE =
+  /^orchest-api\.orchest-(intelli|process)-[a-z0-9-]+\.svc\.cluster\.local$/;
+
+export function isAllowedOrchestApiHost(host: string): boolean {
+  return ORCHEST_API_HOST_RE.test(host);
+}
+```
+
+**Slug-normalization note (verify during implementation):** confirm the
+JWT's `customer_name` is *exactly* the namespace slug (lowercase, kebab, no
+spaces). If it is not, normalize deterministically inside
+`tenantOrchestApiHost` (e.g. `customerName.toLowerCase().replace(/[^a-z0-9-]/g, '-')`)
+and extend the test with the raw→normalized case. Do NOT guess the rule —
+inspect a real token or ask the team.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx jest src/modules/auth/orchest-identity.spec.ts -t 'tenant routing'`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/modules/auth/orchest-identity.ts src/modules/auth/orchest-identity.spec.ts
+git commit -m "feat(orchest-identity): tenant orchest-api host derivation + allowlist"
+```
+
+---
+
+### Task 5: authz branch — call `/api/authz/check`, relay, fail-closed
+
+**Files:**
+- Modify: `src/modules/auth/auth.service.ts` (add `authorizeOrchestServiceAccess`)
+- Modify: `src/modules/auth/auth.controller.ts` (insert the authz branch in `moduleIdentity`)
+- Modify: `src/modules/auth/module-identity.controller.spec.ts`
+
+**Interfaces:**
+- Consumes: `tenantOrchestApiHost`, `isAllowedOrchestApiHost`, `namespaceModule` (Task 4); an HTTP client. Maestro uses gRPC for its own services but plain HTTP for this cross-service call — use `axios` if already a dependency, else the `@nestjs/axios` `HttpService`; confirm which is present before writing (grep `import axios` / `HttpService`).
+- Produces: `AuthClientService.authorizeOrchestServiceAccess(args: { host: string; permission: string; projectUuid?: string; headers: Record<string,string> }): Promise<'allow' | 'deny' | 'error'>` — GET `http://{host}/api/authz/check?permission=…[&project_uuid=…]` with the identity headers; 200→`allow`, 403→`deny`, anything else/throw→`error`.
+
+- [ ] **Step 1: Write the failing test (append to module-identity.controller.spec.ts)**
+
+```typescript
+describe('GET /auth/module-identity — per-service authz', () => {
+  let controller: AuthController;
+  const auth = {
+    verifyAccessToken: jest.fn(),
+    authorizeOrchestServiceAccess: jest.fn(),
+  } as unknown as AuthClientService;
+
+  beforeEach(async () => {
+    jest.resetAllMocks();
+    process.env.ORCHEST_MODULE_PERMISSION_SEQID = '31';
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34';
+    process.env.ORCHEST_NAMESPACE_MODULE = 'intelli';
+    const mod = await Test.createTestingModule({
+      controllers: [AuthController],
+      providers: [{ provide: AuthClientService, useValue: auth }],
+    }).compile(); // add the same stubbed providers as Task 3
+    controller = mod.get(AuthController);
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1', username: 'alice', permissions: [31], customer_name: 'acme',
+    });
+  });
+
+  const q = { permission: 'session.open', project_uuid: 'p-1' };
+
+  it('has grant → 200 and calls the tenant host', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('allow');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(200);
+    expect(auth.authorizeOrchestServiceAccess).toHaveBeenCalledWith(
+      expect.objectContaining({
+        host: 'orchest-api.orchest-intelli-acme.svc.cluster.local',
+        permission: 'session.open',
+        projectUuid: 'p-1',
+      }),
+    );
+  });
+
+  it('lacks grant → 403', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('deny');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(403);
+  });
+
+  it('orchest-api error → 502 (fail-closed)', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('error');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(502);
+  });
+
+  it('permission without project_uuid → 403 (all-or-nothing)', async () => {
+    const r = res();
+    await controller.moduleIdentity(req('tok', { permission: 'session.open' }), r);
+    expect(r._status).toBe(403);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+
+  it('no authz params → 200 identity-only (webserver case)', async () => {
+    const r = res();
+    await controller.moduleIdentity(req('tok', {}), r);
+    expect(r._status).toBe(200);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+
+  it('malformed customer_name → host fails allowlist → 403, no call', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1', username: 'alice', permissions: [31], customer_name: 'Bad Name!',
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(403);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx jest src/modules/auth/module-identity.controller.spec.ts -t 'per-service authz'`
+Expected: FAIL — `authorizeOrchestServiceAccess` undefined / authz branch absent.
+
+- [ ] **Step 3a: Implement the service helper**
+
+In `auth.service.ts` (use the HTTP client confirmed in the Interfaces note; `axios` shown):
+
+```typescript
+  public async authorizeOrchestServiceAccess(args: {
+    host: string;
+    permission: string;
+    projectUuid?: string;
+    headers: Record<string, string>;
+  }): Promise<'allow' | 'deny' | 'error'> {
+    const params: Record<string, string> = { permission: args.permission };
+    if (args.projectUuid) params.project_uuid = args.projectUuid;
+    try {
+      const resp = await axios.get(`http://${args.host}/api/authz/check`, {
+        params,
+        headers: args.headers,
+        timeout: 5000,
+        validateStatus: () => true, // never throw on 4xx/5xx; we branch below
+      });
+      if (resp.status === 200) return 'allow';
+      if (resp.status === 403) return 'deny';
+      return 'error';
+    } catch (e) {
+      return 'error';
+    }
+  }
+```
+
+- [ ] **Step 3b: Insert the authz branch in the controller**
+
+Replace the `// Phase 2 authz branch is inserted here` marker (Task 3) with:
+
+```typescript
+    const permission = req.query?.permission as string | undefined;
+    const projectUuid = req.query?.project_uuid as string | undefined;
+    if (permission) {
+      // Service-ingress caller: authorize per-project. All-or-nothing —
+      // an incomplete annotation must not silently skip the check.
+      if (!projectUuid) {
+        return res.status(403).send();
+      }
+      const module = namespaceModule(process.env.ORCHEST_NAMESPACE_MODULE);
+      const host = tenantOrchestApiHost(String(payload.customer_name ?? ''), module);
+      if (!isAllowedOrchestApiHost(host)) {
+        return res.status(403).send();
+      }
+      const identityHeaders: Record<string, string> = {
+        'X-Auth-User': String(payload.user_id),
+        'X-Auth-Username': String(payload.username ?? ''),
+      };
+      if (isAdmin(perms, parseAdminSeqids(process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS))) {
+        identityHeaders['X-Auth-Roles'] = 'admin';
+      }
+      const decision = await this.authClient.authorizeOrchestServiceAccess({
+        host,
+        permission,
+        projectUuid,
+        headers: identityHeaders,
+      });
+      if (decision === 'deny') return res.status(403).send();
+      if (decision === 'error') return res.status(502).send();
+      // 'allow' falls through to the 200 below (identity headers already set).
+    }
+
+    return res.status(200).send();
+```
+
+Add the imports `tenantOrchestApiHost`, `isAllowedOrchestApiHost`, `namespaceModule` to the existing `./orchest-identity` import line.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx jest src/modules/auth/module-identity.controller.spec.ts`
+Expected: PASS (identity + per-service authz suites).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/modules/auth/auth.service.ts src/modules/auth/auth.controller.ts src/modules/auth/module-identity.controller.spec.ts
+git commit -m "feat(auth): per-service authz branch on /auth/module-identity"
+```
+
+---
+
+### Task 6: orchest-side — scope the Maestro service auth-url (dbt-to-orchest repo)
+
+**Files:**
+- Modify: `lib/python/orchest-internals/_orchest/internals/utils.py:19-51` (`service_access_auth_url`)
+- Test: the module's existing test (grep `service_access_auth_url` under `lib/python/…/tests`; if none, create `lib/python/orchest-internals/tests/test_service_access_auth_url.py`)
+
+**This task is in the `dbt-to-orchest` repo, not Maestro.** Do it on a branch there (e.g. off the current RBAC branch). It has no dependency on Tasks 1-5 compiling, but the annotation it produces is what Task 5 consumes at runtime.
+
+**Interfaces:**
+- Consumes: nothing new.
+- Produces: `service_access_auth_url(base_auth_url, permission, project_uuid, auth_custom)` — in Maestro mode (`auth_custom=True`), returns `f"{base_auth_url}?permission={permission}"` (plus `&project_uuid=…` when set) instead of returning `base_auth_url` unchanged.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+from _orchest.internals.utils import service_access_auth_url
+
+def test_maestro_mode_appends_scoped_params():
+    url = service_access_auth_url(
+        "http://maestro/auth/module-identity", "session.open", "p-1",
+        auth_custom=True,
+    )
+    assert url == (
+        "http://maestro/auth/module-identity?permission=session.open&project_uuid=p-1"
+    )
+
+def test_maestro_mode_without_project_uuid():
+    url = service_access_auth_url(
+        "http://maestro/auth/module-identity", "project.view", None,
+        auth_custom=True,
+    )
+    assert url == "http://maestro/auth/module-identity?permission=project.view"
+
+def test_local_mode_unchanged():
+    url = service_access_auth_url(
+        "http://auth-server/auth", "session.open", "p-1", auth_custom=False,
+    )
+    assert url == (
+        "http://auth-server/auth/service-access?permission=session.open&project_uuid=p-1"
+    )
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run (in the pod or a venv with the lib on path):
+`python -m pytest lib/python/orchest-internals/tests/test_service_access_auth_url.py -q`
+Expected: FAIL on the two Maestro cases (current code returns the base URL unchanged).
+
+- [ ] **Step 3: Write minimal implementation**
+
+Replace the `if auth_custom:` short-circuit in `utils.py`:
+
+```python
+    if auth_custom:
+        # Maestro mode: no /auth/service-access sibling route — the unified
+        # /auth/module-identity route authorizes when the annotation carries
+        # the scope. Append the same permission/project_uuid params. (Maestro
+        # derives the tenant orchest-api host from the JWT, not from the URL.)
+        query = f"permission={permission}"
+        if project_uuid:
+            query += f"&project_uuid={project_uuid}"
+        return f"{base_auth_url}?{query}"
+```
+
+Update the docstring's "falls back to the plain base_auth_url" paragraph to describe the new scoped behavior.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `python -m pytest lib/python/orchest-internals/tests/test_service_access_auth_url.py -q`
+Expected: PASS (all three).
+
+- [ ] **Step 5: Commit (dbt-to-orchest repo)**
+
+```bash
+git add lib/python/orchest-internals/_orchest/internals/utils.py lib/python/orchest-internals/tests/test_service_access_auth_url.py
+git commit -m "feat(rbac): scope Maestro-mode service auth-url (close direct-URL bypass)"
+```
+
+---
+
+## Deployment & manual verification (after Tasks 1-6)
+
+Not code steps — run after merging, per the spec §8/§10.
+
+- [ ] **Maestro env** on the Orchest-serving deployment: `ORCHEST_MODULE_PERMISSION_SEQID=31`, `ORCHEST_ADMIN_PERMISSION_SEQIDS=34`, `ORCHEST_NAMESPACE_MODULE=intelli`.
+- [ ] **OrchestCluster spec** (webserver ingress): `AuthCustom: true`, `AuthUrl: http://maestro.<maestro-ns>.svc.cluster.local/auth/module-identity`, `AuthSignin: <platform login URL>`.
+- [ ] **⚠️ celery-worker rebuild (Phase 2 / Task 6):** `service_access_auth_url` runs in the **celery-worker baked image** — rebuild + roll it, and verify the scoped annotation on a **freshly launched** service ingress (`kubectl get ingress …`), never an existing one. (This gotcha cost a debugging cycle last week; see `docs/source/development/building_images_minikube.md`.)
+- [ ] **Verify path A (spec §10):** curl-drive orchest-api with the `X-Auth-*` headers Maestro would set and watch the RBAC ladder + `external_admin` resolve, before standing up real Maestro.
+- [ ] **Forgery checks (spec §9.11, §9.12):** a non-admin's forged `X-Auth-Roles: admin` through the ingress must not reach orchest-api as admin; `?permission=…` appended to the app URL must not trigger an authz check.
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- §4.1 cookie auth + JWKS reuse → Task 2 (expose verify) + Task 3 (read cookie).
+- §4.2 ladder (401/403/200 + authz + all-or-nothing + no refresh) → Task 3 (401/403/200) + Task 5 (authz, 502, all-or-nothing).
+- §4.3 three headers, no email → Task 3 (sets exactly the three; email never set).
+- §5 module gate + admin set (config, list) → Task 1 + Task 3.
+- §5.1 tenant routing (namespace pattern, allowlist, slug note, dadosferademo2) → Task 4 + Task 5.
+- §6 forgery boundary → deployment verification checklist.
+- §7 service_access_auth_url scoping → Task 6.
+- §8 deployment config → deployment checklist.
+- §9 tests 1-12 → Tasks 1/3 (1-5), Task 5 (6-10), deployment checklist (11-12).
+- §10 minikube verification → deployment checklist.
+- §11 phase split → Phase 1 (Tasks 1-3) / Phase 2 (Tasks 4-6).
+
+**Placeholder scan:** none — every code step has real content; the only deliberately-open items are flagged verify-steps (HTTP client choice in Task 5; `customer_name` slug normalization in Task 4), each with an explicit instruction to inspect rather than guess.
+
+**Type consistency:** `verifyAccessToken` (Task 2) consumed in Tasks 3/5; `moduleIdentity(req,res)` signature identical across Tasks 3/5; helper names (`parseAdminSeqids`, `moduleGateSeqid`, `isModuleAllowed`, `isAdmin`, `tenantOrchestApiHost`, `isAllowedOrchestApiHost`, `namespaceModule`) defined in Tasks 1/4 and used verbatim in Tasks 3/5; `authorizeOrchestServiceAccess` return union `'allow'|'deny'|'error'` consistent between service (Task 5 3a) and controller (Task 5 3b).
@@ -16,14 +16,7 @@ declare global {
      OPEN_CUSTOMER_ID: string;
      DEDICATED_PROXY: string;
      COOKIE_SECRET: string;
-
-      // Autodrive Configuration
-      AUTODRIVE_USERNAME?: string;
-      AUTODRIVE_PASSWORD?: string;
-      AUTODRIVE_BASE_URL?: string;
-      AUTODRIVE_MODEL?: string;
-      AUTODRIVE_KEY?: string;
-      AUTO_DRIVE_KEY?: string;
+      REDIS_TLS?: string;
    }
  }
 }
@@ -5,6 +5,9 @@ const config: Config.InitialOptions = {
  roots: ['<rootDir>/src/', '<rootDir>/test/'],
  testRegex: '.*\\.(test|spec)\\.[jt]s$',
  transform: { '\\.[jt]s$': 'ts-jest' },
+  // Dummy values for env vars read at module-import time (see the setup file),
+  // so specs importing those modules don't crash on load.
+  setupFiles: ['<rootDir>/test/jest.setup-env.ts'],
  collectCoverageFrom: ['**/*.[jt]s'],
  coverageDirectory: 'coverage',
  coveragePathIgnorePatterns: [
@@ -10,7 +10,7 @@
  },
  "scripts": {
    "co:login": "aws codeartifact login --tool npm --namespace @dadosfera --repository dadosfera-npm --domain dadosfera --domain-owner 611330257153 --region us-east-1",
-    "proto-update": "npm i @dadosfera/protospack-v2@latest --save-exact",
+    "proto-update": "npm i @dadosfera/protospack-v2@v3.40.0-beta.1 --save-exact",
    "prebuild": "rimraf dist",
    "build": "nest build",
    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -27,10 +27,14 @@
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  "dependencies": {
+    "@aws-crypto/sha256-js": "^5.2.0",
+    "@aws-sdk/client-dynamodb": "^3.414.0",
    "@aws-sdk/client-secrets-manager": "^3.414.0",
+    "@aws-sdk/credential-provider-node": "^3.940.0",
+    "@aws-sdk/lib-dynamodb": "^3.414.0",
+    "@aws-sdk/signature-v4": "^3.370.0",
    "@dadosfera/dadosfera-logs": "^1.0.0-beta.4",
-    "@dadosfera/protospack": "2.5.3",
-    "@dadosfera/protospack-v2": "3.38.0-beta.10",
+    "@dadosfera/protospack-v2": "^3.40.0-beta.14",
    "@grpc/grpc-js": "^1.9.3",
    "@grpc/proto-loader": "^0.7.9",
    "@nestjs/cli": "^9.5.0",
@@ -44,7 +48,7 @@
    "@nestjs/schematics": "^9.2.0",
    "@nestjs/swagger": "^6.3.0",
    "@nestjs/testing": "^9.4.3",
-    "axios": "^0.27.2",
+    "axios": "0.30.3",
    "cache-manager": "^5.1.4",
    "cache-manager-ioredis-yet": "^1.1.0",
    "class-transformer": "^0.5.1",
@@ -60,6 +64,7 @@
    "jwk-to-pem": "^2.0.5",
    "mixpanel": "^0.17.0",
    "ms": "^3.0.0-canary.1",
+    "multer": "^2.0.2",
    "openid-client": "^5.7.1",
    "passport": "^0.6.0",
    "passport-facebook": "^3.0.0",
@@ -75,11 +80,17 @@
    "swagger-ui-express": "^4.6.3"
  },
  "overrides": {
-    "multer": "1.4.5-lts.1"
+    "axios": "0.30.3",
+    "form-data": "^4.0.4",
+    "body-parser": "^1.20.3",
+    "cross-spawn": "^7.0.5",
+    "glob": "^10.5.0",
+    "path-to-regexp": "^3.3.0",
+    "semver": "^7.5.2"
  },
  "devDependencies": {
-    "@types/cookie-parser": "^1.4.9",
    "@types/cache-manager": "^4.0.6",
+    "@types/cookie-parser": "^1.4.9",
    "@types/express": "^4.17.17",
    "@types/express-session": "^1.18.1",
    "@types/jest": "27.0.2",
@@ -106,5 +117,8 @@
    "ts-node": "^10.9.1",
    "tsconfig-paths": "^3.14.2",
    "typescript": "^4.9.5"
+  },
+  "resolutions": {
+    "axios": "0.30.3"
  }
 }
@@ -17,7 +17,6 @@ import { ConnectionTestModule } from './modules/connection-test/connection-test.
 import { NetworkConfigModule } from './modules/network-config/network-config.module';
 import { InputsModule } from './modules/inputs/inputs.module';
 import { OauthModule } from './modules/oauth/oauth.module';
-import { PipelinesModule } from './modules/pipelines/pipelines.module';
 import { TransformationsModule } from './modules/transformations/transformations.module';
 import { HealthModule } from './modules/health/health.module';
 import { CatalogModule } from './modules/catalog/catalog.module';
@@ -33,6 +32,10 @@ import { NetworkPolicyModule } from './modules/network-policy/network-policy.mod
 import { AssignModule } from './modules/assign/assign.module';
 import { ShareMetadataModule } from './modules/share-metadata/share-metadata.module';
 import { ApiKeyModule } from './modules/api-key/api-key.module';
+import { PlatformApiModule } from './modules/platform-api/platform-api.module';
+import { StorageExplorerModule } from './modules/storage-explorer/storage-explorer.module';
+import { ReleaseNoteModule } from './modules/release_note/release_note.module';
+

@Module({
  providers: [
@@ -56,7 +59,6 @@ import { ApiKeyModule } from './modules/api-key/api-key.module';
    PermissionsModule,
    TermsOfUseModule,
    ConnectionTestModule,
-    PipelinesModule,
    TransformationsModule,
    UsersModule,
    RolesModule,
@@ -73,8 +75,11 @@ import { ApiKeyModule } from './modules/api-key/api-key.module';
    ApiKeyModule,
    IdentityProviderModule,
    NetworkPolicyModule,
+    PlatformApiModule,
+    StorageExplorerModule,
    //Always leave HealthModule last, so it is on the bottom of swagger
    HealthModule,
+    ReleaseNoteModule,
  ],
 })
 export class AppModule {}
@@ -153,6 +153,7 @@ export class AuthenticationGuard
      user_id: accessTokenPayload.user_id,
      username: accessTokenPayload.username,
      permissions: accessTokenPayload.permissions,
+      roles: accessTokenPayload.roles,
      customer_id: accessTokenPayload.customer_id,
      customer_name: accessTokenPayload.customer_name,
      customer_tier: accessTokenPayload.customer_tier,
@@ -0,0 +1,21 @@
+import jwt, { JwtPayload } from 'jsonwebtoken';
+
+export function extractUserFrom(aRawJwt: string) {
+  const decodedToken = jwt.decode(aRawJwt, {
+    complete: true,
+  });
+
+  const payload = decodedToken.payload as JwtPayload;
+
+  return {
+    user_id: payload.user_id,
+    username: payload.username,
+    permissions: payload.permissions,
+    roles: payload.roles,
+    customer_id: payload.customer_id,
+    customer_name: payload.customer_name,
+    customer_tier: payload.customer_tier,
+    customer_modules: payload.customer_modules,
+    access_token: aRawJwt,
+  }
+}
@@ -116,6 +116,44 @@ export const PERMISSIONS_GROUPS = {
      },
    },
  },
+  IMPORT_FILES: {
+    title: {
+      'pt-br': 'Coletar | Importar arquivos',
+      'en-us': 'Collect | Import files',
+      'es-es': 'Colecta | Importar archivos',
+    },
+    permissions: {
+      VIEW: {
+        seqid: 48,
+        claim: 'import-file:view',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Importar arquivos',
+          'en-us': 'Import files',
+          'es-es': 'Importar archivos',
+        },
+      },
+    },
+  },
+   AI_CHAT: {
+    title: {
+      'pt-br': 'AutodriveDDF',
+      'en-us': 'AutodriveDDF',
+      'es-es': 'AutodriveDDF',
+    },
+    permissions: {
+      VIEW: {
+        seqid: 49,
+        claim: 'ai-chat:view',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'AutodriveDDF',
+          'en-us': 'AutodriveDDF',
+          'es-es': 'AutodriveDDF',
+        },
+      },
+    },
+  },
  CONNECTION: {
    title: {
      'pt-br': 'Coletar | Fontes de dados',
@@ -319,6 +357,16 @@ export const PERMISSIONS_GROUPS = {
          'es-es': 'Crear y editar atributos en el catálogo',
        },
      },
+      CERTIFY: {
+        seqid: 53,
+        claim: 'catalog:certify',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Alterar o status de certificação dos Ativos',
+          'en-us': "Change Assets' certification status",
+          'es-es': 'Cambiar el estado de certificación de los Activos',
+        },
+      },
      DELETE: {
        seqid: 1,
        claim: 'catalog:delete',
@@ -352,6 +400,25 @@ export const PERMISSIONS_GROUPS = {
      },
    },
  },
+  LINEAGE: {
+    title: {
+      'pt-br': 'Explorar | Linhagem',
+      'en-us': 'Explore | Lineage',
+      'es-es': 'Explorar | Linaje',
+    },
+    permissions: {
+      VIEW: {
+        seqid: 50,
+        claim: 'lineage:view',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar ao módulo de Linhagem',
+          'en-us': 'Access to Lineage module',
+          'es-es': 'Acceda al módulo de Linaje',
+        },
+      }
+    },
+  },
  EMBED: {
    title: {
      'pt-br': 'Analisar | Incorporação',
@@ -611,6 +678,35 @@ export const PERMISSIONS_GROUPS = {
      },
    },
  },
+  STORAGE_EXPLORER: {
+    title: {
+      'pt-br': 'Storage Explorer',
+      'en-us': 'Storage Explorer',
+      'es-es': 'Storage Explorer',
+    },
+    permissions: {
+      READ: {
+        seqid: 51,
+        claim: 'storage-explorer:read',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Ler dados do Storage Explorer',
+          'en-us': 'Read Storage Explorer data',
+          'es-es': 'Leer datos del Storage Explorer',
+        },
+      },
+      WRITE: {
+        seqid: 52,
+        claim: 'storage-explorer:write',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Escrever dados no Storage Explorer',
+          'en-us': 'Write Storage Explorer data',
+          'es-es': 'Escribir datos en Storage Explorer',
+        },
+      },
+    },
+  },
 };
 export interface DadosferaModule {
  name: string;
@@ -626,6 +722,8 @@ export const DADOSFERA_MODULES_KEYS = {
  PII: 'pii',
  EMBED: 'embedded-analytics',
  EMBED_ASSIGNED: 'embed-assigned',
+  CATALOG: 'catalog',
+  COLLECT: 'collect',
 }

 export const DADOSFERA_MODULES: Array<DadosferaModule> = [
@@ -12,6 +12,7 @@ export interface RequestUser {
  customer_tier: string;
  access_token: string;
  customer_modules: string[];
+  roles: string[];
 }

 export const User: (options?: { required?: boolean }) => ParameterDecorator =
@@ -0,0 +1,65 @@
+import {
+  BadRequestException,
+  CanActivate,
+  ExecutionContext,
+  Inject,
+  Injectable,
+  OnModuleInit,
+} from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { map, Observable } from 'rxjs';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import {
+  ReadService,
+  ProtoServices,
+} from '@dadosfera/protospack-v2/dist/lib/PipelineV2';
+import { PipelinesClientConfiguration } from 'src/modules/pipelinesV2/pipelines-client';
+import { PlatformApiService } from 'src/modules/platform-api/platform-api.service';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+@Injectable()
+export class PipelineExecutionGuard implements CanActivate {
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private readonly platformApiService: PlatformApiService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    try {
+      this.logger.info(
+        'PipelineExecutionGuard: Checking if pipeline can be executed...',
+      );
+      const request = context.switchToHttp().getRequest();
+      const pipelineId = request.params.pipelineId;
+      const user = request.user;
+      const idRegex = /[^0-9a-zA-Z_$]+/g;
+      const convertedId = pipelineId.replace(idRegex, '_');
+  
+      const status = await this.platformApiService.proxy(
+        'GET',
+        `/pipeline/${convertedId}/pipeline_run`,
+        user,
+      );
+
+      const currentStatus = status[status.length - 1]
+
+      this.logger.info('Pipeline current status response:' +  JSON.stringify(currentStatus));
+  
+      if (currentStatus.last_status.toLowerCase() === 'running') {
+        this.logger.error('Pipeline is running, cannot update input now');
+        throw new BadRequestException('Pipeline is running, cannot update input now');
+      } else {
+        return true;
+      }
+    } catch (error) {
+      this.logger.error('Error in PipelineExecutionGuard: ' + error.message);
+      throw new BadRequestException('Error checking pipeline status: ' + error.message);
+    }
+
+  }
+}
@@ -18,21 +18,41 @@ async function bootstrap() {
  });
  const logger = new DadosferaLogger();

+  const corsOrigins = [];
+
+  if (process.env.ENV === 'local') {
+    corsOrigins.push('http://localhost:4200');
+  } else {
+    corsOrigins.push( 
+      'https://app.stg.dadosfera.ai',
+      'https://app.dadosfera.ai',
+      'https://private-frontend.stg.dadosfera.ai',
+      'https://unimed.dadosfera.ai',
+      'https://boston-scientific.dadosfera.ai',
+      'https://plataforma.dadosfera.ai'
+    );
+  }
+
  const app = await NestFactory.create(AppModule, {
    logger,
    cors: {
-      origin: '*',
+      origin: corsOrigins,
      methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
      preflightContinue: false,
      optionsSuccessStatus: 204,
-      credentials: true
+      credentials: true,
    },
  });
+
  app.use(helmet());
  app.use(cookieParser(process.env.COOKIE_SECRET));
-  if (process.env.ENV === 'prd') {
+
+  if (process.env.ENV !== 'local') {
    app.use('/catalog/register-dataset', json({ limit: '10mb' }));
-    app.use('/catalog/register-dataset', urlencoded({ extended: true, limit: '10mb' }));
+    app.use(
+      '/catalog/register-dataset',
+      urlencoded({ extended: true, limit: '10mb' }),
+    );
  }

  configureSwagger(app);
@@ -91,3 +111,4 @@ function configureSwagger(app: INestApplication) {
  );
 }
 bootstrap();
+
@@ -1,4 +1,4 @@
-import { Controller, Post, Body, Put, Get} from '@nestjs/common';
+import { Controller, Body, Put, Get, NotFoundException} from '@nestjs/common';
 import { AssignService } from './assign.service';
 import { CreateAssignDto } from './dto/create-assign.dto';
 import { Authenticated, RequireModule, RequireSomePermission } from 'src/decorators/authentication.decorator';
@@ -28,6 +28,10 @@ export class AssignController {
  @RequireModule(DADOSFERA_MODULES_KEYS.EMBED_ASSIGNED)
  async get(@User() user: RequestUser) {
    const metadata = PackTheMetadata(user);
-    return await this.assignService.get(metadata);
+    try {
+      return await this.assignService.get(metadata);
+    } catch (error) {
+      throw new NotFoundException(error.message)
+    }
  }
 }
@@ -13,6 +13,7 @@ import {
  Req,
  Param,
  Res,
+  UnauthorizedException,
 } from '@nestjs/common';
 import {
  ApiHeaders,
@@ -31,6 +32,15 @@ import {
 } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';

 import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import {
+  parseAdminSeqids,
+  moduleGateSeqid,
+  isModuleAllowed,
+  isAdmin,
+  tenantOrchestApiHost,
+  isAllowedOrchestApiHost,
+  namespaceModule,
+} from './orchest-identity';
 import {
  Authenticated,
  RequireAllPermissions,
@@ -54,7 +64,7 @@ import jwt, { JwtPayload } from 'jsonwebtoken';
 import { LanguageEnum } from 'src/utils/languages.enum';
 import { Language } from 'src/decorators/language.decorator';
 import { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
-import { Cookie } from 'express-session';
+import { ApiKeyService } from 'src/modules/api-key/api-key.service';

 type CookiesValues = {
  accessToken?: string;
@@ -74,6 +84,7 @@ export class AuthController {
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
    private authClient: AuthClientService,
+    private apiKeyService: ApiKeyService,
  ) {
    this.logger = dadosferaLogger.logger;

@@ -103,14 +114,13 @@ export class AuthController {
      const data = await this.authClient.signIn({ username, password, totp }, metadata);

      if (data.tokens) {
-        this.addTokenInCookie(res, {
+        this.authClient.writeAuthSession(res, {
          accessToken: data.tokens.accessToken,
          refreshToken: data.tokens.refreshToken,
          userId: data.user.id
        });
      }

-
      return res.send(data);
    } catch (error) {
      this.logger.error('/auth - SignIn - ERROR', error);
@@ -127,27 +137,8 @@ export class AuthController {
  ) {
    try {
      this.logger.info('/auth - SignOut');
-      const exp = 1000 * 60 * 3;
-
-      res.cookie('ddf-auth', '', {
-        domain: 'dadosfera.local',
-        maxAge: Date.now() - exp,
-        expires: new Date(),
-        httpOnly: true,
-        secure: true,
-        sameSite: 'none', // Necessário para cookies em requisições cross-site
-      });
-
-      res.cookie('ddf-refresh-auth', '', {
-        domain: 'dadosfera.local',
-        maxAge: Date.now() - exp,
-        expires: new Date(),
-        httpOnly: true,
-        secure: true,
-        sameSite: 'none', // Necessário para cookies em requisições cross-site
-      });
-
-      this.logger.info('Clean cookie sessions');
+   
+      this.authClient.cleanUpAuthSession(res);

      return res.send();
    } catch (error) {
@@ -176,8 +167,9 @@ export class AuthController {

    const data = await this.authClient.refreshAccessToken({ refreshToken, userId }, metadata);

-    this.addTokenInCookie(res, {
+    this.authClient.writeAuthSession(res, {
      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
      userId
    });

@@ -209,13 +201,14 @@ export class AuthController {
  ) {
    this.logger.info('/auth - change-password');

-    const { oldPassword, newPassword } = body;
+    const { oldPassword, newPassword, totpCode } = body;
    const { authorization: accessToken } = headers;

    return this.authClient.changePassword({
      accessToken,
      oldPassword,
      newPassword,
+      totpCode,
    });
  }

@@ -233,7 +226,8 @@ export class AuthController {

    const { username } = body;

-    return this.authClient.resetPassword({ username }, metadata);
+    await this.authClient.resetPassword({ username }, metadata);
+    return { authProvider: process.env.AUTH_PROVIDER || 'cognito' };
  }

  @ApiInternalOnlyEndpoint()
@@ -493,114 +487,137 @@ export class AuthController {
  @Get('me')
  async getMe(@Req() req: Request, @Res() res: Response) {
    this.logger.info('GET /auth/me ')
-    // Lê cookies
-    const accessToken = req.cookies['ddf-auth'];
-    const userId = req.cookies['ddf-user-id'];
+    this.logger.info(JSON.stringify(req.headers));

-    this.logger.info('Has cookie: ' + Boolean(accessToken))
-    let payload: any;
-    let userInfo: any = {};
-    try {
-      // Decodifica e valida o JWT de acesso
-      const decoded: any = accessToken && jwt.decode(accessToken, { complete: true });
-      if (!decoded) throw new Error('Invalid token')
-      const { kid } = decoded.header;
-      // Busca a chave pública
-      const { keys } = await this.authClient.getPublicKeys();
-      const pemValue = keys.find((k) => k.kid === kid)?.pem;
-      if (!pemValue) throw new Error('Public key not found');
-      jwt.verify(accessToken, pemValue);
-      payload = decoded.payload;
-      userInfo = {
-        id: payload.user_id,
-        name: payload.username,
+    // Check for API key header first
+    const apiKey = req.get('X-Api-key');
+    if (apiKey) {
+      this.logger.info('Authenticating via X-Api-key header');
+      const { api_key } = await this.apiKeyService.get(apiKey);
+
+      const userDto = {
+        id: api_key.user_id,
+        name: api_key.username,
+        email: api_key.username,
        customer: {
-          id: payload.customer_id,
-          name: payload.customer_name,
-          tier: payload.customer_tier,
+          id: api_key.customer_id,
+          name: api_key.customer_name,
+          tier: api_key.customer_tier,
        }
      };
-      return res.status(200).json(userInfo);
-    } catch (err) {
-      this.logger.error(err.message);
-      const refreshToken = req.cookies['ddf-refresh-auth'];

-      this.logger.info('Token is invalid')
-      this.logger.info('Has Refresh Token: '+ Boolean(refreshToken))
-      // Se access token inválido, tenta refresh
-      if (!refreshToken || !userId) {
+      return res.status(200).json(userDto);
+    }
+
+    // Get token and headers
+    const accessToken = req.cookies['ddf-auth'];
+    const refreshToken = req.cookies['ddf-refresh-auth'];
+    const userId = req.cookies['ddf-user-id'];
+    const resourceHost = req.headers["x-original-url"] as string || "" ;
+
+    const hasUserSession = Boolean(accessToken) && Boolean(userId);
+    this.logger.info('Has User Session: ' + hasUserSession);
+
+    if (!hasUserSession) {
+      throw new UnauthorizedException()
+    }
+
+    try {
+      const userDto = await this.authClient.validateUserSession(accessToken, resourceHost);
+      return res.status(200).json(userDto);
+    } catch (error) {
+
+      if (!refreshToken) {
        this.logger.error('Invalid refresh token or customer name');
-        return res.status(401).json({ error: 'Not authenticated' });
-      }
-      try {
-        // Chama refreshAccessToken
-        const metadata = PackTheMetadata({
-        });
-        this.logger.info('Call Refresh Token')
-        const data = await this.authClient.refreshAccessToken({ refreshToken, userId }, metadata);
-        this.logger.info('Finish Refresh Token')
-        // Retorna novo access token e dados mínimos
-        this.addTokenInCookie(res, {
-          accessToken: data.accessToken,
-          userId
-        });
-        // Decodifica novo token
-        const decoded: any = jwt.decode(data.accessToken, { complete: true });
-        const payload = decoded.payload;
-        userInfo = {
-          id: payload.user_id,
-          name: payload.username,
-          customer: {
-            id: payload.customer_id,
-            name: payload.customer_name,
-            tier: payload.customer_tier,
-          }
-        };
-        return res.status(200).json(userInfo);
-      } catch (refreshErr) {
-        this.logger.error(refreshErr)
-        return res.status(401).json({ error: 'Not authenticated' });
-      }
+        throw new UnauthorizedException("Invalid refresh token or customer name");
+      };
+
+      const {
+        authSession,
+        user
+      } = await this.authClient.refreshUserSession(refreshToken, userId, resourceHost);
+      this.authClient.writeAuthSession(res, authSession);
+      return res.status(200).json(user);
    }
  }

-  private addTokenInCookie(res: Response, data: CookiesValues) {
-    let exp = 1000 * 60 * 5; // 5 minutes
-
-    if (data.accessToken) {
-      const { exp: expiration } = jwt.decode(data.accessToken) as JwtPayload;
-      exp = (expiration - 30) * 1000; // exp em segundos, maxAge em ms
-
-      this.logger.info('Set Cookie ddf-auth')
-      res.cookie('ddf-auth', data.accessToken, {
-        domain: 'stg.dadosfera.ai',
-        maxAge: exp,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'none', // Necessário para cookies em requisições cross-site
-      });
+  /**
+   * Ingress auth subrequest for Orchest (see dbt-to-orchest
+   * docs/superpowers/specs/2026-08-20-maestro-module-identity-design.md).
+   *
+   * Authenticates the ddf-auth cookie, gates on the module permission, and
+   * returns the X-Auth-* identity headers orchest-api trusts. Never writes
+   * cookies (an auth_request response cannot). No token refresh: an expired
+   * token is a 401 (the signin flow re-auths).
+   */
+  @Get('module-identity')
+  async moduleIdentity(@Req() req: Request, @Res() res: Response) {
+    const token = req.cookies?.['ddf-auth'];
+    if (!token) {
+      return res.status(401).send();
    }

-    if (data.refreshToken) {
-      this.logger.info('Set Cookie ddf-refresh-auth')
-      res.cookie('ddf-refresh-auth', data.refreshToken, {
-        domain: 'stg.dadosfera.ai',
-        maxAge: exp,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'none', // Necessário para cookies em requisições cross-site
-      });
+    let payload: any;
+    try {
+      payload = await this.authClient.verifyAccessToken(token);
+    } catch (e) {
+      return res.status(401).send();
    }

-    if (data.userId) {
-      this.logger.info('Set Cookie ddf-refresh-auth')
-      res.cookie('ddf-user-id', data.userId, {
-        domain: 'stg.dadosfera.ai',
-        maxAge: exp,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'none', // Necessário para cookies em requisições cross-site
-      });
+    const perms: number[] = payload?.permissions ?? [];
+    const gate = moduleGateSeqid(process.env.ORCHEST_MODULE_PERMISSION_SEQID);
+    if (!isModuleAllowed(perms, gate)) {
+      return res.status(403).send();
    }
+
+    const adminUser = isAdmin(
+      perms,
+      parseAdminSeqids(process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS),
+    );
+
+    res.set('X-Auth-User', String(payload.user_id));
+    res.set('X-Auth-Username', String(payload.username ?? ''));
+    if (adminUser) {
+      res.set('X-Auth-Roles', 'admin');
+    }
+
+    // Service-ingress caller: the orchest-api-authored annotation carries the
+    // scope. Authorize per-project against the tenant's orchest-api. A
+    // param-less request is the webserver-ingress case → identity only.
+    const permission = req.query?.permission as string | undefined;
+    const projectUuid = req.query?.project_uuid as string | undefined;
+    if (permission) {
+      // All-or-nothing: an incomplete annotation must not silently skip the
+      // per-project check.
+      if (!projectUuid) {
+        return res.status(403).send();
+      }
+      const module = namespaceModule(process.env.ORCHEST_NAMESPACE_MODULE);
+      const host = tenantOrchestApiHost(
+        String(payload.customer_name ?? ''),
+        module,
+      );
+      if (!isAllowedOrchestApiHost(host)) {
+        return res.status(403).send();
+      }
+      const identityHeaders: Record<string, string> = {
+        'X-Auth-User': String(payload.user_id),
+        'X-Auth-Username': String(payload.username ?? ''),
+      };
+      if (adminUser) {
+        identityHeaders['X-Auth-Roles'] = 'admin';
+      }
+      const decision = await this.authClient.authorizeOrchestServiceAccess({
+        host,
+        permission,
+        projectUuid,
+        headers: identityHeaders,
+      });
+      if (decision === 'deny') return res.status(403).send();
+      if (decision === 'error') return res.status(502).send();
+      // 'allow' falls through to the 200 (identity headers already set).
+    }
+
+    return res.status(200).send();
  }
 }
@@ -8,10 +8,11 @@ import { AuthClientService } from './auth.service';
 import { DucClient } from '../duc/client.config';
 import { GoogleLoginStrategy } from './passport-strategies/google-strategy';
 import { getOauthSecrets } from 'src/utils/OauthSecrets';
+import { ApiKeyModule } from '../api-key/api-key.module';
 const client = new DucClient();

@Module({
-  imports: [ClientsModule.register([client.providerOptions])],
+  imports: [ClientsModule.register([client.providerOptions]), ApiKeyModule],
  controllers: [AuthController],
  providers: [
    AuthClientService,
@@ -1,10 +1,21 @@
-import { OnModuleInit, Inject, Injectable, ForbiddenException } from '@nestjs/common';
+import {
+  OnModuleInit,
+  Inject,
+  Injectable,
+  ForbiddenException,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { lastValueFrom } from 'rxjs';
+import axios from 'axios';

 import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
-import { AuthProtoService as AuthServiceInterface, IdentityProviderProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
+import {
+  AuthProtoService as AuthServiceInterface,
+  UsersProtoService,
+} from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
 import {
  AuthSnowflakeSignInRequest,
  AuthSignInRequest,
@@ -21,18 +32,24 @@ import {
 } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
 import { DucClient } from '../duc/client.config';
 import { Metadata } from '@grpc/grpc-js';
-import { BulkEditResponse } from './dtos/login';
+import { BulkEditResponse, UserDTO } from './dtos/login';
+import jwt, { JwtPayload } from 'jsonwebtoken';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { Request, Response } from 'express';

+type AuthSession = {
+  accessToken?: string;
+  refreshToken?: string;
+  userId?: string;
+};

@Injectable()
 export class AuthClientService implements OnModuleInit {
-
-
  logger: DadosferaLogger;

-
  private authService: AuthServiceInterface;
-  private identityProviderService: IdentityProviderProtoService;
+  private userService: UsersProtoService;
+
  constructor(
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
@@ -46,8 +63,8 @@ export class AuthClientService implements OnModuleInit {
      ProtoServices.AuthProtoService,
    );

-    this.identityProviderService = this.grpcClient.getService<IdentityProviderProtoService>(
-      ProtoServices.IdentityProviderProtoService,
+    this.userService = this.grpcClient.getService<UsersProtoService>(
+      ProtoServices.UsersProtoService,
    );
  }

@@ -63,11 +80,11 @@ export class AuthClientService implements OnModuleInit {
    return lastValueFrom(this.authService.AuthSnowflakeSignIn(input));
  }

-  checkDedicatedProxy({
-    customer
-  }: AuthSignInResponse) {
+  checkDedicatedProxy({ customer }: AuthSignInResponse) {
    const DEDICATED_PROXY = process.env.DEDICATED_PROXY || '';
-    this.logger.info('SignIn - Setting customer ID for dedicated proxy: ' + DEDICATED_PROXY);
+    this.logger.info(
+      'SignIn - Setting customer ID for dedicated proxy: ' + DEDICATED_PROXY,
+    );
    this.logger.info('Customer ID: ' + customer.id);

    if (DEDICATED_PROXY !== '' && DEDICATED_PROXY !== customer.id) {
@@ -75,7 +92,9 @@ export class AuthClientService implements OnModuleInit {
    }

    // Bloquear o customer de acesso o maestro publico
-    this.logger.info('Check if customer have network policy: ' + customer.modules);
+    this.logger.info(
+      'Check if customer have network policy: ' + customer.modules,
+    );
    const hasNetworkPolicyModule = customer.modules.includes('network-policy');
    if (hasNetworkPolicyModule && DEDICATED_PROXY === '') {
      throw new ForbiddenException();
@@ -94,7 +113,6 @@ export class AuthClientService implements OnModuleInit {
      result = await lastValueFrom(
        this.authService.AuthSignIn({ username, password, totp }, metadata),
      );
-
    } catch (error) {
      this.logger.error('SignIn - Error during sign-in');
      this.logger.error(error);
@@ -105,7 +123,7 @@ export class AuthClientService implements OnModuleInit {
      this.checkDedicatedProxy(result);
    }

-    return result
+    return result;
  }

  async refreshAccessToken(
@@ -115,7 +133,10 @@ export class AuthClientService implements OnModuleInit {
    this.logger.info('RefreshAccessToken');

    return lastValueFrom(
-      this.authService.AuthRefreshAccessToken({ refreshToken, userId }, metadata),
+      this.authService.AuthRefreshAccessToken(
+        { refreshToken, userId },
+        metadata,
+      ),
    );
  }

@@ -123,6 +144,7 @@ export class AuthClientService implements OnModuleInit {
    accessToken,
    oldPassword,
    newPassword,
+    totpCode,
  }: AuthChangePasswordRequest) {
    this.logger.info('ChangePassword');

@@ -131,6 +153,7 @@ export class AuthClientService implements OnModuleInit {
        accessToken,
        oldPassword,
        newPassword,
+        totpCode,
      }),
    );
  }
@@ -283,4 +306,225 @@ export class AuthClientService implements OnModuleInit {
      throw error;
    }
  }
+
+  public async validateUserSession(accessToken: any, resourceHost: string) {
+    const payload = await this.verifyAccessToken(accessToken);
+
+    const userDto = await this.getUserfromPayload(payload);
+
+    this.validateResourceAccess(resourceHost, userDto);
+    return userDto;
+  }
+
+  public async refreshUserSession(
+    refreshToken: string,
+    userId: string,
+    originHeader: string,
+  ): Promise<{
+    user: UserDTO;
+    authSession: AuthSession;
+  }> {
+    const metadata = PackTheMetadata({});
+
+    this.logger.info('Call Refresh Token');
+    const refreshCredentials = await this.refreshAccessToken(
+      { refreshToken, userId },
+      metadata,
+    );
+    this.logger.info('Finish Refresh Token');
+
+    const userDto = await this.validateUserSession(
+      refreshCredentials.accessToken,
+      originHeader,
+    );
+    return {
+      user: userDto,
+      authSession: {
+        accessToken: refreshCredentials.accessToken,
+        refreshToken: refreshCredentials.refreshToken,
+        userId,
+      },
+    };
+  }
+
+  public writeAuthSession(res: Response, data: AuthSession) {
+    let exp = 1000 * 60 * 5; // 5 minutes
+
+    if (data.accessToken) {
+      const { exp: expiration } = jwt.decode(data.accessToken) as JwtPayload;
+      exp = (expiration - 30) * 1000; // exp em segundos, maxAge em ms
+
+      this.logger.info('Set Cookie ddf-auth');
+      res.cookie('ddf-auth', data.accessToken, {
+        domain: '.dadosfera.ai',
+        maxAge: exp,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'none', // Necessário para cookies em requisições cross-site
+      });
+    }
+
+    if (data.refreshToken) {
+      this.logger.info('Set Cookie ddf-refresh-auth');
+      res.cookie('ddf-refresh-auth', data.refreshToken, {
+        domain: '.dadosfera.ai',
+        maxAge: exp,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'none', // Necessário para cookies em requisições cross-site
+      });
+    }
+
+    if (data.userId) {
+      this.logger.info('Set Cookie ddf-refresh-auth');
+      res.cookie('ddf-user-id', data.userId, {
+        domain: '.dadosfera.ai',
+        maxAge: exp,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'none', // Necessário para cookies em requisições cross-site
+      });
+    }
+  }
+
+  public cleanUpAuthSession(res: Response) {
+    const exp = 1000 * 60 * 3;
+
+    res.cookie('ddf-auth', '', {
+      domain: 'dadosfera.ai',
+      maxAge: Date.now() - exp,
+      expires: new Date(),
+      httpOnly: true,
+      secure: true,
+      sameSite: 'none', // Necessário para cookies em requisições cross-site
+    });
+
+    res.cookie('ddf-refresh-auth', '', {
+      domain: 'dadosfera.ai',
+      maxAge: Date.now() - exp,
+      expires: new Date(),
+      httpOnly: true,
+      secure: true,
+      sameSite: 'none', // Necessário para cookies em requisições cross-site
+    });
+
+    this.logger.info('Clean cookie sessions');
+  }
+
+  /**
+   * Verify a DUC access token against the JWKS and return its payload.
+   * Public so the /auth/module-identity route can authenticate the ddf-auth
+   * cookie the same way (was the private validateJwtToken).
+   */
+  public async verifyAccessToken(token: string) {
+    const decoded: any = token && jwt.decode(token, { complete: true });
+    if (!decoded) throw new Error('Invalid token');
+
+    const { kid } = decoded.header;
+    // Busca a chave pública
+    const { keys } = await this.getPublicKeys();
+    const pemValue = keys.find((k) => k.kid === kid)?.pem;
+    if (!pemValue) throw new Error('Public key not found');
+    jwt.verify(token, pemValue);
+
+    return decoded.payload;
+  }
+
+  private async getUserfromPayload(payload: JwtPayload): Promise<UserDTO> {
+    this.logger.info('getUser');
+
+    const metadata = PackTheMetadata({
+      customer_id: payload.customer_id,
+    });
+
+    const { user } = await lastValueFrom(
+      this.userService.UserFindOneById({ id: payload.user_id }, metadata),
+    );
+
+    const userDto: UserDTO = {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      jobTitle: user?.jobTitle || null,
+      department: user?.department || null,
+      hierarchy: user?.hierarchy || null,
+      customer: {
+        id: payload.customer_id,
+        name: payload.customer_name,
+        tier: payload.customer_tier,
+      },
+    };
+
+    return userDto;
+  }
+
+  private validateResourceAccess(host: string, user: UserDTO) {
+    this.logger.info(
+      "Validate whether the source URL is a resource belonging to the user's client",
+    );
+    this.logger.info('Host: ' + host);
+    this.logger.info('Customer: ' + user.customer.name);
+
+    const hostParts = host.split('.');
+    const domain = hostParts[0];
+    const isResouceStg = hostParts[1] === 'stg';
+
+    const notFoundCustomerInDomain = !domain.includes('-')
+
+    if (notFoundCustomerInDomain) {
+      this.logger.info(`Not found Customer Name in domain`);
+      return;
+    }
+
+    const domainParts = domain.split('-');
+
+    const customerInDomain = domainParts[domainParts.length - 1];
+
+    if (isResouceStg && process.env.ENV !== 'stg') {
+      this.logger.error(`Customer ${user.customer.name} cannot access ${host}`);
+      throw new HttpException(
+        `Customer ${user.customer.name} cannot access ${host}`,
+        HttpStatus.FORBIDDEN
+      );
+    }
+
+    if (customerInDomain != user.customer.name) {
+      this.logger.error(`Customer ${user.customer.name} cannot access ${host}`);
+      throw new HttpException(
+        `Customer ${user.customer.name} cannot access ${host}`,
+        HttpStatus.FORBIDDEN
+      );
+    }
+
+    return;
+  }
+
+  /**
+   * Ask a tenant's orchest-api whether the acting user holds `permission` on
+   * `projectUuid` (the per-service authz half of /auth/module-identity).
+   * Fail-closed: any error / unexpected status → 'error' (the route denies).
+   */
+  public async authorizeOrchestServiceAccess(args: {
+    host: string;
+    permission: string;
+    projectUuid?: string;
+    headers: Record<string, string>;
+  }): Promise<'allow' | 'deny' | 'error'> {
+    const params: Record<string, string> = { permission: args.permission };
+    if (args.projectUuid) params.project_uuid = args.projectUuid;
+    try {
+      const resp = await axios.get(`http://${args.host}/api/authz/check`, {
+        params,
+        headers: args.headers,
+        timeout: 5000,
+        // Never throw on 4xx/5xx; branch on the status ourselves.
+        validateStatus: () => true,
+      });
+      if (resp.status === 200) return 'allow';
+      if (resp.status === 403) return 'deny';
+      return 'error';
+    } catch (e) {
+      return 'error';
+    }
+  }
 }
@@ -140,3 +140,17 @@ export interface BulkEditResponse {
  successfulUsers: string[];
  failedUsers: string[];
 }
+
+export type UserDTO = {
+  id: string,
+  name: string,
+  email: string,
+  jobTitle?: string,
+  department?: string,
+  hierarchy?: string,
+  customer: {
+    id: string,
+    name: string,
+    tier: string,
+  }
+}
@@ -0,0 +1,206 @@
+import { Test } from '@nestjs/testing';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { AuthController } from './auth.controller';
+import { AuthClientService } from './auth.service';
+import { ApiKeyService } from 'src/modules/api-key/api-key.service';
+
+function res() {
+  const headers: Record<string, string> = {};
+  const r: any = {
+    _status: 0,
+    _sent: undefined,
+    set: (k: string, v: string) => {
+      headers[k] = v;
+      return r;
+    },
+    status: (c: number) => {
+      r._status = c;
+      return r;
+    },
+    send: (b?: any) => {
+      r._sent = b ?? '';
+      return r;
+    },
+    json: (b?: any) => {
+      r._sent = b;
+      return r;
+    },
+    _headers: headers,
+  };
+  return r;
+}
+
+function req(cookie?: string, query: Record<string, string> = {}) {
+  return { cookies: cookie ? { 'ddf-auth': cookie } : {}, query } as any;
+}
+
+const loggerStub = {
+  logger: { info: jest.fn(), error: jest.fn(), warn: jest.fn() },
+} as unknown as DadosferaLogger;
+
+async function makeController(auth: AuthClientService): Promise<AuthController> {
+  const mod = await Test.createTestingModule({
+    controllers: [AuthController],
+    providers: [
+      { provide: DadosferaLogger, useValue: loggerStub },
+      { provide: AuthClientService, useValue: auth },
+      { provide: ApiKeyService, useValue: {} },
+    ],
+  }).compile();
+  return mod.get(AuthController);
+}
+
+describe('GET /auth/module-identity — identity', () => {
+  let controller: AuthController;
+  const auth = {
+    verifyAccessToken: jest.fn(),
+  } as unknown as AuthClientService;
+
+  beforeEach(async () => {
+    jest.resetAllMocks();
+    process.env.ORCHEST_MODULE_PERMISSION_SEQID = '31';
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34';
+    controller = await makeController(auth);
+  });
+
+  it('no cookie → 401', async () => {
+    const r = res();
+    await controller.moduleIdentity(req(undefined), r);
+    expect(r._status).toBe(401);
+  });
+
+  it('valid + module + admin → 200 with X-Auth-Roles: admin', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1',
+      username: 'alice',
+      permissions: [31, 34],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(200);
+    expect(r._headers['X-Auth-User']).toBe('u-1');
+    expect(r._headers['X-Auth-Username']).toBe('alice');
+    expect(r._headers['X-Auth-Roles']).toBe('admin');
+  });
+
+  it('valid + module, not admin → 200, no X-Auth-Roles', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-2',
+      username: 'bob',
+      permissions: [31],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(200);
+    expect(r._headers['X-Auth-Roles']).toBeUndefined();
+  });
+
+  it('valid, lacks module → 403', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-3',
+      username: 'carol',
+      permissions: [5],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(403);
+  });
+
+  it('verify throws (expired/bad) → 401', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockRejectedValue(new Error('bad'));
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._status).toBe(401);
+  });
+
+  it('admin seqids extended by config → 200 admin', async () => {
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34,99';
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-4',
+      username: 'dana',
+      permissions: [31, 99],
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok'), r);
+    expect(r._headers['X-Auth-Roles']).toBe('admin');
+  });
+});
+
+describe('GET /auth/module-identity — per-service authz', () => {
+  let controller: AuthController;
+  const auth = {
+    verifyAccessToken: jest.fn(),
+    authorizeOrchestServiceAccess: jest.fn(),
+  } as unknown as AuthClientService;
+
+  const q = { permission: 'session.open', project_uuid: 'p-1' };
+
+  beforeEach(async () => {
+    jest.resetAllMocks();
+    process.env.ORCHEST_MODULE_PERMISSION_SEQID = '31';
+    process.env.ORCHEST_ADMIN_PERMISSION_SEQIDS = '34';
+    process.env.ORCHEST_NAMESPACE_MODULE = 'intelli';
+    controller = await makeController(auth);
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1',
+      username: 'alice',
+      permissions: [31],
+      customer_name: 'acme',
+    });
+  });
+
+  it('has grant → 200 and calls the tenant host', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('allow');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(200);
+    expect(auth.authorizeOrchestServiceAccess).toHaveBeenCalledWith(
+      expect.objectContaining({
+        host: 'orchest-api.orchest-intelli-acme.svc.cluster.local',
+        permission: 'session.open',
+        projectUuid: 'p-1',
+      }),
+    );
+  });
+
+  it('lacks grant → 403', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('deny');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(403);
+  });
+
+  it('orchest-api error → 502 (fail-closed)', async () => {
+    (auth.authorizeOrchestServiceAccess as jest.Mock).mockResolvedValue('error');
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(502);
+  });
+
+  it('permission without project_uuid → 403 (all-or-nothing)', async () => {
+    const r = res();
+    await controller.moduleIdentity(req('tok', { permission: 'session.open' }), r);
+    expect(r._status).toBe(403);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+
+  it('no authz params → 200 identity-only (webserver case)', async () => {
+    const r = res();
+    await controller.moduleIdentity(req('tok', {}), r);
+    expect(r._status).toBe(200);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+
+  it('malformed customer_name → host fails allowlist → 403, no call', async () => {
+    (auth.verifyAccessToken as jest.Mock).mockResolvedValue({
+      user_id: 'u-1',
+      username: 'alice',
+      permissions: [31],
+      customer_name: '',
+    });
+    const r = res();
+    await controller.moduleIdentity(req('tok', q), r);
+    expect(r._status).toBe(403);
+    expect(auth.authorizeOrchestServiceAccess).not.toHaveBeenCalled();
+  });
+});
@@ -0,0 +1,76 @@
+import {
+  parseAdminSeqids,
+  moduleGateSeqid,
+  isModuleAllowed,
+  isAdmin,
+  tenantOrchestApiHost,
+  isAllowedOrchestApiHost,
+  namespaceModule,
+} from './orchest-identity';
+
+describe('orchest-identity mapping', () => {
+  it('parseAdminSeqids: default, single, list, whitespace', () => {
+    expect(parseAdminSeqids(undefined)).toEqual([34]);
+    expect(parseAdminSeqids('')).toEqual([34]);
+    expect(parseAdminSeqids('34')).toEqual([34]);
+    expect(parseAdminSeqids('34,40')).toEqual([34, 40]);
+    expect(parseAdminSeqids(' 34 , 40 ')).toEqual([34, 40]);
+  });
+
+  it('moduleGateSeqid: default and override', () => {
+    expect(moduleGateSeqid(undefined)).toBe(31);
+    expect(moduleGateSeqid('43')).toBe(43);
+  });
+
+  it('isModuleAllowed', () => {
+    expect(isModuleAllowed([31, 5], 31)).toBe(true);
+    expect(isModuleAllowed([5, 7], 31)).toBe(false);
+    expect(isModuleAllowed([], 31)).toBe(false);
+  });
+
+  it('isAdmin: intersection', () => {
+    expect(isAdmin([31, 34], [34])).toBe(true);
+    expect(isAdmin([31], [34])).toBe(false);
+    expect(isAdmin([99], [34, 99])).toBe(true);
+  });
+});
+
+describe('orchest-identity tenant routing', () => {
+  it('namespaceModule default and values', () => {
+    expect(namespaceModule(undefined)).toBe('intelli');
+    expect(namespaceModule('process')).toBe('process');
+    expect(namespaceModule('garbage')).toBe('intelli');
+  });
+
+  it('tenantOrchestApiHost builds the namespace pattern', () => {
+    expect(tenantOrchestApiHost('acme', 'intelli')).toBe(
+      'orchest-api.orchest-intelli-acme.svc.cluster.local',
+    );
+    expect(tenantOrchestApiHost('acme', 'process')).toBe(
+      'orchest-api.orchest-process-acme.svc.cluster.local',
+    );
+  });
+
+  it('tenantOrchestApiHost normalizes a non-slug customer_name', () => {
+    expect(tenantOrchestApiHost('Acme Corp', 'intelli')).toBe(
+      'orchest-api.orchest-intelli-acme-corp.svc.cluster.local',
+    );
+  });
+
+  it('isAllowedOrchestApiHost guards against malformed values', () => {
+    expect(
+      isAllowedOrchestApiHost(
+        'orchest-api.orchest-intelli-acme.svc.cluster.local',
+      ),
+    ).toBe(true);
+    expect(isAllowedOrchestApiHost('evil.example.com')).toBe(false);
+    expect(
+      isAllowedOrchestApiHost('orchest-api.orchest-intelli-.svc.cluster.local'),
+    ).toBe(false);
+    expect(
+      isAllowedOrchestApiHost(
+        'orchest-api.orchest-other-acme.svc.cluster.local',
+      ),
+    ).toBe(false);
+  });
+});
@@ -0,0 +1,70 @@
+/**
+ * Pure helpers backing `GET /auth/module-identity` (see
+ * dbt-to-orchest docs/superpowers/specs/2026-08-20-maestro-module-identity-design.md).
+ *
+ * Kept free of HTTP/Nest so the permission mapping and tenant-routing logic
+ * unit-test without a request. Authorization decisions that reach orchest-api
+ * live on AuthClientService; this module only maps Maestro permissions to the
+ * Orchest header contract and derives the tenant orchest-api host.
+ */
+
+/** Parse ORCHEST_ADMIN_PERMISSION_SEQIDS ("34" / "34,40"); default [34]. */
+export function parseAdminSeqids(raw: string | undefined): number[] {
+  if (!raw || !raw.trim()) return [34];
+  return raw
+    .split(',')
+    .map((s) => Number(s.trim()))
+    .filter((n) => Number.isInteger(n));
+}
+
+/** Parse ORCHEST_MODULE_PERMISSION_SEQID; default 31 (Intelligence/Orchest). */
+export function moduleGateSeqid(raw: string | undefined): number {
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : 31;
+}
+
+/** Whether the user's permissions include the module-access gate seqid. */
+export function isModuleAllowed(perms: number[], gateSeqid: number): boolean {
+  return Array.isArray(perms) && perms.includes(gateSeqid);
+}
+
+/** Whether the user's permissions intersect the admin seqid set. */
+export function isAdmin(perms: number[], adminSeqids: number[]): boolean {
+  return Array.isArray(perms) && perms.some((p) => adminSeqids.includes(p));
+}
+
+/** The `{module}` slug in the tenant namespace pattern; default 'intelli'. */
+export function namespaceModule(
+  raw: string | undefined,
+): 'intelli' | 'process' {
+  return raw === 'process' ? 'process' : 'intelli';
+}
+
+/**
+ * The in-cluster DNS of the calling tenant's orchest-api, from the tenant
+ * namespace convention `orchest-{module}-{customer_name}`.
+ *
+ * `customer_name` is normalized to the namespace slug shape (lowercase,
+ * non-[a-z0-9-] → '-') so a display-name value still yields a valid host; a
+ * value that is already a clean slug is unchanged. NOTE: confirm the exact
+ * prod `customer_name` → namespace mapping against a real token before relying
+ * on this in production (the `dadosferademo2` tenant is a known exception and
+ * is unsupported — it is being removed).
+ */
+export function tenantOrchestApiHost(
+  customerName: string,
+  module: string,
+): string {
+  const slug = String(customerName)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-');
+  return `orchest-api.orchest-${module}-${slug}.svc.cluster.local`;
+}
+
+const ORCHEST_API_HOST_RE =
+  /^orchest-api\.orchest-(intelli|process)-[a-z0-9-]+\.svc\.cluster\.local$/;
+
+/** Defense in depth: only call an orchest-api host matching the convention. */
+export function isAllowedOrchestApiHost(host: string): boolean {
+  return ORCHEST_API_HOST_RE.test(host);
+}
@@ -17,14 +17,12 @@ import {
  HttpStatus,
  Res,
 } from '@nestjs/common';
+import { ValidationPipe } from '../../pipes/object-validation.pipe';
 import {
  ApiCreatedResponse,
  ApiHeaders,
  ApiOkResponse,
  ApiTags,
-  ApiOperation,
-  ApiParam,
-  ApiResponse,
 } from '@nestjs/swagger';
 import {
  Authenticated,
@@ -49,6 +47,7 @@ import {
  IMakeAComment,
  IOneDataAsset,
  IPreviewResponse,
+  IUpdateCertificationStatusRequest,
  IUpdateDataRequest,
  TriggerCatalogReq,
  TriggerCatalogRes,
@@ -86,11 +85,18 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async searchCatalog(
    @User() user: RequestUser,
    @Query() query: ICatalogAllRequest,
  ): Promise<ICatalogAllResponse> {
    const { user_id, customer_name, customer_id, username, permissions } = user;
+    this.logger.info(`/catalog - searchCatalog`, {
+      user_id,
+      customer_name,
+    });

    const is_data_manager = permissions.includes(
      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
@@ -121,12 +127,19 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async dowloadAsserts(
    @User() user: RequestUser,
    @Query() query: ICatalogAllRequest,
    @Res() res: Response
  ) {
    const { user_id, customer_name, customer_id, username, permissions } = user;
+    this.logger.info(`/catalog/download - searchCatalog`, {
+      user_id,
+      customer_name,
+    });

    const is_data_manager = permissions.includes(
      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
@@ -160,9 +173,16 @@ export class CatalogController {

  @ApiInternalOnlyEndpoint()
  @Get('data-asset')
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async findByPipelineAndObject(@User() user: RequestUser, @Query() query) {
    const { username, user_id, customer_id, customer_name, permissions } = user;
    const { pipeline, object } = query;
+    this.logger.info(`/catalog - ON GET DATA ASSET BY PIPELINE AND OBJECT`, {
+      username,
+      customer_name,
+    });

    if (!pipeline || !object) {
      throw new BadRequestException('Query params not provided');
@@ -214,7 +234,14 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async findAllTags(@Body() body) {
+    this.logger.info(`/catalog - ON FIND ALL TAGS ROUTE`, {
+      user: body.info.user_id,
+      customer: body.info.customer,
+    });

    const { user_id, customer, customer_id } = body.info;
    const metadata = PackTheMetadata({
@@ -228,11 +255,59 @@ export class CatalogController {
    return res;
  }

+  @Get('schemas')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async findSchemas(@User() user: RequestUser) {
+    const { username, user_id, customer_id, customer_name } = user;
+    this.logger.info(`/catalog - ON FIND SCHEMAS ROUTE`, {
+      username,
+      customer_name,
+    });
+
+    const metadata = PackTheMetadata({
+      username,
+      user_id,
+      customer_id,
+      customer_name,
+    });
+
+    try {
+      const res = await this.catalogService.findSchemas(metadata);
+      return res;
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.NOT_FOUND);
+    }
+
+  }
+
+  @Get('custom-properties')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getCustomPropertyDefinitions(@User() user: RequestUser) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+
+    return this.catalogService.getCustomPropertyDefinitions(metadata);
+  }
+
  @Get('data-asset/:id')
  @RequireSomePermission(
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async getDataAsset(
    @User() user: RequestUser,
    @Param('id') id: string,
@@ -240,6 +315,10 @@ export class CatalogController {
  ) {
    const { username, user_id, customer_id, customer_name, permissions } = user;

+    this.logger.info(`GET /data-asset/${id}`, {
+      username,
+      customer_name,
+    });

    const is_data_manager = permissions.includes(
      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
@@ -292,6 +371,10 @@ export class CatalogController {
  ) {
    const { username, user_id, customer_id, customer_name, permissions } = user;

+    this.logger.info(`/catalog - ON GET ONE DASHBOARD METABASE ROUTE`, {
+      username,
+      customer_name,
+    });

    const is_data_manager = permissions.includes(
      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
@@ -336,6 +419,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async getDataAssetColumnsMetadata(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
@@ -343,6 +429,10 @@ export class CatalogController {
  ): Promise<IColumnsMetadataResponse> {
    const { customer_name, customer_id, user_id, username } = user;

+    this.logger.info(`/catalog - columns-metadata`, {
+      user_id,
+      customer_name,
+    });

    const metadata = PackTheMetadata({
      customer_name,
@@ -363,6 +453,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async getDataAssetPreview(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
@@ -370,6 +463,10 @@ export class CatalogController {
  ): Promise<IPreviewResponse> {
    const { customer_name, customer_id, user_id, username, customer_modules } = user;

+    this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });

    const metadata = PackTheMetadata({
      customer_name,
@@ -390,36 +487,33 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async getDataAssetDocs(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
    @Param('id') id: string,
+    @Query('asset_type') asset_type: string,
  ): Promise<IDocsResponse> {
-    try {
-      const { customer_name, customer_id, user_id, username } = user;
+    const { customer_name, customer_id, user_id, username } = user;

-      this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
-        user_id,
-        customer_name,
-        id,
-      });
+    this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });

-      const metadata = PackTheMetadata({
-        customer_name,
-        customer_id,
-        user_id,
-        username,
-        language,
-      });
+    const metadata = PackTheMetadata({
+      customer_name,
+      customer_id,
+      user_id,
+      username,
+      language,
+    });

-      const docs = await this.catalogService.getDataDocs(id, metadata);
+    const docs = await this.catalogService.getDataDocs(id, asset_type, metadata);

-      return { docs };
-    } catch (error) {
-      this.logger.error(`Error in getDataAssetDocs for id ${id}: ${error.message}`);
-      this.logger.error(`Error details: ${JSON.stringify(error)}`);
-      throw error;
-    }
+    return { docs };
  }

  @Put('data-asset/:id')
@@ -427,6 +521,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async updateDataAsset(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
@@ -442,6 +539,8 @@ export class CatalogController {
      language,
    });

+    delete (body as any).certification_status;
+
    const result = await this.catalogService.updateOneDataAsset({
      body,
      data_asset_id,
@@ -455,34 +554,84 @@ export class CatalogController {
    return result;
  }

+  @Put('data-asset/:id/certification-status')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.CERTIFY,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
+  async updateDataAssetCertificationStatus(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') data_asset_id: string,
+    @Body(new ValidationPipe()) body: IUpdateCertificationStatusRequest,
+  ): Promise<IUpdateCertificationStatusRequest> {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+      language,
+    });
+
+    return this.catalogService.updateCertificationStatus({
+      body,
+      data_asset_id,
+      metadata,
+    });
+  }
+
  @Post('data-asset/:id/docs')
  @RequireSomePermission(
    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async manageDataAssetDocs(
    @User() user: RequestUser,
    @Headers() headers,
    @Param('id') table_id: string,
    @Body('docs') docs: string,
+    @Query('asset_type') asset_type: string,
  ) {
-    const { user_id, customer_name } = user;
+    const { user_id, customer_name, customer_id, username } = user;
+    
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });

+    this.logger.info(`/catalog - ON POST DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });

-    const res = await this.catalogService.createDataDocs({
+    const body = {
      table_id,
      docs,
+      asset_type,
      info: {
        customer: customer_name,
      },
-    });
+    }
+
+    const res = await this.catalogService.createDataDocs(body, metadata);

    return res;
  }

-
  @ApiInternalOnlyEndpoint()
  @Put('data-asset/:id/manage-permissions')
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async manageDataAssetPermissions(
    @Param('id') id: string,
    @User() user: RequestUser,
@@ -505,6 +654,9 @@ export class CatalogController {

  @ApiInternalOnlyEndpoint()
  @Put('data-asset/:id/revoke-permissions')
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async revokeDataAssetPermissions(
    @Param('id') id: string,
    @User() user: RequestUser,
@@ -530,6 +682,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.CREATE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async createDataAsset(
    @User() user: RequestUser,
    @Body() body: ICreateDataAsset,
@@ -554,6 +709,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async commentOnDataAsset(
    @Param('id') id: string,
    @User() user: RequestUser,
@@ -580,6 +738,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.DELETE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async deleteDataAsset(@Param('id') id: string, @User() user: RequestUser) {
    const { customer_id, customer_name, user_id, username } = user;
    const metadata = PackTheMetadata({
@@ -601,6 +762,9 @@ export class CatalogController {
    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async deleteComment(
    @Param('id') id: string,
    @User() user: RequestUser,
@@ -754,6 +918,9 @@ export class CatalogController {

  @Get('nimbus-dashboards')
  @RequireAllPermissions(PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER)
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.CATALOG
+  )
  async getNimbusDashboards(
    @User() user: RequestUser,
    @Body() body: GetNimbusDashboardsRequest,
@@ -906,88 +1073,4 @@ export class CatalogController {
      this.logger.error(error.message);
    }
  }
-
-  @Post('/data-asset/:nimbus_id/docs/ai')
-  @ApiOperation({
-    summary: 'Save documentation for data asset',
-    description: 'Saves documentation content for a data asset',
-  })
-  @ApiParam({
-    name: 'nimbus_id',
-    description: 'Nimbus ID of the data asset',
-    type: 'string',
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'Documentation saved successfully',
-  })
-  async saveDocumentation(
-    @Param('nimbus_id') nimbusId: string,
-    @Body() body: { docs: string },
-    @User() user: RequestUser,
-  ) {
-
-    const metadata = PackTheMetadata(user);
-
-    try {
-      await this.catalogService.updateDataAssetDocumentation(nimbusId, body.docs, metadata);
-      return {
-        message: 'Documentation saved successfully',
-      };
-    } catch (error) {
-      this.logger.error(`Error saving documentation for ${nimbusId}: ${error.message}`);
-      throw error;
-    }
-  }
-
-  @Post('/data-asset/:nimbus_id/docs/generate-ai')
-  @ApiOperation({
-    summary: 'Generate AI documentation for data asset',
-    description: 'Generates comprehensive documentation for a data asset using AI (Autodrive)',
-  })
-  @ApiParam({
-    name: 'nimbus_id',
-    description: 'Nimbus ID of the data asset',
-    type: 'string',
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'AI documentation generated successfully',
-    schema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string' },
-        documentation: { type: 'string' },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Bad request - invalid nimbus_id or missing data',
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Data asset not found',
-  })
-  @ApiResponse({
-    status: 500,
-    description: 'Internal server error during AI generation',
-  })
-  async generateAiDocumentation(
-    @Param('nimbus_id') dataAssetId: string,
-    @User() user: RequestUser,
-  ) {
-    const metadata = PackTheMetadata(user);
-
-    try {
-      const result = await this.catalogService.generateAiDocumentation(dataAssetId, metadata, user);
-      return {
-        message: 'AI documentation generated successfully',
-        documentation: result,
-      };
-    } catch (error) {
-      this.logger.error(`Error generating AI documentation for ${dataAssetId}: ${error.message}`);
-      throw error;
-    }
-  }
-}
+}
@@ -5,20 +5,17 @@ import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { CatalogController } from './catalog.controller';
 import { CatalogClientConfiguration } from './catalog-client';
 import { ClientsModule } from '@nestjs/microservices';
-import { PipelinesModule as OldPipelineModule } from 'src/modules/pipelines/pipelines.module';
 import { UsersModule } from '../users/users.module';
 import { RolesModule } from '../roles/roles.module';
 import { CustomersModule } from '../customers/customers.module';
 import { ShareModule } from './share/share.module';
 import { CatalogService } from './catalog.service';
-import { MixpanelModule } from '../mixpanel/mixpanel.module';

 const client = new CatalogClientConfiguration();

@Module({
  imports: [
    ClientsModule.register([client.providerOptions]),
-    OldPipelineModule,
    UsersModule,
    RolesModule,
    CustomersModule,
@@ -1,42 +0,0 @@
-/**
- * Constantes relacionadas ao Autodrive
- * 
- */
-export const AUTODRIVE_CONSTANTS = {
-  // URLs e endpoints (apenas do ENV)
-  BASE_URL: process.env.BASE_URL_AUTODRIVE || process.env.AUTODRIVE_BASE_URL,
-  
-  // Credenciais (apenas do ENV, sem fallback para segurança)
-  USERNAME: process.env.AUTODRIVE_USERNAME,
-  PASSWORD: process.env.AUTODRIVE_PASSWORD,
-  
-  // Modelo padrão
-  DEFAULT_MODEL: process.env.AUTODRIVE_MODEL || "gpt-4o",
-  
-  // Timeouts (em milissegundos)
-  ASK_TIMEOUT: 120000,
-  ANSWER_TIMEOUT: 180000,
-  
-  // Headers
-  HEADERS: {
-    'Content-Type': 'application/json',
-  },
-} as const;
-
-/**
- * Chaves geográficas para detecção de dados de localização
- */
-export const GEOGRAPHIC_KEYS = [
-  'country', 'countries', 'city', 'cities', 
-  'region', 'regions', 'location', 'state', 
-  'states', 'address'
-] as const;
-
-/**
- * Países comuns para detecção automática
- */
-export const COMMON_COUNTRIES = [
-  'brazil', 'brasil', 'usa', 'united states', 
-  'canada', 'mexico', 'argentina', 'chile', 
-  'colombia'
-] as const;
@@ -1,4 +1,10 @@
 import { ApiProperty, ApiPropertyOptional, PickType } from '@nestjs/swagger';
+import {
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+} from 'class-validator';
 import { CreateDataAssetRequest } from '@dadosfera/protospack-v2/dist/lib/Catalog/interfaces/messages';

 export enum DataAssetShareType {
@@ -6,6 +12,12 @@ export enum DataAssetShareType {
  public = 'public',
  private = 'private',
 }
+export enum CertificationStatus {
+  draft = 'draft',
+  in_review = 'in_review',
+  approved = 'approved',
+  deprecated = 'deprecated',
+}
 export enum OrderEnum {
  asc = 'asc',
  desc = 'desc',
@@ -98,6 +110,8 @@ export class IDataAsset {
  embed?: EmbedObject;
  @ApiPropertyOptional({ enum: DataAssetShareType })
  share_type?: DataAssetShareType;
+  @ApiPropertyOptional()
+  docs?: string;
 }

 export class IOneDataAsset {
@@ -147,6 +161,24 @@ export class ICatalogAllRequest {
    description: 'Tipo de ordenação - `asc`: crescente; `desc`: decrescente ',
  })
  order?: OrderEnum;
+
+  @ApiPropertyOptional({
+    description: 'ID do usuário owner para filtrar data assets',
+    example: 'user-id-1,user-id-2',
+  })
+  owner?: string;
+
+  @ApiPropertyOptional({
+    description: 'Data inicial para filtro de catálogo (formato: YYYY-MM-DD)',
+    example: '2025-01-01',
+  })
+  catalog_date_from?: string;
+
+  @ApiPropertyOptional({
+    description: 'Data final para filtro de catálogo (formato: YYYY-MM-DD)',
+    example: '2025-12-31',
+  })
+  catalog_date_to?: string;
 }

 export class ICatalogAllResponse {
@@ -171,6 +203,27 @@ export class IData {
  day_opening: number;
 }

+
+export enum CustomPropertyType {
+  TEXT = 'text',
+  NUMBER = 'number',
+  DATE = 'date',
+  BOOLEAN = 'boolean',
+}
+
+export class CustomPropertyDto {
+  @ApiProperty()
+  key: string;
+  @ApiProperty()
+  value: string;
+  @ApiProperty({ enum: CustomPropertyType })
+  type: CustomPropertyType;
+  @ApiPropertyOptional()
+  color?: string;
+  @ApiPropertyOptional()
+  emoji?: string;
+}
+
 export class IUpdateDataRequest {
  @ApiProperty()
  name: string;
@@ -182,7 +235,18 @@ export class IUpdateDataRequest {
  embed: EmbedObject;
  @ApiPropertyOptional({ enum: DataAssetShareType })
  share_type?: DataAssetShareType;
+  @ApiPropertyOptional()
+  docs?: string;
+  @ApiPropertyOptional({ type: [CustomPropertyDto] })
+  custom_properties?: CustomPropertyDto[];
 }
+
+export class IUpdateCertificationStatusRequest {
+  @ApiProperty({ enum: CertificationStatus })
+  @IsEnum(CertificationStatus)
+  certification_status: CertificationStatus;
+}
+
 export class ICreateDataAsset implements CreateDataAssetRequest {
  @ApiProperty()
  display_name: string;
@@ -196,6 +260,8 @@ export class ICreateDataAsset implements CreateDataAssetRequest {
  location: string;
  @ApiPropertyOptional()
  embed: EmbedObject;
+  @ApiPropertyOptional()
+  docs: string;
 }

 export class IPreview {
@@ -328,3 +394,10 @@ export type AssetReporter = {
  created_at: string;
  tags: string;
 }
+
+export type CreateDataDocsDTO = {
+  table_id: string;
+  docs: string;
+  asset_type: string;
+
+}
@@ -1,88 +0,0 @@
-/**
-
- */
-export const AI_DOCUMENTATION_PROMPT = `crie uma documentação em Portugues, Ingles e Espanhol seguindo essas instruções 
-1. Persona: como profissional de governança e engenharia de dados
-2. Tarefa: ao receber as informações da tabela criar uma documentação com o seguinte escopo 
-**A primeira linha do documento tem que conter a seguinte informação: ## Document languages: EN / BR / ES
-**A segunda linha tem que obrigatoriamente conter a escrita Table: nome da tabela
-**A terceira linha tem que obrigatoriamente conter a escrita Table Schema: nome do table schema
-**DIRETRIZ CRUCIAL DE CONSISTÊNCIA E COMPLETUDE DE SCHEMA:**
-**1. Fonte Exclusiva de Metadados:** O 'Table Schema' definido na linha acima é a ÚNICA fonte de verdade para o schema dos dados a serem documentados. TODAS as informações subsequentes, especialmente na seção 'Estrutura da Tabela' (incluindo a lista de colunas, seus nomes, tipos de dados, descrições e exemplos) DEVEM ser extraídas EXCLUSIVAMENTE de metadados que correspondem a ESTE 'Table Schema'. Se os dados de entrada que você recebeu contiverem informações para a mesma tabela ou colunas mas de schemas diferentes (ex: um schema 'bronze' e um 'silver'), você DEVE IGNORAR TOTALMENTE as informações dos schemas divergentes para esta tarefa de documentação e utilizar APENAS as do 'Table Schema' aqui especificado.
-**2. Listagem Completa de Colunas:** Sua principal tarefa na seção 'Estrutura da Tabela' é identificar e listar TODAS as colunas que pertencem ao 'Table Schema' especificado. Verifique nos dados de entrada fornecidos se há uma indicação explícita do número total de colunas para esta tabela neste schema (por exemplo, um campo como 'Num_columns' ou similar nos metadados da tabela). Você deve se esforçar para listar exatamente essa quantidade de colunas. Se essa contagem não estiver disponível, liste todas as colunas que você puder identificar como pertencentes exclusivamente a este 'Table Schema'. A completude em relação ao schema especificado é essencial.
-
-**Depois de "Estrutura da tablea", incluir a mensagem "Este documento foi gerado por IA", traduzida corretamente para cada idioma.**
-**Obrigatoriamente:Após finalizar a versão em Inglês, começar a versão em Português** **Após finalizar a versão em Português, começar a versão em Espanhol** **Antes de começar cada versão, colocar um título como:** - \`## English Version\` (para inglês)  
-  - \`## Versão em Português\` (para português)  
-  - \`## Versión en Español\` (para espanhol)  
- - Descrição: fornece uma visão geral do ativo de dados, 
- destacando seu propósito e principal funcionalidade. 
- Esta sessão resume o conteúdo e o objetivo do ativo, ajudando os usuários a entender rapidamente o que o ativo representa 
- e como pode ser utilizado em suas análises e decisões.
- - Sugestão de Domínio de Dados:
- Analise cuidadosamente os dados da tabela e sugira o domínio mais apropriado. Inclua:
- - Domínio Sugerido: [Nome do domínio]
- - Motivo: [Explicação breve sobre porque a tabela pertence a este domínio]
- - Observações: [Qualquer observação adicional relevante]
- 
- Exemplos de Domínios de Dados para referência:
- - Financeiro: Dados sobre transações, receitas, despesas, etc.
- - Recursos Humanos: Dados sobre funcionários, cargos, salários, etc.
- - Produtos: Dados sobre produtos, categorias, preços, etc.
- - Fornecedores: Dados sobre fornecedores, produtos fornecidos, localizações, etc.
- - Marketing: Dados sobre campanhas, leads, conversões, etc.
- - Vendas: Dados sobre vendas, clientes, produtos vendidos, etc.
- - Operações: Dados sobre processos, logística, produção, etc.
- - Clientes: Dados sobre clientes, interações, histórico, etc.
-   -Tags Sugeridas:
-          A IA deve gerar tags relevantes **com base nos dados da tabela**.  
-        - **IMPORTANTE: Analise cuidadosamente os dados de preview da tabela (PREVIEW DATA) para encontrar países. Procure em todas as colunas por nomes de países, cidades ou regiões.**
-        - **Garanta que as tags estejam separadas por espaços vazios, todas na mesma linha, exemplo: #marketing #sales #australia #canada, limitar até 3 países que mais aparecem** - **Os países DEVEM ser extraídos dos dados de preview da tabela. Procure em colunas como City, Country, Region, Location, etc.** - Por que esta tabela é interessante:
- Nesta sessão, é destacada a importância do ativo, explicando como ele pode ser útil para os usuários. 
- São abordadas as formas como o ativo pode melhorar a tomada de decisões, identificar padrões relevantes ou fornecer insights valiosos. 
- O objetivo é ressaltar a utilidade prática e o impacto positivo que o ativo pode ter em suas atividades.
- - Análises potencialmente úteis feitas com esses dados:
- Aqui são listadas algumas das análises que podem ser realizadas com o ativo de dados. Inclui sugestões de dashboards, 
- relatórios ou outros tipos de análises que aproveitam as informações fornecidas pelo ativo. 
- O objetivo é oferecer maneiras de utilizar os dados para obter insights valiosos e apoiar a tomada de decisões informadas.
- - Links Úteis:
- Os Links Úteis oferecem recursos adicionais relacionados ao ativo de dados, incluindo guias, 
- artigos ou outras fontes de informação que podem ajudar os usuários a compreender melhor o ativo e suas aplicações. Além disso, 
- inclui um link rápido dentro da Dadosfera para ativos relacionados diretamente com o ativo em questão, facilitando a navegação entre os ativos.
- - Estrutura da Tabela:
- A Estrutura da Tabela detalha TODAS as colunas e os dados disponíveis no ativo, conforme pertencentes ao 'Table Schema' principal definido no início deste documento.
- **Instrução Detalhada para Estrutura da Tabela:**
- Siga rigorosamente estes passos:
- 1. Identifique nos dados de entrada (metadados da tabela e das colunas) todas as colunas que pertencem EXCLUSIVAMENTE ao 'Table Schema' especificado no cabeçalho deste documento. Se houver uma contagem de colunas (ex: 'Num_columns') para este schema específico, assegure-se de listar essa quantidade.
- 2. Para CADA uma dessas colunas identificadas, formate a saída da seguinte maneira, **SEM utilizar NENHUM marcador de lista (como traços ou asteriscos) no início de cada entrada de coluna**. Cada coluna deve ser apresentada como um bloco de texto. Inclua uma linha em branco entre a documentação de cada coluna para separação visual.
-   - Apresente o NOME_DA_COLUNA em maiúsculas, seguido pelo (TIPO_DE_DADO_EXTRAÍDO_DOS_METADADOS_DO_SCHEMA_CORRETO) entre parênteses.
-   - O **NOME_DA_COLUNA (TIPO_DE_DADO_EXTRAÍDO_DOS_METADADOS_DO_SCHEMA_CORRETO)** deve estar na primeira linha do bloco da coluna e **inteiramente em negrito**.
-   - Na linha seguinte, a etiqueta "**Descrição:**" deve estar **em negrito**, seguida pelo texto da descrição da coluna.
-   - Na linha seguinte à descrição, a etiqueta "**Exemplo:**" deve estar **em negrito**, seguida pelo valor do exemplo. Se o exemplo for um valor literal ou código, formate-o entre crases (\`) se apropriado.
-   - Se houver informações adicionais relevantes (como "Valores Possíveis:", "Observações:", etc.), coloque a etiqueta correspondente **em negrito** em uma nova linha, seguida pelo seu texto.
-   
- Este documento foi gerado por IA.
-
- NOME_COLUNA_1 (TIPO_DADO_SCHEMA_CORRETO_1):
-   Descrição: [Descrição da coluna 1, do schema correto]
-   Exemplo: \`[Exemplo de valor para coluna 1, do schema correto]\`
-
- NOME_COLUNA_2 (TIPO_DADO_SCHEMA_CORRETO_2):
-   Descrição: [Descrição da coluna 2, do schema correto]
-   Exemplo: \`[Exemplo de valor para coluna 2, do schema correto]\`
-
- (continue este formato com início de cada coluna para TODAS as colunas do 'Table Schema' especificado, garanta com que NUNCA tenha TRAÇO OU PONTO no inicio)
-
- 3. Contexto : O usuário ira cadastrar um ativo de dados na nossa plataforma e para ter um bom catalogo ele ira querer gerar a documentação padronizada mas explicativa e
- automática 
- 4. Restrições : A documentação deve seguir obrigatoriamente o mesmo padrão principalmente na parte de estrutura de dados
- 5. Objetivo: O principal objetivo é gerar uma documentação acessível, clara, 
- automática e padronizada para os usuários que desejem cadastrar um ativo de dados na plataforma`;
-
-/**
- * Configurações para a geração de documentação com IA
- */
-export const AI_DOCUMENTATION_CONFIG = {
-  FETCH_K: 250,
-  K: 100,
-} as const;
@@ -160,7 +160,7 @@ export class ShareService implements OnModuleInit {
    });

    const { documentation } = await lastValueFrom(
-      this.catalogReadService.GetDatasetDoc({ id, type: undefined }, metadata),
+      this.catalogReadService.GetDatasetDoc({ id }, metadata),
    );
    console.log(documentation);
    const docs = JSON.parse(documentation);
@@ -180,7 +180,7 @@ export class ShareService implements OnModuleInit {
    return data_assets.map((data_asset) => {
      const owner = customer_users.find(
        (u) => u.id === data_asset.owner,
-      )?.username;
+      )?.email;

      const roles = [];
      const users = [];
@@ -190,7 +190,7 @@ export class ShareService implements OnModuleInit {
      }
      for (const user_id of data_asset.users) {
        const user = customer_users.find((r) => r.id === user_id);
-        if (user) users.push({ id: user.id, username: user.username });
+        if (user) users.push({ id: user.id, email: user.email });
      }
      return {
        ...data_asset,
@@ -262,6 +262,7 @@ export class ShareService implements OnModuleInit {
        user_id: accessTokenPayload.user_id,
        username: accessTokenPayload.username,
        permissions: accessTokenPayload.permissions,
+        roles: accessTokenPayload.roles,
        customer_id: accessTokenPayload.customer_id,
        customer_name: accessTokenPayload.customer_name,
        customer_tier: accessTokenPayload.customer_tier,
@@ -1,60 +0,0 @@
-/**
- * Tipos relacionados à geração de documentação com IA
- */
-
-export interface AutodriveCredentials {
-  username: string;
-  password: string;
-  baseUrl: string;
-  model: string;
-  authHeader?: string;
-}
-
-export interface AutodriveAskPayload {
-  question: string;
-  fetch_k: number;
-  k: number;
-  model: string;
-}
-
-export interface AutodriveAskResponse {
-  answer?: string;
-  question_id?: string;
-  dataset_id?: string;
-}
-
-export interface AutodriveAnswerResponse {
-  status: 'started' | 'success' | 'failed';
-  answer?: string;
-  status_reason?: string;
-}
-
-export interface AutodriveUploadResponse {
-  dataset_id: string;
-}
-
-export interface DatasetStatusResponse {
-  status: 'processing' | 'success' | 'failed';
-  status_reason?: string;
-}
-
-export interface ColumnData {
-  name: string;
-  type: string;
-  description?: string;
-  nullable?: string;
-}
-
-export interface ColumnsMetadata {
-  columns: ColumnData[];
-}
-
-export interface DataPreview {
-  preview: any[];
-}
-
-export interface FormattedDataForAI {
-  dataAsset: any;
-  dataPreview: any[];
-  columnsData?: ColumnsMetadata;
-}
@@ -22,17 +22,24 @@ import {
  ConnectionTestListTablesRes,
  GetTableMetadataRes,
  GetTableMetadataReq,
+  RefreshCatalogReq,
+  RefreshCatalogRes,
+  RefreshCatalogStatusReq,
 } from './dto/connection-test';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-import { Authenticated } from 'src/decorators/authentication.decorator';
+import { Authenticated, RequireModule } from 'src/decorators/authentication.decorator';
 import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
 import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
+import { DADOSFERA_MODULES_KEYS } from 'src/authentication/permissions.enum';

@ApiInternalOnlyController()
@ApiTags('Connection Test')
@Controller('connection-test')
@UseFilters(new GrpcToHttpExceptionFilter())
@Authenticated()
+@RequireModule(
+  DADOSFERA_MODULES_KEYS.COLLECT
+)
 export class ConnectionTestController {
  logger: any;
  constructor(
@@ -84,7 +91,7 @@ export class ConnectionTestController {
    });
    return this.connectionTestService.connectionTestListSchemas(
      body,
-      user.customer_name,
+      user,
    );
  }

@@ -101,7 +108,7 @@ export class ConnectionTestController {
    });
    return this.connectionTestService.connectionTestListTables(
      body,
-      user.customer_name,
+      user,
    );
  }

@@ -118,7 +125,38 @@ export class ConnectionTestController {
    });
    return this.connectionTestService.getTableMetadata(
      body,
-      user.customer_name,
+      user,
    );
  }
+
+  @Post('refresh-catalog')
+  @ApiOkResponse({ type: RefreshCatalogRes })
+  @HttpCode(HttpStatus.ACCEPTED)
+  async refreshCatalog(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: RefreshCatalogReq,
+  ) {
+    this.logger.info('/connection-test/refresh-catalog', {
+      user: user.user_id,
+      customer: user.customer_name,
+      connection: body.connection_id,
+    });
+    return this.connectionTestService.refreshCatalog(body, user);
+  }
+
+  @Post('refresh-catalog/status')
+  @ApiOkResponse({ type: RefreshCatalogRes })
+  @HttpCode(HttpStatus.OK)
+  async refreshCatalogStatus(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: RefreshCatalogStatusReq,
+  ) {
+    this.logger.info('/connection-test/refresh-catalog/status', {
+      user: user.user_id,
+      customer: user.customer_name,
+      connection: body.connection_id,
+      session: body.session_id,
+    });
+    return this.connectionTestService.refreshCatalogStatus(body, user);
+  }
 }
@@ -5,10 +5,17 @@ import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { ClientsModule } from '@nestjs/microservices';
 import { ConnectionTestClientConfiguration } from './connection-test-client.config';
 import { ConnectionModule } from '../connection/connection.module';
+import { ConnectionsApiModule } from '../connections-api/connections-api.module';
+import { PlatformApiModule } from '../platform-api/platform-api.module';
 const client = new ConnectionTestClientConfiguration();
@Module({
  controllers: [ConnectionTestController],
  providers: [ConnectionTestService, DadosferaLogger],
-  imports: [ClientsModule.register([client.providerOptions]), ConnectionModule],
+  imports: [
+    ClientsModule.register([client.providerOptions]),
+    ConnectionModule,
+    ConnectionsApiModule,
+    PlatformApiModule,
+  ],
 })
 export class ConnectionTestModule {}
@@ -0,0 +1,205 @@
+import { ConnectionTestService } from './connection-test.service';
+import { RequestUser } from 'src/decorators/user.decorator';
+
+describe('ConnectionTestService catalog cache', () => {
+  const user: RequestUser = {
+    user_id: 'user-id',
+    username: 'user@example.com',
+    permissions: [],
+    customer_id: 'customer-id',
+    customer_name: 'customer-name',
+    customer_tier: 'standard',
+    access_token: 'token',
+    customer_modules: [],
+    roles: [],
+  };
+  const grpcClient = { getService: jest.fn().mockReturnValue({}) };
+  const connectionsService = {};
+  const connectionsApiService = { proxy: jest.fn() };
+  const platformApiService = { proxy: jest.fn() };
+  let service: ConnectionTestService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new ConnectionTestService(
+      grpcClient as any,
+      connectionsService as any,
+      connectionsApiService as any,
+      platformApiService as any,
+    );
+  });
+
+  it('keeps the existing schemas response contract', async () => {
+    connectionsApiService.proxy.mockResolvedValue({
+      schemas: [{ schema_name: 'analytics' }, { schema_name: 'public' }],
+    });
+
+    await expect(
+      service.connectionTestListSchemas(
+        { connection_id: 'config-id', plugin: 'postgresql' },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      schema_list: ['analytics', 'public'],
+    });
+  });
+
+  it('keeps the existing tables response contract', async () => {
+    connectionsApiService.proxy.mockResolvedValue({
+      tables: [{ table_name: 'customers' }, { table_name: 'orders' }],
+    });
+
+    await expect(
+      service.connectionTestListTables(
+        {
+          connection_id: 'config-id',
+          plugin: 'postgresql',
+          schema: 'public',
+        },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      table_list: ['customers', 'orders'],
+    });
+  });
+
+  it('maps cached columns to the existing table metadata contract', async () => {
+    connectionsApiService.proxy.mockResolvedValue({
+      columns: [
+        {
+          column_name: 'id',
+          data_type: 'bigint',
+          is_primary_key: true,
+        },
+      ],
+    });
+
+    await expect(
+      service.getTableMetadata(
+        {
+          connection_id: 'config-id',
+          plugin: 'postgresql',
+          schema: 'public',
+          table_list: ['customers'],
+        },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      tables_metadata: [
+        {
+          table_name: 'customers',
+          columns: [
+            {
+              name: 'id',
+              type: 'bigint',
+              is_primary_key: true,
+            },
+          ],
+          references: [],
+        },
+      ],
+    });
+    expect(connectionsApiService.proxy).toHaveBeenCalledWith(
+      'GET',
+      '/connection_catalog/config-id/schemas/public/tables/customers/columns',
+      user,
+    );
+  });
+
+  it('submits a catalog refresh without holding the request open', async () => {
+    platformApiService.proxy.mockResolvedValue({
+      session_id: 'session-id',
+      date: '20260731',
+    });
+
+    await expect(
+      service.refreshCatalog(
+        { connection_id: 'config-id', plugin: 'postgresql' },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      status: 'PENDING',
+      session_id: 'session-id',
+      date: '20260731',
+    });
+
+    expect(platformApiService.proxy).toHaveBeenCalledWith(
+      'POST',
+      '/connection_test',
+      user,
+      {
+        customer_id: user.customer_name,
+        plugin: 'postgresql',
+        task: {
+          task_type: 'refresh_catalog',
+          connection: {
+            provider: 'connection_manager',
+            config_id: 'config-id',
+          },
+        },
+      },
+    );
+  });
+
+  it('keeps polling without changing the catalog pointer while pending', async () => {
+    platformApiService.proxy.mockResolvedValue({ status: 'PENDING' });
+
+    await expect(
+      service.refreshCatalogStatus(
+        {
+          connection_id: 'config-id',
+          plugin: 'postgresql',
+          session_id: 'session-id',
+          date: '20260731',
+        },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: false,
+      status: 'PENDING',
+      session_id: 'session-id',
+      date: '20260731',
+    });
+
+    expect(connectionsApiService.proxy).not.toHaveBeenCalled();
+  });
+
+  it('publishes the catalog pointer after the refresh finishes', async () => {
+    platformApiService.proxy.mockResolvedValue({ status: 'DONE' });
+    connectionsApiService.proxy.mockResolvedValue({
+      last_catalog_refresh_status: 'SUCCESS',
+    });
+
+    await expect(
+      service.refreshCatalogStatus(
+        {
+          connection_id: 'config/id',
+          plugin: 'postgresql',
+          session_id: 'session-id',
+          date: '20260731',
+        },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      status: 'DONE',
+      session_id: 'session-id',
+      date: '20260731',
+    });
+
+    expect(connectionsApiService.proxy).toHaveBeenCalledWith(
+      'PUT',
+      '/connection_config/config%2Fid/catalog_metadata',
+      user,
+      {
+        last_catalog_refresh_status: 'SUCCESS',
+        last_catalog_connection_test_date: '20260731',
+        last_catalog_connection_test_session_id: 'session-id',
+      },
+    );
+  });
+});
@@ -1,4 +1,4 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { HttpException, HttpStatus, Inject, Injectable } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 import { ConnectionTest } from '@dadosfera/protospack-v2';
 import { lastValueFrom } from 'rxjs';
@@ -13,6 +13,9 @@ import {
  ConnectionTestPingRes,
  GetTableMetadataReq,
  GetTableMetadataRes,
+  RefreshCatalogReq,
+  RefreshCatalogRes,
+  RefreshCatalogStatusReq,
 } from './dto/connection-test';
 import { ConnectionClientService } from '../connection/client.service';
 import {
@@ -21,6 +24,8 @@ import {
 } from '../connection/dtos/connection';
 import { RequestUser } from 'src/decorators/user.decorator';
 import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { ConnectionsApiService } from '../connections-api/connections-api.service';
+import { PlatformApiService } from '../platform-api/platform-api.service';

@Injectable()
 export class ConnectionTestService {
@@ -28,6 +33,8 @@ export class ConnectionTestService {
  constructor(
    @Inject('ConnectionTestGrpcClient') private readonly grpcClient: ClientGrpc,
    private connectionsService: ConnectionClientService,
+    private connectionsApiService: ConnectionsApiService,
+    private platformApiService: PlatformApiService,
  ) {
    this.connectionTestReadClient =
      grpcClient.getService<ConnectionTest.ReadService.ConnectionTestReadServices>(
@@ -147,45 +154,137 @@ export class ConnectionTestService {
  }
  async connectionTestListSchemas(
    body: ConnectionTestListSchemasReq,
-    customer_name: string,
+    user: RequestUser,
  ): Promise<ConnectionTestListSchemasRes> {
-    const { connection_id, plugin } = body;
-    return lastValueFrom(
-      this.connectionTestReadClient.ListSchemas({
-        connection_id,
-        customer_name,
-        plugin,
-      }),
+    const result = await this.connectionsApiService.proxy(
+      'GET',
+      `/connection_catalog/${encodeURIComponent(body.connection_id)}/schemas`,
+      user,
    );
+    return {
+      operation_result: true,
+      schema_list: result.schemas.map((schema) => schema.schema_name),
+    };
  }
+
  async connectionTestListTables(
    body: ConnectionTestListTablesReq,
-    customer_name: string,
+    user: RequestUser,
  ): Promise<ConnectionTestListTablesRes> {
-    const { connection_id, plugin, schema } = body;
-    return lastValueFrom(
-      this.connectionTestReadClient.ListTables({
-        connection_id,
-        customer_name,
-        plugin,
-        schema,
-      }),
+    const result = await this.connectionsApiService.proxy(
+      'GET',
+      `/connection_catalog/${encodeURIComponent(body.connection_id)}` +
+        `/schemas/${encodeURIComponent(body.schema)}/tables`,
+      user,
    );
+    return {
+      operation_result: true,
+      table_list: result.tables.map((table) => table.table_name),
+    };
  }

  async getTableMetadata(
    body: GetTableMetadataReq,
-    customer_name: string,
+    user: RequestUser,
  ): Promise<GetTableMetadataRes> {
-    const { schema, plugin, table_list, connection_id } = body;
-    return lastValueFrom(
-      this.connectionTestReadClient.GetTableMetadata({
-        connection_id,
-        customer_name,
-        plugin,
-        schema,
-        table_list,
+    const tables_metadata = await Promise.all(
+      body.table_list.map(async (table_name) => {
+        const result = await this.connectionsApiService.proxy(
+          'GET',
+          `/connection_catalog/${encodeURIComponent(body.connection_id)}` +
+            `/schemas/${encodeURIComponent(body.schema)}` +
+            `/tables/${encodeURIComponent(table_name)}/columns`,
+          user,
+        );
+        return {
+          table_name,
+          columns: result.columns.map((column) => ({
+            name: column.column_name,
+            type: column.data_type,
+            is_primary_key: column.is_primary_key,
+          })),
+          references: [],
+        };
      }),
    );
+    return { operation_result: true, tables_metadata };
+  }
+
+  async refreshCatalog(
+    body: RefreshCatalogReq,
+    user: RequestUser,
+  ): Promise<RefreshCatalogRes> {
+    const task = await this.platformApiService.proxy(
+      'POST',
+      '/connection_test',
+      user,
+      {
+        customer_id: user.customer_name,
+        plugin: body.plugin,
+        task: {
+          task_type: 'refresh_catalog',
+          connection: {
+            provider: 'connection_manager',
+            config_id: body.connection_id,
+          },
+        },
+      },
+    );
+
+    if (!task.session_id || !task.date) {
+      throw new HttpException(
+        'Platform API did not return a catalog refresh task identifier',
+        HttpStatus.BAD_GATEWAY,
+      );
+    }
+
+    return {
+      operation_result: true,
+      status: 'PENDING',
+      session_id: task.session_id,
+      date: task.date,
+    };
+  }
+
+  async refreshCatalogStatus(
+    body: RefreshCatalogStatusReq,
+    user: RequestUser,
+  ): Promise<RefreshCatalogRes> {
+    const result = await this.platformApiService.proxy(
+      'POST',
+      '/connection_test/status',
+      user,
+      {
+        session_id: body.session_id,
+        date: body.date,
+      },
+    );
+
+    if (result.status === 'DONE') {
+      await this.connectionsApiService.proxy(
+        'PUT',
+        `/connection_config/${encodeURIComponent(
+          body.connection_id,
+        )}/catalog_metadata`,
+        user,
+        {
+          last_catalog_refresh_status: 'SUCCESS',
+          last_catalog_connection_test_date: body.date,
+          last_catalog_connection_test_session_id: body.session_id,
+        },
+      );
+    } else if (result.status === 'ERROR' || result.status === 'EXPIRED') {
+      throw new HttpException(
+        `Catalog refresh finished with status ${result.status}`,
+        HttpStatus.BAD_GATEWAY,
+      );
+    }
+
+    return {
+      operation_result: result.status === 'DONE',
+      status: result.status,
+      session_id: body.session_id,
+      date: body.date,
+    };
  }
 }
@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
-import { IsString, IsOptional } from 'class-validator';
+import { IsIn, IsString, IsOptional } from 'class-validator';
 import { DatabaseConnectionPropertiesDto } from 'src/modules/connection/dtos/connection';
 import { CreateConnectionDto } from 'src/modules/connection/dtos/connection';
 export class ColumnDto {
@@ -7,6 +7,8 @@ export class ColumnDto {
  name: string;
  @ApiProperty()
  type: string;
+  @ApiProperty()
+  is_primary_key: boolean;
 }
 export class TableMetadataDto {
  @ApiProperty()
@@ -131,3 +133,37 @@ export class GetTableMetadataRes {
  @ApiProperty({ type: [TableMetadataDto] })
  tables_metadata: TableMetadataDto[];
 }
+
+export class RefreshCatalogReq {
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+
+  @ApiProperty({ enum: ['oracle', 'mysql', 'postgresql', 'sqlserver'] })
+  @IsIn(['oracle', 'mysql', 'postgresql', 'sqlserver'])
+  plugin: string;
+}
+
+export class RefreshCatalogStatusReq extends RefreshCatalogReq {
+  @ApiProperty()
+  @IsString()
+  session_id: string;
+
+  @ApiProperty()
+  @IsString()
+  date: string;
+}
+
+export class RefreshCatalogRes {
+  @ApiProperty()
+  operation_result: boolean;
+
+  @ApiProperty()
+  status: string;
+
+  @ApiProperty()
+  session_id: string;
+
+  @ApiProperty()
+  date: string;
+}
@@ -16,8 +16,9 @@ import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import {
  Authenticated,
  RequireAllPermissions,
+  RequireModule,
 } from 'src/decorators/authentication.decorator';
-import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import { DADOSFERA_MODULES_KEYS, PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
 import { RequestUser, User } from 'src/decorators/user.decorator';
 import { ValidationPipe } from '../../pipes/object-validation.pipe';
 import {
@@ -39,6 +40,9 @@ const connectionPermissions = PERMISSIONS_GROUPS.CONNECTION.permissions;
@ApiTags('connections')
@Authenticated()
@Controller('connections')
+@RequireModule(
+  DADOSFERA_MODULES_KEYS.COLLECT
+)
 export class ConnectionController {
  logger: any;
  constructor(
@@ -0,0 +1,11 @@
+export const CONNECTIONS_API_CONFIG = {
+  getUrl: (): string => {
+    const url = process.env.CONNECTIONS_API_URL;
+    if (!url) {
+      throw new Error('CONNECTIONS_API_URL environment variable is not set');
+    }
+    return url;
+  },
+  region: process.env.AWS_REGION || 'us-east-1',
+  timeout: parseInt(process.env.CONNECTIONS_API_TIMEOUT || '30000', 10),
+};
@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { ConnectionsApiService } from './connections-api.service';
+
+@Module({
+  providers: [ConnectionsApiService, DadosferaLogger],
+  exports: [ConnectionsApiService],
+})
+export class ConnectionsApiModule {}
@@ -0,0 +1,99 @@
+import { Injectable, Inject, HttpException } from '@nestjs/common';
+import { SignatureV4 } from '@aws-sdk/signature-v4';
+import { Sha256 } from '@aws-crypto/sha256-js';
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import axios, { AxiosResponse, Method } from 'axios';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { RequestUser } from '../../decorators/user.decorator';
+import { CONNECTIONS_API_CONFIG } from './connections-api.config';
+
+@Injectable()
+export class ConnectionsApiService {
+  private signer: SignatureV4;
+  private logger: any;
+
+  constructor(@Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger) {
+    this.logger = dadosferaLogger.logger;
+    this.signer = new SignatureV4({
+      service: 'execute-api',
+      region: CONNECTIONS_API_CONFIG.region,
+      credentials: defaultProvider(),
+      sha256: Sha256,
+    });
+  }
+
+  async proxy(
+    method: string,
+    path: string,
+    user: RequestUser,
+    body?: any,
+    query?: Record<string, string>,
+  ): Promise<any> {
+    const baseUrl = CONNECTIONS_API_CONFIG.getUrl();
+    const url = new URL(`${baseUrl}${path}`);
+
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const headers: Record<string, string> = {
+      host: url.hostname,
+      'content-type': 'application/json',
+      customer_name: user.customer_name || '',
+      customer_id: user.customer_id || '',
+      'x-user-id': user.user_id || '',
+      'x-username': user.username || '',
+      'x-customer-tier': user.customer_tier || '',
+      'x-customer-id': user.customer_id || '',
+    };
+    const requestToSign = {
+      method: method.toUpperCase(),
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port ? parseInt(url.port, 10) : undefined,
+      path: url.pathname + url.search,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    };
+
+    try {
+      const signedRequest = await this.signer.sign(requestToSign);
+      const response: AxiosResponse = await axios({
+        method: method as Method,
+        url: url.href,
+        headers: signedRequest.headers as Record<string, string>,
+        data: body,
+        timeout: CONNECTIONS_API_CONFIG.timeout,
+        validateStatus: () => true,
+      });
+
+      if (response.status >= 400) {
+        throw new HttpException(response.data, response.status);
+      }
+      return response.data;
+    } catch (error) {
+      this.logger.error('Connections API proxy error', {
+        error: error.message,
+        path,
+        method: method.toUpperCase(),
+      });
+      if (error instanceof HttpException) {
+        throw error;
+      }
+      if (error.response) {
+        throw new HttpException(error.response.data, error.response.status);
+      }
+      if (error.code === 'ECONNREFUSED') {
+        throw new HttpException('Connections API service unavailable', 503);
+      }
+      if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+        throw new HttpException('Connections API request timeout', 504);
+      }
+      throw new HttpException('Internal server error', 500);
+    }
+  }
+}
@@ -25,9 +25,10 @@ import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import {
  Authenticated,
  RequireAllPermissions,
+  RequireModule,
  RequireSomePermission,
 } from 'src/decorators/authentication.decorator';
-import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import { DADOSFERA_MODULES_KEYS, PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
 import { Language } from 'src/decorators/language.decorator';
 import { LanguageEnum } from 'src/utils/languages.enum';
 import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
@@ -99,6 +100,9 @@ export class ConnectorController {
    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async getAllConnectors(
    @Language() language: LanguageEnum,
    @Query() queries: GetAllDto,
@@ -131,6 +135,9 @@ export class ConnectorController {
    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async getConnectorsTags() {
    return await this.connectorClientService.getConnectorsTags();
  }
@@ -143,6 +150,9 @@ export class ConnectorController {
    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async getConnector(
    @Language() language: LanguageEnum,
    @Param('plugin') plugin: string,
@@ -171,6 +181,9 @@ export class ConnectorController {
    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
  )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async getConnectorDetails(
    @Language() language: LanguageEnum,
    @Param('plugin') plugin: string,
@@ -193,6 +206,9 @@ export class ConnectorController {
  @Put('/:plugin')
  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
  @ApiConsumes('multipart/form-data')
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async updateConnector(
    @Param('plugin') plugin: string,
    @Body() body: UpdateDto,
@@ -214,6 +230,9 @@ export class ConnectorController {

  @Put('/:plugin/add-tag')
  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async addTagOnConnector(
    @Param('plugin') plugin: string,
    @Body() body: AddTagDto,
@@ -241,6 +260,9 @@ export class ConnectorController {

  @Put('/:plugin/remove-tag')
  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async removeTagOnConnector(
    @Param('plugin') plugin: string,
    @Body() body: RemoveTagDto,
@@ -269,6 +291,9 @@ export class ConnectorController {

  @Delete('/:plugin')
  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.DELETE)
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
  async deleteConnector(
    @Param('plugin') plugin: string,
    @Query('version') version: string,
@@ -136,4 +136,32 @@ export class CustomersController {
    const result = await this.customersService.getAccessDashboardUrl(user.customer_name, metadata);
    return result;
  }
+
+  @Get(':id/organization-info')
+  @Authenticated()
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @ApiOkResponse({ description: 'Organization information' })
+  async getOrganizationInfo(@Param('id') id: string) {
+    this.logger.info('getOrganizationInfo', { id });
+    return this.customersService.getOrganizationInfo(id);
+  }
+
+  @Put(':id/organization-info')
+  @Authenticated()
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @HttpCode(HttpStatus.OK)
+  @ApiOkResponse({ description: 'Organization information updated' })
+  async updateOrganizationInfo(
+    @Param('id') id: string,
+    @Body() body: {
+      companyName: string;
+      companySite: string;
+      domain: string;
+      cnpj: string;
+      description: string;
+    },
+  ) {
+    return this.customersService.updateOrganizationInfo(id, body);
+  }
+
 }
@@ -9,12 +9,12 @@ import {
 } from '@nestjs/common';

 import { firstValueFrom, lastValueFrom } from 'rxjs';
-import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
 import { DucClient } from '../duc/client.config';
 import { ClientGrpc } from '@nestjs/microservices';
 import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
-import { CustomerUpdateRequest } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
+import { CustomerSetLinksRequest } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
 import { CustomersProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
+import { CustomerLinksConfig } from './dtos/customers';
 import ErrorCodes from 'src/utils/errorCodes';
 import jwt from 'jsonwebtoken';
 import {
@@ -67,12 +67,12 @@ export class CustomersService implements OnModuleInit {
    )
  }

-  async getLinks(customerId: string) {
+  async getLinks(customerId: string): Promise<CustomerLinksConfig | null> {
    try {
      const result = await lastValueFrom(
-        this.customerService.CustomerFindOneById({ id: customerId }),
+        this.customerService.CustomerGetLinks({ customerId }),
      );
-      return result.customer?.links || [];
+      return (result.links as CustomerLinksConfig) || null;
    } catch (err) {
      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
@@ -80,17 +80,17 @@ export class CustomersService implements OnModuleInit {
    }
  }

-  async setLinks(customerId: string, links: Link[]) {
+  async setLinks(customerId: string, links: CustomerLinksConfig) {
    if (!customerId || !links) {
      throw new HttpException(null, HttpStatus.BAD_REQUEST);
    }

    try {
      return await firstValueFrom(
-        this.customerService.CustomerUpdate({
-          id: customerId,
-          links,
-        } as CustomerUpdateRequest),
+        this.customerService.CustomerSetLinks({
+          customerId,
+          links: links as CustomerSetLinksRequest['links'],
+        }),
      );
    } catch (err) {
      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
@@ -223,4 +223,57 @@ export class CustomersService implements OnModuleInit {
      })
    )
  }
-}
+
+  async updateOrganizationInfo(
+    customerId: string,
+    data: {
+      companyName: string;
+      companySite: string;
+      domain: string;
+      cnpj: string;
+      description: string;
+    },
+  ) {
+    try {
+      const result = await lastValueFrom(
+        this.customerService.OrganizationUpdate({
+          customerId,
+          companyName: data.companyName || '',
+          companySite: data.companySite || '',
+          domain: data.domain || '',
+          cnpj: data.cnpj || '',
+          description: data.description || '',
+        }),
+      );
+
+      return result;
+    } catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      else throw err;
+    }
+  }
+
+  async getOrganizationInfo(customerId: string) {
+    try {
+      const customerResponse = await lastValueFrom(
+        this.customerService.CustomerFindOneById({ id: customerId })
+      );
+
+      const customer = customerResponse.customer;
+      
+      return {
+        companyName: customer.companyName || '',
+        companySite: customer.companySite || '',
+        domain: customer.domain || '',
+        cnpj: customer.cnpj || '',
+        description: customer.description || ''
+      };
+    } catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      else throw err;
+    }
+  }
+
+}
@@ -1,7 +1,6 @@
-import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';

-export class CustomerLink implements Link {
+export class CustomerLinkItem {
  @ApiProperty()
  href: string;
  @ApiProperty()
@@ -9,15 +8,59 @@ export class CustomerLink implements Link {
  @ApiProperty()
  description: string;
  @ApiPropertyOptional()
-  iconSrc: string;
+  iconSrc?: string;
 }
+
+export class CustomerSidebarLinkItem {
+  @ApiProperty()
+  type: 'link';
+  @ApiProperty({ type: Object })
+  title: Record<string, string>;
+  @ApiProperty()
+  link: string;
+  @ApiPropertyOptional()
+  icon?: string;
+}
+
+export class CustomerSidebarMenuItem {
+  @ApiProperty()
+  type: 'menu';
+  @ApiProperty({ type: Object })
+  title: Record<string, string>;
+  @ApiPropertyOptional()
+  icon?: string;
+  @ApiProperty({ type: [CustomerSidebarLinkItem] })
+  items: CustomerSidebarLinkItem[];
+}
+
+export class CustomerSidebarSection {
+  @ApiProperty({ type: Object })
+  title: Record<string, string>;
+  @ApiProperty({
+    type: 'array',
+    items: {
+      oneOf: [
+        { $ref: '#/components/schemas/CustomerSidebarMenuItem' },
+        { $ref: '#/components/schemas/CustomerSidebarLinkItem' },
+      ],
+    },
+  })
+  items: (CustomerSidebarMenuItem | CustomerSidebarLinkItem)[];
+}
+
+export class CustomerLinksConfig {
+  @ApiPropertyOptional({ type: [CustomerLinkItem] })
+  home?: CustomerLinkItem[];
+  @ApiPropertyOptional({ type: [CustomerSidebarSection] })
+  sidebar?: CustomerSidebarSection[];
+}
+
 export class CustomerLinkRequest {
-  @ApiProperty({ type: [CustomerLink] })
-  links: CustomerLink[];
+  @ApiProperty({ type: CustomerLinksConfig })
+  links: CustomerLinksConfig;
 }

 export class CustomerLinksResponse {
-  @ApiProperty({ type: [CustomerLink] })
-  links: CustomerLink[];
-}
-
+  @ApiPropertyOptional({ type: CustomerLinksConfig })
+  links?: CustomerLinksConfig;
+}
@@ -0,0 +1,27 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class OrganizationUpdateRequest {
+  @ApiProperty()
+  name: string;
+  @ApiPropertyOptional()
+  companySite: string;
+  @ApiProperty()
+  domain: string;
+  @ApiPropertyOptional()
+  info: string;
+  @ApiPropertyOptional()
+  cnpj: string;
+}
+
+export class OrganizationResponse {
+  @ApiProperty()
+  name: string;
+  @ApiPropertyOptional()
+  companySite: string;
+  @ApiProperty()
+  domain: string;
+  @ApiPropertyOptional()
+  info: string;
+  @ApiPropertyOptional()
+  cnpj: string;
+}
@@ -11,10 +11,19 @@ export class TableColumns {
  name: string;
  @ApiProperty()
  columns: string[];
-  @ApiProperty()
+  @ApiPropertyOptional({ type: [Column] })
  references: Column[];
  @ApiProperty()
+  destination: Record<'raw' | 'qualify', {
+    table_name: string;
+    table_schema: string;
+  }> | null;
+  @ApiProperty()
  type: string;
+  @ApiPropertyOptional({ type: [String] })
+  identifier_columns?: string[];
+  @ApiPropertyOptional({ type: Column })
+  reference_column?: Column;
 }
 export class AvailableEntity {
  @ApiProperty()
@@ -1,4 +1,8 @@
-import { Info } from '@dadosfera/protospack/dist/lib/interfaces';
+export interface Info {
+  user_id: string;
+  customer_id: string;
+  customer: string;
+}

 interface Values {
  jdbc_user: string;
@@ -99,6 +99,7 @@ export class InputsController {
      customer: info.customer,
    });

+    this.logger.info(JSON.stringify(body))
    const response = await this.inputService.create({ body, info });

    return response;
@@ -17,10 +17,13 @@ import {
  InputCreateGenericRequest,
  InputCreateS3Request,
  InputNewCreateRequest,
+  InputUpdateResponse,
+  RollbackInputRequest,
  TestConnectionRequest,
 } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/messages';
 import { Info } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/entities';
 import { CreateInputReq } from './dtos/input.model';
+import { Metadata } from '@grpc/grpc-js';

@Injectable()

@@ -71,10 +74,10 @@ export class InputsService {
      objectCamelToSnake(createInputResponse);
      return createInputResponse;
    },
-    update: async (updateInputDTO: UpdateInputRequest) => {
-      this.logger.info('InputClientService - Update');
+    update: async (updateInputDTO: UpdateInputRequest, metadata: Metadata): Promise<InputUpdateResponse> => {
+      this.logger.info('InputClientService - Update' + JSON.stringify(updateInputDTO));
      const updateInputResponse = await lastValueFrom(
-        this.inputWriteService.InputUpdate(updateInputDTO),
+        this.inputWriteService.InputUpdate(updateInputDTO, metadata),
      );

      return updateInputResponse;
@@ -164,6 +167,11 @@ export class InputsService {
    const inputCreateGenericRequest: InputCreateGenericRequest = {
      input: {
        ...body,
+        tables: (body.tables || []).map((table) => ({
+          ...table,
+          identifier_columns: table.identifier_columns || [],
+          reference_column: table.reference_column || table.references?.[0],
+        })),
      },
      info,
    };
@@ -199,24 +207,47 @@ export class InputsService {
    return findOneInputResponse;
  }

-  async update(id: string, data, info: Info) {
-    this.validateCron({ ...data, info });
+  async update(id: string, data, info: Info, metadata?: Metadata) {
+    // this.validateCron({ ...data, info });
    try {
-      const updateInputResponse: any = await this.OLD_inputClient.update({
+      const {
+        tablesUpdate,
+        dataAssetUpdate,
+        input
+      } = await this.OLD_inputClient.update({
        id,
-        info,
        ...data,
-      });
+        info,
+      }, metadata);

-      updateInputResponse.input = this.adjustInputPayload(
-        updateInputResponse?.input,
+      const updateInputResponse = this.adjustInputPayload(
+        input,
      );
-      return updateInputResponse;
+      return {
+        input: updateInputResponse,
+        tablesUpdate,
+        dataAssetUpdate
+      };
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

+  async rollbackUpdate(
+    data: RollbackInputRequest
+  ) {
+    this.logger.info('PipelinesClientService - rollbackUpdate');
+    this.logger.info('Rolling back input update with data: ' + JSON.stringify(data));
+    const updatePipelineResponse = await lastValueFrom(
+      this.inputWriteService.RollbackInputUpdate(
+        data
+      ),
+    );
+    this.logger.info('Done');
+
+    return updatePipelineResponse;
+  }
+
  async remove(idRequest: IIdRequest) {
    return lastValueFrom(this.inputWriteService.InputRemove(idRequest));
  }
@@ -258,4 +289,12 @@ export class InputsService {
    };
    return formatedPayload;
  }
+
+  async markTableDeleted(data: { input_id: string; table_name: string; info: Info }) {
+    return lastValueFrom(this.inputWriteService.MarkTableDeleted(data));
+  }
+
+  async unmarkTableDeleted(data: { input_id: string; table_name: string; info: Info }) {
+    return lastValueFrom((this.inputWriteService as any).UnmarkTableDeleted(data));
+  }
 }
@@ -1,29 +1,46 @@
 import { Body, Controller, Inject, Param, Post, Req } from '@nestjs/common';
-import { init } from 'mixpanel';
-import { Authenticated } from 'src/decorators/authentication.decorator';
 import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
-import { RequestUser, User } from 'src/decorators/user.decorator';
+import { RequestUser } from 'src/decorators/user.decorator';
 import { MixpanelService } from './mixpanel.service';
+import { extractUserFrom } from 'src/authentication/extract-user';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';

@ApiInternalOnlyController()
@Controller('trackEvent')
 export class MixpanelController {
+  logger: DadosferaLogger;
+
  constructor(
-    private mixpanelService: MixpanelService
-  ) {}
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private mixpanelService: MixpanelService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
  @Post(':id')
  async trackEvent(
    @Param('id') id,
    @Body() body,
-    @User() user: RequestUser,
    @Req() request
  ) {
+    this.logger.info(`POST Track Event: ${id}`)
    delete body.info;
+
+    const anonymousUser = {
+      username: "anonymous",
+      customer_name: "anonymous"
+    } as RequestUser
+
+    const hasToken = request.headers['authorization'];
+
+    const user = hasToken ? extractUserFrom(hasToken) : anonymousUser;
+
+    this.logger.info(`Has user: ${typeof hasToken == "string"}`)
 
    await this.mixpanelService.track(id, user, request, body)

+    this.logger.info(`Event successful`)
    return { id, body, user: user.username };
  }
-
-
 }
@@ -1,78 +0,0 @@
-import { ConflictException, Inject, OnModuleInit } from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-import {
-  PipelineServicesNames,
-  PipelinesServiceInterface,
-} from '@dadosfera/protospack';
-import { lastValueFrom } from 'rxjs';
-
-import { IIdRequest } from './interfaces';
-
-import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-import { PipelinesClientConfiguration } from './pipelines-client';
-
-export class PipelinesClientService implements OnModuleInit {
-  private pipelineService: PipelinesServiceInterface;
-  logger: DadosferaLogger;
-
-  constructor(
-    @Inject(DadosferaLogger)
-      dadosferaLogger: DadosferaLogger,
-    @Inject(PipelinesClientConfiguration.name)
-    private readonly grpcClient: ClientGrpc,
-  ) {
-    this.logger = dadosferaLogger.logger;
-  }
-
-  onModuleInit() {
-    this.pipelineService =
-      this.grpcClient.getService<PipelinesServiceInterface>(
-        PipelineServicesNames.PipelineService,
-      );
-  }
-
-  async getPipelineStatus(data) {
-    this.logger.info('PipelinesClientService - GetPipelineStatus');
-
-    const statusPipelineResponse = await lastValueFrom(
-      this.pipelineService.getPipelineStatus(data),
-    )
-      .then((res) => {
-        const statusArray =
-          res.status?.sort((a, b) => {
-            if (a.id < b.id) {
-              return 1;
-            } else {
-              return -1;
-            }
-          }) || [];
-        return { status: statusArray };
-      })
-      .catch((err) => {
-        this.logger.error(err.message);
-        throw new Error(err);
-      });
-    this.logger.info('Done');
-
-    return statusPipelineResponse;
-  }
-
-  async runPipeline({ id, info }: IIdRequest) {
-    this.logger.info('PipelinesClientService - RunPipeline');
-    const statusPipelineResponse = await lastValueFrom(
-      this.pipelineService.triggerPipeline({ id, info }),
-    ).catch((err) => {
-      this.logger.error(err.message);
-      throw new Error(err);
-    });
-
-    if (statusPipelineResponse.status == false) {
-      throw new ConflictException(
-        'This pipeline is not ready yet to execute, Try again later!',
-      );
-    }
-
-    this.logger.info('Done');
-    return statusPipelineResponse;
-  }
-}
@@ -1,36 +0,0 @@
-import { Info } from '@dadosfera/protospack/dist/lib/interfaces';
-
-export interface ICreatePipelineDto {
-  input: IdRequest;
-  transformations: IdRequest[];
-  output: IdRequest;
-  tags: string[];
-  name: string;
-  description: string;
-  info: Info;
-}
-
-export interface IdRequest {
-  id: string;
-}
-
-export interface IIdRequest {
-  id: string;
-  info: Info;
-}
-
-export interface IUpdatePipelineRequest {
-  input: IdRequest;
-  transformations: IdRequest[];
-  output: IdRequest;
-  tags: string[];
-  name: string;
-  description: string;
-  id: string;
-  info: Info;
-}
-
-export interface IGetPipelineLogsRequest {
-  id: string;
-  details: string;
-}
@@ -1,33 +0,0 @@
-import {
-  ClientsProviderAsyncOptions,
-  GrpcOptions,
-  Transport,
-} from '@nestjs/microservices';
-import { PipelinePackages, PipelineProtoFilePath } from '@dadosfera/protospack';
-import { credentials } from '@grpc/grpc-js';
-
-const isLocalConnection =
-  process.env.PIFACTORY_URL.startsWith('pi-factory:') ||
-  process.env.PIFACTORY_URL.includes('0.0.0.0');
-
-export class PipelinesClientConfiguration {
-  public name = 'PipelinesClientConfiguration';
-  private config: GrpcOptions = {
-    transport: Transport.GRPC,
-    options: {
-      url: process.env.PIFACTORY_URL,
-      package: PipelinePackages,
-      credentials: isLocalConnection ? undefined : credentials.createSsl(),
-      protoPath: PipelineProtoFilePath,
-      loader: {
-        keepCase: true,
-        enums: String,
-        defaults: false,
-      },
-    },
-  };
-  providerOptions: ClientsProviderAsyncOptions = {
-    name: this.name,
-    ...this.config,
-  };
-}
@@ -1,89 +0,0 @@
-import { Body, Controller, Get, Inject, Param, Post } from '@nestjs/common';
-import { ApiOperation, ApiTags } from '@nestjs/swagger';
-import {
-  AuthenticateCondition,
-  Authenticated,
-} from 'src/decorators/authentication.decorator';
-import { PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
-import { PipelinesService } from './pipelines.service';
-import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
-
-@ApiInternalOnlyController()
-@ApiTags('Pipelines')
-@Controller('pipelines')
-@Authenticated()
-@AuthenticateCondition((req, user) => {
-  let action;
-
-  switch (req.method) {
-    case 'POST':
-      action = 'CREATE';
-      break;
-
-    case 'PUT':
-      action = 'UPDATE';
-      break;
-
-    default:
-      action = req.method;
-  }
-
-  return user.permissions.includes(
-    PERMISSIONS_GROUPS.PIPELINE.permissions[action].seqid,
-  );
-})
-export class PipelinesController {
-  logger: DadosferaLogger;
-  constructor(
-    @Inject(DadosferaLogger)
-    dadosferaLogger: DadosferaLogger,
-    private pipelineService: PipelinesService,
-  ) {
-    this.logger = dadosferaLogger.logger;
-  }
-
-  @Post('start/:id')
-  @ApiOperation({
-    deprecated: true,
-    description:
-      'This method is deprecated. Please use route /pipelinesV2/start/:id instead',
-  })
-  async activate(@Param('id') id: string, @Body() body) {
-    const { info } = body;
-
-    this.logger.info(
-      process.env.DEV_URL + `/pipeline/start/${id} - ON START PIPELINE ROUTE`,
-      {
-        user: body.info.user_id,
-        customer: body.info.customer,
-      },
-    );
-
-    const response = await this.pipelineService.runPipeline({ id, info });
-
-    return response;
-  }
-
-  @Get(':id/status')
-  @ApiOperation({
-    deprecated: true,
-    description:
-      'This method is deprecated. Please use route /pipelinesV2/:id/status instead',
-  })
-  async getPipelineStatus(@Body() body, @Param('id') id: string) {
-    body.id = id;
-
-    this.logger.info(
-      process.env.DEV_URL + `/pipeline/${id} - ON GET PIPELINE STATUS ROUTE`,
-      {
-        user: body.info.user_id,
-        customer: body.info.customer,
-      },
-    );
-
-    const response = await this.pipelineService.getPipelineStatus(body);
-
-    return response;
-  }
-}
@@ -1,19 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ClientsModule } from '@nestjs/microservices';
-import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-
-import { PipelinesController } from './pipelines.controller';
-import { PipelinesService } from './pipelines.service';
-
-import { PipelinesClientConfiguration } from './pipelines-client';
-import { PipelinesClientService } from './client.service';
-
-const client = new PipelinesClientConfiguration();
-
-@Module({
-  imports: [ClientsModule.register([client.providerOptions])],
-  controllers: [PipelinesController],
-  providers: [PipelinesService, PipelinesClientService, DadosferaLogger],
-  exports: [PipelinesService],
-})
-export class PipelinesModule {}
@@ -1,33 +0,0 @@
-import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { PipelinesClientService } from './client.service';
-import { IIdRequest } from './interfaces';
-import { objectCamelToSnake } from 'src/utils/CaseConverter';
-
-@Injectable()
-export class PipelinesService {
-  constructor(private pipelineClient: PipelinesClientService) {}
-
-  async getPipelineStatus(data: IIdRequest) {
-    try {
-      const pipelineStatusResponse =
-        await this.pipelineClient.getPipelineStatus(data);
-
-      return objectCamelToSnake(pipelineStatusResponse);
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
-  }
-
-  async runPipeline({ id, info }: IIdRequest) {
-    try {
-      const triggerPipelineResponse = await this.pipelineClient.runPipeline({
-        id,
-        info,
-      });
-
-      return objectCamelToSnake(triggerPipelineResponse);
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
-  }
-}
@@ -1,5 +1,13 @@
 import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
-import { Info } from '@dadosfera/protospack/dist/lib/interfaces';
+
+export class PipelineInputsDTO {
+  @ApiProperty()
+  tables: Array<{
+    name: string,
+    type: string,
+    
+  }>
+}

 export class IPipelineV2 {
  @ApiProperty()
@@ -53,6 +61,12 @@ export interface IIdRequest {
  info: Info;
 }

+export interface Info {
+  user_id: string;
+  customer_id: string;
+  customer: string;
+}
+
 export interface IUpdatePipelineRequest {
  input: IdRequest;
  transformations: IdRequest[];
@@ -123,3 +137,30 @@ export class PipelineFindAllReq {
  @ApiPropertyOptional()
  type?: string | undefined;
 }
+
+export interface UpdateTableDTO {
+  name: string;
+  type: string;
+  columns: string[];
+  destinations: {
+    raw: {
+      table_schema: string;
+      table_name: string;
+    };
+    qualify: {
+      table_schema: string;
+      table_name: string;
+    };
+  };
+  identifier_columns: string[];
+  reference_column: {
+    name: string;
+    type: string;
+  };
+  memory: number;
+}
+
+export interface UpdatePlatformInputRequest {
+  cron: string;
+  tables: Array<UpdateTableDTO>;
+}
@@ -14,7 +14,7 @@ import {
  Patch,
  HttpException,
  BadRequestException,
-  CacheTTL,
+  UseGuards,
 } from '@nestjs/common';
 import {
  ApiCreatedResponse,
@@ -24,17 +24,17 @@ import {
  ApiTags,
 } from '@nestjs/swagger';
 import {
-  AuthenticateCondition,
  RequireAllPermissions,
+  RequireModule,
+  RequireSomePermission,
 } from 'src/decorators/authentication.decorator';
-import { PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
+import { DADOSFERA_MODULES_KEYS, PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
 import { PipelinesService } from './pipelines.service';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { Messages } from '@dadosfera/protospack-v2/dist/lib/PipelineV2';
 import { RequestUser, User } from 'src/decorators/user.decorator';
 import { PackTheMetadata } from 'src/utils/PackTheMetadata';

-import { PipelinesService as OldPipelineService } from 'src/modules/pipelines/pipelines.service';
 import {
  ICompleteUploadCSVFile,
  ICreatePipelineCSVFile,
@@ -42,52 +42,37 @@ import {
  IPipelineV2,
  IInitUploadCSVFile,
  PipelineFindAllReq,
+  UpdatePlatformInputRequest,
 } from './interfaces';
 import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
 import { LanguageEnum } from 'src/utils/languages.enum';
 import { Language } from 'src/decorators/language.decorator';
 import { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
+import { Info } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/entities';
+import { PipelineExecutionGuard } from 'src/guards/pipeline-execution.guard';
+
+type PipelineTable = { name: string; job_id?: string; is_deleted?: boolean; [key: string]: any };
+type PipelineTablesConfig = { input_id?: string; tables: PipelineTable[] };

@ApiTags('PipelinesV2')
@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
@UseFilters(new GrpcToHttpExceptionFilter())
@Controller('pipelinesV2')
-@AuthenticateCondition((req, user) => {
-  let action;
-
-  switch (req.method) {
-    case 'POST':
-      action = 'CREATE';
-      break;
-
-    case 'PUT':
-      action = 'UPDATE';
-      break;
-
-    case 'PATCH':
-      action = 'UPDATE';
-      break;
-
-    default:
-      action = req.method;
-  }
-
-  return user.permissions.includes(
-    PERMISSIONS_GROUPS.PIPELINE.permissions[action].seqid,
-  );
-})
+@RequireModule(
+  DADOSFERA_MODULES_KEYS.COLLECT
+)
 export class PipelinesController {
  logger: DadosferaLogger;
  constructor(
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
    private pipelinesClientService: PipelinesService,
-    private oldPipelinesService: OldPipelineService,
  ) {
    this.logger = dadosferaLogger.logger;
  }

  @Get('monitoring-dashboard')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async getMonitoringDashboard(@User() user: RequestUser) {
    this.logger.info('PipelinesController - getMonitoringDashboard', { user });

@@ -100,6 +85,7 @@ export class PipelinesController {
  }

  @Post()
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE)
  @ApiCreatedResponse({ type: IPipelineV2 })
  async create(
    @Language() language: LanguageEnum,
@@ -126,6 +112,7 @@ export class PipelinesController {
  }

  @Get()
+  @RequireSomePermission(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW, PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async findAll(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
@@ -150,6 +137,7 @@ export class PipelinesController {
  }

  @Get('/download-logs')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async downloadLogs(
    @User() user: RequestUser,
    @Language() language: LanguageEnum,
@@ -180,6 +168,7 @@ export class PipelinesController {
  }

  @Get(':id/config')
+  @RequireSomePermission(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW,PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async getPipelineproperties(
    @Language() language: LanguageEnum,
    @User() user: RequestUser,
@@ -191,6 +180,7 @@ export class PipelinesController {
  }

  @Get(':id/objects')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async getPipelineObjects(
    @Language() language: LanguageEnum,
    @User() user: RequestUser,
@@ -202,7 +192,9 @@ export class PipelinesController {
  }

  @Get(':id/status')
+  @RequireSomePermission(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW, PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async getPipelineStatus(@Body() body, @Param('id') id: string) {
+
    body.id = id;

    this.logger.info(`/pipeline/${id} - ON GET PIPELINE STATUS ROUTE`, {
@@ -210,12 +202,13 @@ export class PipelinesController {
      customer: body.info.customer,
    });

-    const response = await this.oldPipelinesService.getPipelineStatus(body);
+    const response = await this.pipelinesClientService.getPipelineStatus(body);

    return response;
  }

  @Get('/:id')
+  @RequireSomePermission(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW, PERMISSIONS_GROUPS.PIPELINE.permissions.GET)
  async findOne(
    @Language() language: LanguageEnum,
    @User() user: RequestUser,
@@ -233,31 +226,56 @@ export class PipelinesController {
      language,
    });

-    const result = await this.pipelinesClientService
-      .findOne({ id }, metadata)
-      .then((res) => {
-        //{pipeline:{tables: {tables: [], input_id: ''}}}
-        let tables = JSON.parse(res.pipeline.config.tables);
-        if (tables?.tables) tables = tables.tables;
-        Object.assign(res.pipeline, {
-          transformations: res.pipeline.transformations
-            ? JSON.parse(res.pipeline.transformations)
-            : [],
-          config: {
-            cron: res.pipeline.config.cron,
-            tables,
-          },
-          properties: res.pipeline.properties
-            ? JSON.parse(res.pipeline.properties)
-            : {},
-        });
-        return res;
-      });
+    const pipelineRes = await this.pipelinesClientService.findOne({ id }, metadata);
+
+    const parsed: PipelineTablesConfig = JSON.parse(pipelineRes.pipeline.config.tables);
+    const input_id = parsed.input_id;
+    const tables: PipelineTable[] = parsed.tables ?? [];
+
+    Object.assign(pipelineRes.pipeline, {
+      transformations: pipelineRes.pipeline.transformations
+        ? JSON.parse(pipelineRes.pipeline.transformations)
+        : [],
+      config: {
+        cron: pipelineRes.pipeline.config.cron,
+        tables,
+        input_id,
+      },
+      properties: pipelineRes.pipeline.properties
+        ? JSON.parse(pipelineRes.pipeline.properties)
+        : {},
+    });
+
+    return pipelineRes;
+  }
+
+  @Get("/:id/data-assets")
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.PIPELINE.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET
+  )
+  async findAllDataAssetByPipeline(
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @User() user: RequestUser,
+    @Query('object') object: string
+  ) {
+    const payload = {
+      pipeline: id,
+      object: object, 
+    };
+
+    this.logger.info(`GET pipelinesV2/:id/data-assets` + JSON.stringify(payload));
+    
+    const result =
+      await this.pipelinesClientService.findAllDataAssetByPipeline(payload, user);

    return result;
  }

  @Patch('/:id')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE)
  async update(
    @Language() language: LanguageEnum,
    @Body() updatePipelineDto,
@@ -291,12 +309,47 @@ export class PipelinesController {
    return response;
  }

+  @Patch('/:pipelineId/inputs/:id')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE)
+  @UseGuards(PipelineExecutionGuard)
+  async updatePipelineInput(
+    @Language() language: LanguageEnum,
+    @Body() pipelineInputDTO: UpdatePlatformInputRequest,
+    @Param('id') inputId: string,
+    @Param('pipelineId') pipelineId: string,
+    @User() user: RequestUser,
+  ) {
+    this.logger.info('PipelinesController - update', { user });
+
+    const info: Info = {
+      user_id: user.user_id,
+      customer: user.customer_name,
+      customer_id: user.customer_id,
+      pipeline_id: pipelineId
+    };
+
+    const metadata = PackTheMetadata(user);
+
+    const response = await this.pipelinesClientService.updatePipelineInput(
+      pipelineId,
+      inputId,
+      pipelineInputDTO,
+      info,
+      user,
+      metadata,
+    );
+
+    this.logger.info('PipelinesController - update: OK', { user });
+    return response;
+  }
+
  @ApiInternalOnlyEndpoint()
  @Put('/:id')
  @ApiOperation({
    deprecated: true,
    description: 'This method is deprecated. Please use PATCH instead',
  })
+  @RequireSomePermission(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW, PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE)
  async updateDeprecated(
    @Language() language: LanguageEnum,
    @Body() updatePipelineDto,
@@ -309,9 +362,25 @@ export class PipelinesController {
    return response;
  }

+  @Patch('/:id/upgrade')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE)
+  @HttpCode(HttpStatus.NO_CONTENT)
+  async upgradeConnector(
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @User() user: RequestUser
+  ) {
+    this.logger.info('PipelinesController - upgrade connector');
+
+    const metadata = PackTheMetadata(user);
+
+    await this.pipelinesClientService.upgrade(id, metadata);
+  }
+
  @Delete(':id')
  @ApiNoContentResponse()
  @HttpCode(HttpStatus.NO_CONTENT)
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE)
  async delete(@Param('id') id: string, @User() user: RequestUser) {
    this.logger.info('PipelinesController - delete', { user });
    const metadata = PackTheMetadata({
@@ -325,7 +394,7 @@ export class PipelinesController {

  @ApiInternalOnlyEndpoint()
  @Post('/init-upload')
-  @RequireAllPermissions(PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE)
+  @RequireAllPermissions(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW)
  async initUploadFile(
    @User() user: RequestUser,
    @Body() body: IInitUploadCSVFile,
@@ -357,7 +426,7 @@ export class PipelinesController {

  @ApiInternalOnlyEndpoint()
  @Post('/complete-upload')
-  @RequireAllPermissions(PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE)
+  @RequireAllPermissions(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW)
  async completeUploadFile(
    @User() user: RequestUser,
    @Body() body: ICompleteUploadCSVFile,
@@ -375,7 +444,7 @@ export class PipelinesController {

  @ApiInternalOnlyEndpoint()
  @Post('/file')
-  @RequireAllPermissions(PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE)
+  @RequireAllPermissions(PERMISSIONS_GROUPS.IMPORT_FILES.permissions.VIEW)
  async uploadedFile(
    @User() user: RequestUser,
    @Body() body: ICreatePipelineCSVFile,
@@ -425,6 +494,7 @@ export class PipelinesController {

  @ApiInternalOnlyEndpoint()
  @Post('start/:id')
+  @RequireSomePermission(PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE)
  async activate(@Param('id') id: string, @Body() body) {
    const { info } = body;

@@ -436,7 +506,7 @@ export class PipelinesController {
      },
    );

-    const response = await this.oldPipelinesService.runPipeline({ id, info });
+    const response = await this.pipelinesClientService.runPipeline({ id, info });

    return response;
  }
@@ -7,23 +7,28 @@ import { PipelinesService } from './pipelines.service';

 import { PipelinesClientConfiguration } from './pipelines-client';

-import { PipelinesModule as OldPipelineModule } from 'src/modules/pipelines/pipelines.module';
 import { ConnectorModule } from '../connector/connector.module';
 import { InputsModule } from '../inputs/inputs.module';
 import { TransformationsModule } from '../transformations/transformations.module';
+import { PlatformApiModule } from '../platform-api/platform-api.module';
+import { NimbusServicesModule } from 'src/services/nimbus/nimbus.module';
+import { NimbusService } from 'src/services/nimbus/nimbus.service';
+import { CatalogModule } from '../catalog/catalog.module';

 const client = new PipelinesClientConfiguration();

@Module({
  imports: [
    ClientsModule.register([client.providerOptions]),
-    OldPipelineModule,
    ConnectorModule,
    InputsModule,
    TransformationsModule,
+    PlatformApiModule,
+    NimbusServicesModule,
+    CatalogModule
  ],
  controllers: [PipelinesController],
-  providers: [PipelinesService, DadosferaLogger],
+  providers: [PipelinesService, DadosferaLogger, NimbusService],
  exports: [PipelinesService],
 })
 export class PipelinesV2Module {}
@@ -1,5 +1,7 @@
+/* eslint-disable no-async-promise-executor */
 import {
  BadRequestException,
+  ConflictException,
  HttpException,
  HttpStatus,
  Inject,
@@ -16,7 +18,7 @@ import { lastValueFrom } from 'rxjs';

 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { PipelinesClientConfiguration } from './pipelines-client';
-import { ICreatePipelineV2Req } from './interfaces';
+import { ICreatePipelineV2Req, IIdRequest, UpdatePlatformInputRequest, UpdateTableDTO } from './interfaces';
 import { PipelineV2CreateRequest } from '@dadosfera/protospack-v2/dist/lib/PipelineV2/interfaces/messages';
 import { Metadata } from '@grpc/grpc-js';
 import { ConnectorClientService } from '../connector/client.service';
@@ -26,6 +28,17 @@ import { TransformationsService } from '../transformations/transformations.servi
 import { getObjValueFromPath, objHasPath } from 'src/utils/ObjValueFromPath';
 import ErrorCodes from 'src/utils/errorCodes';
 import ErrorBuilder from 'src/utils/ErrorBuilder';
+import { PlatformApiService } from '../platform-api/platform-api.service';
+import { Info } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/entities';
+import { TableUpdate } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/messages';
+import { AxiosError } from 'axios';
+import { NimbusService } from 'src/services/nimbus/nimbus.service';
+import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { IDataAsset } from '../catalog/dtos';
+import { CatalogService } from '../catalog/catalog.service';
+
+type RollbackPromise = () => Promise<any>;

 export class PipelinesService implements OnModuleInit {
  logger: DadosferaLogger;
@@ -39,6 +52,9 @@ export class PipelinesService implements OnModuleInit {
    private readonly connectorService: ConnectorClientService,
    private readonly inputsService: InputsService,
    private readonly transformationsService: TransformationsService,
+    private readonly platformAPI: PlatformApiService,
+    private readonly nimbusService: NimbusService,
+    private readonly catalogService: CatalogService
  ) {
    this.logger = dadosferaLogger.logger;
  }
@@ -138,6 +154,7 @@ export class PipelinesService implements OnModuleInit {
    const findOnePipelineResponse = await lastValueFrom(
      this.pipelineReadService.PipelineV2FindOne(data, metadata),
    );
+    console.log('pipeline find one response', findOnePipelineResponse);
    this.logger.info('Done');

    return findOnePipelineResponse;
@@ -160,6 +177,15 @@ export class PipelinesService implements OnModuleInit {
    return updatePipelineResponse;
  }

+  async upgrade(id: string, metadata: Metadata) {
+    await lastValueFrom(
+      this.pipelineWriteService.Upgrade(
+        { id },
+        metadata,
+      ),
+    );
+  }
+
  async remove(data: { id: string; metadata: Metadata; user: RequestUser }) {
    const { id, metadata, user } = data;
    const info = {
@@ -339,4 +365,320 @@ export class PipelinesService implements OnModuleInit {

    return res;
  }
+
+  async updatePipelineInput(pipelineId: string, inputId: string, updateInputDTO: UpdatePlatformInputRequest, info: Info, user: RequestUser, metadata: Metadata) {
+    this.logger.info('InputClientService - Update');
+
+    const {
+      input: oldInput
+    } = await this.inputsService.findOne({
+      id: inputId,
+      info: info
+    });
+
+    this.logger.info('Update Dynamo Reference :' + JSON.stringify(oldInput));
+    const pipelineIdFormat = pipelineId.split('-').join('_');
+    const rollback: RollbackPromise[] = [];
+
+    const updateInputResponse = await this.inputsService.update(
+      inputId,
+      updateInputDTO,
+      info,
+      metadata
+    );
+
+    const inputRollback = () => {
+      this.logger.info("exec rollback to input: " + JSON.stringify(oldInput));
+      return this.inputsService.rollbackUpdate(
+        {
+          id: inputId,
+          dataAssetUpdate: updateInputResponse.dataAssetUpdate,
+          tables: oldInput.tables,
+          info
+        }
+      ) as Promise<any>;
+    }
+
+    rollback.push(inputRollback);
+
+    this.logger.info("Input Update Response: " + JSON.stringify(updateInputResponse))
+
+    const nimbusUpdates = updateInputResponse?.tablesUpdate || [];
+
+    if (user.customer_modules.includes('catalog')) {
+      nimbusUpdates.forEach(update => {
+        const nimbusRollback = () => {
+          return this.nimbusService.renameTable(
+            info.customer,
+            update.database,
+            {
+              table_name: update.table_name,
+              table_schema: update.table_schema
+            },
+            {
+              table_name: update.old_table_name,
+              table_schema: update.old_table_schema
+            }
+          );
+        }
+        rollback.push(nimbusRollback);
+      });
+  
+      try {
+        await this.updateNimbus(info.customer, nimbusUpdates);
+      } catch (error) {
+        this.logger.error(error);
+        if (error instanceof AxiosError) {
+          this.logger.error(JSON.stringify(error.response.data));
+        }
+        await this.executeRenameRollback(rollback);
+  
+        throw new Error("Error Nimbus updating tables");
+      }
+    }
+
+    try {
+      await this.updatePlatformJobs(
+        pipelineIdFormat,
+        updateInputResponse.input.type,
+        updateInputDTO,
+        user
+      );
+    } catch (error) {
+      this.logger.error(error);
+      await this.executeRenameRollback(rollback)
+      throw new Error("Error Platform API updating jobs");
+    }
+
+    return updateInputResponse;
+  }
+
+  private async executeRenameRollback(request: RollbackPromise[]) {
+    this.logger.info('rollback steps: ' + request.length)
+    const result = await Promise.allSettled(request.map(func => func()));
+    result.forEach(promise => {
+      this.logger.info("Promise finish with status: " + promise.status)
+
+      if (promise.status === "rejected") {
+        this.logger.error("reject with: " + JSON.stringify(promise.reason || {}))
+      }
+
+      if (promise.status === "fulfilled") {
+        this.logger.info("success with: " + JSON.stringify(promise.value || {}))
+      }
+    });
+
+  }
+
+  private async updateNimbus(customer: string, changes: TableUpdate[]) {
+    // throw new Error("teste error nimbus");
+    this.logger.info('Nimbus Changes: ' + JSON.stringify(changes));
+    if(!changes || changes.length === 0) return;
+
+    const requests = changes.map(change => {
+      return this.nimbusService.renameTable(customer, change.database, {
+        table_name: change.old_table_name,
+        table_schema: change.old_table_schema
+      }, {
+        table_name: change.table_name,
+        table_schema: change.table_schema
+      });
+    })
+
+    const values = await Promise.allSettled(requests);
+
+    const success = values.map(request => request.status === "fulfilled")
+
+    this.logger.info("Updates with succes: " + success.length);
+
+    values.forEach(promise => {
+      this.logger.info("Promise finish with status: " + promise.status)
+
+      if (promise.status === "rejected") {
+        this.logger.error("reject with: " + JSON.stringify(promise.reason || {}));
+        throw new Error(promise.reason );
+      }
+
+      if (promise.status === "fulfilled") {
+        this.logger.info("success with: " + JSON.stringify(promise.value || {}));
+      }
+    });
+
+  }
+
+  async updatePlatformJobs(pipelineId: string, pipelineType: string, updateInputDTO: UpdatePlatformInputRequest, user: RequestUser) {
+    const jobsUpdated = [];
+
+    for (const [index, table] of updateInputDTO.tables.entries()) {
+      const jobUpdate = {
+        job_id: `${pipelineId}_${index}`,
+      }
+
+      if (table.type !== "incremental_with_qualify") {
+        delete table.destinations?.qualify;
+      }
+
+      if (table.memory) {
+        jobUpdate["memory"] = {
+          amount: table.memory * 1000
+        }
+      }
+      
+      this.logger.info('Updating input reference for table: ' + table.name);
+      let hasUpdateSyncMode = false;
+
+      const jobSyncMode = {}
+
+      if (table.columns) {
+        hasUpdateSyncMode = true;
+        jobSyncMode['column_include_list'] = table.columns;
+      }
+
+      if (table.reference_column) {
+        hasUpdateSyncMode = true;
+        jobSyncMode['incremental_column_name'] = table.reference_column.name;
+        jobSyncMode['incremental_column_type'] = table.reference_column.type;
+      }
+
+      if (table.identifier_columns) {
+        hasUpdateSyncMode = true;
+        jobSyncMode['primary_keys'] = table.identifier_columns;
+      }
+
+      if (table.type) {
+        hasUpdateSyncMode = true;
+        
+        jobSyncMode['target_load_type'] = table.type;
+      }
+
+      if(hasUpdateSyncMode) {
+        jobUpdate["sync_mode"] = jobSyncMode;
+      }
+
+      if (Object.keys(table.destinations).length > 1) {
+        let hasChanges = false
+        const jobRenameTables = {
+            raw: {},
+            qualify: {}
+        }
+
+        if (Object.keys(table.destinations.raw).length > 1) {
+          hasChanges = true;
+          jobRenameTables.raw = table.destinations.raw;
+        }
+
+        if (Object.keys(table.destinations.qualify).length > 1) {
+          hasChanges = true;
+          jobRenameTables.qualify = table.destinations.qualify;
+        }
+
+        if (hasChanges) {
+          jobUpdate['rename_tables'] = jobRenameTables;
+        }
+      }
+
+      jobsUpdated.push(jobUpdate);
+    }
+
+    this.logger.info('Request body:' + JSON.stringify({
+      jobs_updated: jobsUpdated
+    }));
+
+    const response = await this.platformAPI.proxy(
+      'PUT',
+        `/pipeline/${pipelineId}/jobs`,
+      user,
+      {
+        job_updates: jobsUpdated
+      }
+    )
+    this.logger.info('Platform api response: ' + JSON.stringify(response));
+  }
+
+  async findAllDataAssetByPipeline(data: {
+    pipeline: string,
+    object?: string
+  }, user: RequestUser) {
+    const metadata = PackTheMetadata(user);
+
+    const isDataAdmin = user.permissions.includes(
+      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+    );
+
+    let has_permission = false;
+
+    const {
+      data_assets: resultString
+    } = await lastValueFrom(
+      this.pipelineReadService.FindAllDataAssetByPipeline(data, metadata)
+    );
+
+    const result = JSON.parse(resultString) as any;
+    const data_assets: IDataAsset[] = []
+    result.forEach(data_asset => {
+      if (data_asset?.owner === user.username) has_permission = true;
+
+      for (const role of user.roles) {
+        if (data_asset.roles.includes(role)) has_permission = true;
+      }
+  
+      if (data_asset.users.includes(user.user_id)) has_permission = true;
+  
+      if (isDataAdmin || has_permission) {
+        delete data_asset.p_roles;
+        delete data_asset.p_users;
+        data_assets.push(data_asset as IDataAsset);
+      }
+    });
+
+    const assets = await this.catalogService.getAssetsUsersAndRoles(data_assets, user.customer_id);
+
+    return assets;
+  }
+
+  async getPipelineStatus(data) {
+    this.logger.info('PipelinesClientService - GetPipelineStatus');
+
+    const statusPipelineResponse = await lastValueFrom(
+      this.pipelineReadService.PipelineV2GetPipelineV2Status(data),
+    )
+      .then((res) => {
+        const statusArray =
+          res.status?.sort((a, b) => {
+            if (a.id < b.id) {
+              return 1;
+            } else {
+              return -1;
+            }
+          }) || [];
+        return { status: statusArray };
+      })
+      .catch((err) => {
+        this.logger.error(err.message);
+        throw new Error(err);
+      });
+    this.logger.info('Done');
+
+    return statusPipelineResponse;
+  }
+
+  async runPipeline({ id, info }: IIdRequest) {
+    this.logger.info('PipelinesClientService - RunPipeline');
+    const statusPipelineResponse = await lastValueFrom(
+      this.pipelineWriteService.PipelineV2TriggerPipelineV2({ id, info }),
+    ).catch((err) => {
+      this.logger.error(err.message);
+      throw new Error(err);
+    });
+
+    if (statusPipelineResponse.status == false) {
+      throw new ConflictException(
+        'This pipeline is not ready yet to execute, Try again later!',
+      );
+    }
+
+    this.logger.info('Done');
+    return statusPipelineResponse;
+  }
+
 }
@@ -0,0 +1,11 @@
+export const PLATFORM_API_CONFIG = {
+  getUrl: (): string => {
+    const url = process.env.PLATFORM_API_URL;
+    if (!url) {
+      throw new Error('PLATFORM_API_URL environment variable is not set');
+    }
+    return url;
+  },
+  region: process.env.AWS_REGION || 'us-east-1',
+  timeout: parseInt(process.env.PLATFORM_API_TIMEOUT || '30000', 10),
+};
@@ -0,0 +1,9 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export class ValidationTableDTO {
+    @ApiProperty()
+    tables: Array<{
+        table_name: string;
+        table_schema: string;
+    }>
+}
@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { PlatformApiController } from './platform-api.controller';
+import { PlatformApiService } from './platform-api.service';
+import { ElasticsearchModule } from '../../services/elasticsearch';
+import { DynamoDBModule } from '../../services/dynamodb';
+import { CustomersModule } from '../customers/customers.module';
+import { CatalogModule } from '../catalog/catalog.module';
+import { InputsModule } from '../inputs/inputs.module';
+
+@Module({
+  imports: [ElasticsearchModule, DynamoDBModule, CustomersModule, CatalogModule, InputsModule],
+  controllers: [PlatformApiController],
+  providers: [PlatformApiService, DadosferaLogger],
+  exports: [PlatformApiService],
+})
+export class PlatformApiModule {}
@@ -0,0 +1,131 @@
+import { Injectable, Inject, HttpException } from '@nestjs/common';
+import { SignatureV4 } from '@aws-sdk/signature-v4';
+import { Sha256 } from '@aws-crypto/sha256-js';
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import axios, { AxiosResponse, Method } from 'axios';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { RequestUser } from '../../decorators/user.decorator';
+import { PLATFORM_API_CONFIG } from './platform-api.config';
+
+@Injectable()
+export class PlatformApiService {
+  private signer: SignatureV4;
+  private logger: any;
+
+  constructor(
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+    this.signer = new SignatureV4({
+      service: 'execute-api',
+      region: PLATFORM_API_CONFIG.region,
+      credentials: defaultProvider(),
+      sha256: Sha256,
+    });
+  }
+
+  async proxy(
+    method: string,
+    path: string,
+    user: RequestUser,
+    body?: any,
+    query?: Record<string, string>,
+  ): Promise<any> {
+    const baseUrl = PLATFORM_API_CONFIG.getUrl();
+    const url = new URL(`${baseUrl}${path}`);
+
+    // Add query params
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+
+    const headers: Record<string, string> = {
+      host: url.hostname,
+      'content-type': 'application/json',
+      // Forward user context headers
+      // Note: platform-api expects customer_name in the 'customer_id' header (contract inconsistency)
+      'customer_id': user.customer_name || '',
+      'customer_name': user.customer_name || '',
+      'x-user-id': user.user_id || '',
+      'x-username': user.username || '',
+      'x-customer-tier': user.customer_tier || '',
+      'x-customer-id': user.customer_id || '',
+    };
+
+    const requestToSign = {
+      method: method.toUpperCase(),
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port ? parseInt(url.port, 10) : undefined,
+      path: url.pathname + url.search,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    };
+
+    this.logger.info('Proxying request to platform-api', {
+      method: method.toUpperCase(),
+      path,
+      customer_id: user.customer_id,
+      user_id: user.user_id,
+    });
+
+    try {
+      // Sign with IAM v4
+      const signedRequest = await this.signer.sign(requestToSign);
+
+      const response: AxiosResponse = await axios({
+        method: method as Method,
+        url: url.href,
+        headers: signedRequest.headers as Record<string, string>,
+        data: body,
+        timeout: PLATFORM_API_CONFIG.timeout,
+        validateStatus: () => true, // Don't throw on non-2xx
+      });
+
+      // Propagate non-2xx responses as HttpExceptions
+      if (response.status >= 400) {
+        this.logger.error('Platform API upstream error' + JSON.stringify({
+          status: response.status,
+          data: response.data,
+          path,
+          method: method.toUpperCase(),
+        }));
+        throw new HttpException(response.data, response.status);
+      }
+
+      return response.data;
+    } catch (error) {
+      this.logger.error('Platform API proxy error', {
+        error: error.message,
+        status: error.response?.status,
+        path,
+        method: method.toUpperCase(),
+      });
+
+      this.logger.error(error)
+
+      if (error instanceof HttpException) {
+        throw error;
+      }
+
+      if (error.response) {
+        throw new HttpException(error.response.data, error.response.status);
+      }
+
+      if (error.code === 'ECONNREFUSED') {
+        throw new HttpException('Platform API service unavailable', 503);
+      }
+
+      if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+        throw new HttpException('Platform API request timeout', 504);
+      }
+
+      throw new HttpException('Internal server error', 500);
+    }
+  }
+}
@@ -0,0 +1,14 @@
+export type ReleaseNoteDTO = {
+    id: string;
+    date: string;
+    tag: string;
+    title: string;
+    visible: boolean;
+    expiryDate: string;
+    content: string;
+    showEmojis: boolean;
+    image?: string;
+    link?: string;
+    linkText?: string;
+  };
+  
@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ReleaseNoteController } from './release_note.controller';
+import { ReleaseNoteService } from './release_note.service';
+
+describe('ReleaseNoteController', () => {
+  let controller: ReleaseNoteController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ReleaseNoteController],
+      providers: [ReleaseNoteService],
+    }).compile();
+
+    controller = module.get<ReleaseNoteController>(ReleaseNoteController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});
@@ -0,0 +1,26 @@
+import { Controller, Get, Inject } from '@nestjs/common';
+import { ReleaseNoteService } from './release_note.service';
+import { Authenticated } from 'src/decorators/authentication.decorator';
+import { Language } from 'src/decorators/language.decorator';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+@Controller('release_note')
+@Authenticated()
+export class ReleaseNoteController {
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private readonly releaseNoteService: ReleaseNoteService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Get()
+  async getLatestReleaseNote(@Language() language: LanguageEnum) {
+    this.logger.info(`Fetching latest release note for language: ${language}`);
+    return await this.releaseNoteService.getLatestReleaseNote(language);
+  }
+}
@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ReleaseNoteService } from './release_note.service';
+import { ReleaseNoteController } from './release_note.controller';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+@Module({
+  controllers: [ReleaseNoteController],
+  providers: [ReleaseNoteService, DadosferaLogger]
+})
+export class ReleaseNoteModule {}
@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ReleaseNoteService } from './release_note.service';
+
+describe('ReleaseNoteService', () => {
+  let service: ReleaseNoteService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ReleaseNoteService],
+    }).compile();
+
+    service = module.get<ReleaseNoteService>(ReleaseNoteService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});
@@ -0,0 +1,46 @@
+import { Inject, Injectable } from '@nestjs/common';
+import axios, { AxiosInstance } from 'axios';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import { ReleaseNoteDTO } from './dto/release_note.dto';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+@Injectable()
+export class ReleaseNoteService {
+  client: AxiosInstance;
+    logger: DadosferaLogger;
+
+  constructor(
+        @Inject(DadosferaLogger)
+        dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+      this.client = axios.create({
+          baseURL: process.env.FIREBASE_BASE_URL,
+      });
+  }
+
+  async getLatestReleaseNote(lang: LanguageEnum) {
+    try {
+      const lng = lang.split('-');
+      const language = lng[0] + '-' + lng[1].toUpperCase();
+
+      const endpoint = `/release_note/${language}.json`;
+      const {
+        data,
+        status,
+        config
+      } = await this.client.get<ReleaseNoteDTO>(endpoint)
+      this.logger.info(`Fetched release note for language: ${lang} with status: ${status}`);
+      this.logger.info(`Request URL: ${config.baseURL}/${config.url}`);
+
+      return data;
+    } catch (error) {
+      this.logger.error(`Error fetching release note: ${error.message}`);
+
+      if (axios.isAxiosError(error)) {
+        this.logger.error(`Axios error details: ${error.toJSON()}`);
+      }
+    }
+
+  }
+}
@@ -229,27 +229,33 @@ export class RolesService {
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }
+
  getRolesPermissionsName(roles: GetRolesPermissionsName[]): RoleDto[] {
    const newRoles: RoleDto[] = [];
    for (const role of roles) {
-      const allPermissions = this.permissionsService.getAllPermissions(
-        this.language,
-      );
-      const newPermissions = role.permissions.map((p) => {
-        const permission = allPermissions.find((per) => per.seqid === p.seqid);
-        return {
-          ...p,
-          name: permission.name,
-          id: p.seqid,
-        };
-      });
-      const newRole: RoleDto = {
-        ...role,
-        permissions: newPermissions,
-        isPublic: role.isPublic,
-      };
+      const newRole: RoleDto = this.formatRole(role);
      newRoles.push(newRole);
    }
    return newRoles;
  }
+
+  private formatRole(role: GetRolesPermissionsName): RoleDto {
+    const allPermissions = this.permissionsService.getAllPermissions(
+      this.language
+    );
+    const newPermissions = role.permissions.map((p) => {
+      const permission = allPermissions.find((per) => per.seqid === p.seqid);
+      return {
+        ...p,
+        name: permission.name,
+        id: p.seqid,
+      };
+    });
+
+    return {
+      ...role,
+      permissions: newPermissions,
+      isPublic: role.isPublic,
+    };;
+  }
 }
@@ -0,0 +1,13 @@
+export const STORAGE_EXPLORER_CONFIG = {
+  getUrl: (customerName: string): string => {
+    const urlTemplate = process.env.STORAGE_EXPLORER_API_URL;
+    if (!urlTemplate) {
+      throw new Error('STORAGE_EXPLORER_API_URL environment variable is not set');
+    }
+    // Replace {customer_id} placeholder with actual customer ID
+    // For local: http://172.17.0.1:8000/api (no placeholder)
+    // For prod: https://storage-explorer-{customer_id}.dadosfera.ai/api
+    return urlTemplate.replace('{customer}', customerName);
+  },
+  timeout: parseInt(process.env.STORAGE_EXPLORER_TIMEOUT || '30000', 10),
+};
@@ -0,0 +1,383 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Param,
+  Body,
+  Query,
+  Inject,
+  UseInterceptors,
+  UploadedFiles,
+  Headers,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiConsumes } from '@nestjs/swagger';
+import { FilesInterceptor } from '@nestjs/platform-express';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import FormData from 'form-data';
+
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from '../../decorators/authentication.decorator';
+import { User, RequestUser } from '../../decorators/user.decorator';
+import { StorageExplorerService } from './storage-explorer.service';
+import { PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
+
+@ApiTags('Storage Explorer')
+@Controller('storage-explorer')
+@Authenticated()
+export class StorageExplorerController {
+  private logger: any;
+
+  constructor(
+    private readonly storageExplorerService: StorageExplorerService,
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  // ============================================
+  // TABLE OPERATIONS
+  // ============================================
+
+  @ApiOperation({ summary: 'Validate table name in PostgreSQL and Snowflake' })
+  @Post('tables/validate-name')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async validateTableName(
+    @Body() body: any,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'POST',
+      '/tables/validate-name',
+      user,
+      
+      body,
+    );
+  }
+
+  @ApiOperation({ summary: 'Create a new table' })
+  @Post('tables')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async createTable(
+    @Body() body: any,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'POST',
+      '/tables/',
+      user,
+      
+      body,
+    );
+  }
+
+  @ApiOperation({ summary: 'List all tables with pagination' })
+  @Get('tables')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async listTables(
+    @Query('page') page: number,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      '/tables/',
+      user,
+      
+      undefined,
+      { page },
+    );
+  }
+
+  @ApiOperation({ summary: 'Get table details by ID' })
+  @Get('tables/:tableId')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getTable(
+    @Param('tableId') tableId: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/tables/${tableId}`,
+      user,
+    );
+  }
+
+  @ApiOperation({ summary: 'Link a dataset to a table' })
+  @Post('tables/:tableId/datasets/:datasetId')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async linkDatasetToTable(
+    @Param('tableId') tableId: string,
+    @Param('datasetId') datasetId: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'POST',
+      `/tables/${tableId}/datasets/${datasetId}`,
+      user,
+      
+    );
+  }
+
+  @ApiOperation({ summary: 'Get all datasets linked to a table' })
+  @Get('tables/:tableId/datasets')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getTableDatasets(
+    @Param('tableId') tableId: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/tables/${tableId}/datasets`,
+      user,
+      
+    );
+  }
+
+  @ApiOperation({ summary: 'Get table schema' })
+  @Get('tables/:tableId/schema')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getTableSchema(
+    @Param('tableId') tableId: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/tables/${tableId}/schema`,
+      user,
+      
+    );
+  }
+
+  @ApiOperation({ summary: 'Validate schema compatibility between table and dataset' })
+  @Post('tables/:tableId/validate-compatibility/:datasetId')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async validateSchemaCompatibility(
+    @Param('tableId') tableId: string,
+    @Param('datasetId') datasetId: string,
+    @User() user: RequestUser,
+  ) {
+    return this.storageExplorerService.proxy(
+      'POST',
+      `/tables/${tableId}/validate-compatibility/${datasetId}`,
+      user,
+      
+    );
+  }
+
+  // ============================================
+  // DATASET OPERATIONS
+  // ============================================
+
+  @ApiOperation({ summary: 'Get dataset preview data' })
+  @Get('datasets/:datasetId/preview')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getDatasetPreview(
+    @Param('datasetId') datasetId: string,
+    @Query('limit') limit: number,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/datasets/${datasetId}/preview`,
+      user,
+      
+      undefined,
+      { limit },
+    );
+  }
+
+  @ApiOperation({ summary: 'Get dataset schema information' })
+  @Get('datasets/:datasetId/schema')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getDatasetSchema(
+    @Param('datasetId') datasetId: string,
+    @Query('force_refresh') forceRefresh: boolean,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/datasets/${datasetId}/schema`,
+      user,
+      
+      undefined,
+      { force_refresh: forceRefresh },
+    );
+  }
+
+  @ApiOperation({ summary: 'List all datasets for a specific upload' })
+  @Get('datasets/upload/:uploadId')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async listDatasetsByUpload(
+    @Param('uploadId') uploadId: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      `/datasets/upload/${uploadId}`,
+      user,
+      
+    );
+  }
+
+  @ApiOperation({ summary: 'Refresh dataset schema with new parsing options (Excel)' })
+  @Put('datasets/:datasetId/refresh-schema')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async refreshDatasetSchema(
+    @Param('datasetId') datasetId: string,
+    @Body() body: any,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'PUT',
+      `/datasets/${datasetId}/refresh-schema`,
+      user,
+      
+      body,
+    );
+  }
+
+  // ============================================
+  // STORAGE OPERATIONS
+  // ============================================
+
+  @ApiOperation({ summary: 'List file explorer uploads with pagination' })
+  @Get('storage/uploads/history')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async listFileExplorerUploads(
+    @Query('page') page: number,
+    @Query('limit') limit: number,
+    @Query('folder_path') folderPath: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      '/storage/uploads/history',
+      user,
+      
+      undefined,
+      { page, limit, folder_path: folderPath },
+    );
+  }
+
+  @ApiOperation({ summary: 'Browse folders and files in storage' })
+  @Get('storage/browse')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async browseStorage(
+    @Query('path') path: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      '/storage/browse',
+      user,
+      
+      undefined,
+      { path },
+    );
+  }
+
+  @ApiOperation({ summary: 'Upload multiple files to storage' })
+  @Post('storage/upload/batch')
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(FilesInterceptor('files'))
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async batchUpload(
+    @UploadedFiles() files: Array<Express.Multer.File>,
+    @Body('folder_path') folderPath: string,
+    @User() user: RequestUser,
+    
+  ) {
+    // Create FormData to forward files to storage-explorer API
+    const formData = new FormData();
+    
+    // Add files
+    if (files && files.length > 0) {
+      files.forEach((file) => {
+        formData.append('files', file.buffer, {
+          filename: file.originalname,
+          contentType: file.mimetype,
+        });
+      });
+    }
+    
+    // Add folder_path
+    if (folderPath) {
+      formData.append('folder_path', folderPath);
+    }
+
+    return this.storageExplorerService.proxyFormData(
+      'POST',
+      '/storage/upload/batch',
+      user,
+      
+      formData,
+    );
+  }
+
+  @ApiOperation({ summary: 'Create a new folder in storage' })
+  @Post('storage/folder/create')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.WRITE)
+  async createFolder(
+    @Body() body: any,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'POST',
+      '/storage/folder/create',
+      user,
+      
+      body,
+    );
+  }
+
+  @ApiOperation({ summary: 'Download a file from storage' })
+  @Get('storage/download')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async downloadFile(
+    @Query('file_path') filePath: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      '/storage/download',
+      user,
+      
+      undefined,
+      { file_path: filePath },
+    );
+  }
+
+  @ApiOperation({ summary: 'Get detailed file metadata' })
+  @Get('storage/metadata')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.STORAGE_EXPLORER.permissions.READ)
+  async getFileMetadata(
+    @Query('file_path') filePath: string,
+    @User() user: RequestUser,
+    
+  ) {
+    return this.storageExplorerService.proxy(
+      'GET',
+      '/storage/metadata',
+      user,
+      undefined,
+      { file_path: filePath },
+    );
+  }
+}
@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { StorageExplorerController } from './storage-explorer.controller';
+import { StorageExplorerService } from './storage-explorer.service';
+
+@Module({
+  imports: [],
+  controllers: [StorageExplorerController],
+  providers: [StorageExplorerService, DadosferaLogger],
+  exports: [StorageExplorerService],
+})
+export class StorageExplorerModule {}
@@ -0,0 +1,178 @@
+import { Injectable, Inject, HttpException } from '@nestjs/common';
+import axios, { AxiosResponse, Method } from 'axios';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { RequestUser } from '../../decorators/user.decorator';
+import { STORAGE_EXPLORER_CONFIG } from './storage-explorer.config';
+
+@Injectable()
+export class StorageExplorerService {
+  private logger: any;
+
+  constructor(
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  async proxy(
+    method: string,
+    path: string,
+    user: RequestUser,
+    body?: any,
+    query?: Record<string, any>
+  ): Promise<any> {
+    // Validate customer_id is present for multi-tenant isolation
+    if (!user.customer_id) {
+      throw new HttpException('Customer ID is required for storage operations', 400);
+    }
+
+    // Get customer-specific storage-explorer URL
+    const baseUrl = STORAGE_EXPLORER_CONFIG.getUrl(user.customer_name);
+    const url = new URL(`${baseUrl}${path}`);
+
+    // Add query params
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+
+    const headers: Record<string, string> = {
+      'content-type': 'application/json',
+    };
+
+    this.logger.info('Proxying request to storage-explorer', {
+      method: method.toUpperCase(),
+      path,
+      customer_id: user.customer_id,
+      storage_url: baseUrl,
+      user_id: user.user_id,
+    });
+
+    try {
+      const response: AxiosResponse = await axios({
+        method: method as Method,
+        url: url.href,
+        headers,
+        data: body,
+        timeout: STORAGE_EXPLORER_CONFIG.timeout,
+        validateStatus: () => true, // Don't throw on non-2xx
+      });
+
+      // Propagate non-2xx responses as HttpExceptions
+      if (response.status >= 400) {
+        throw new HttpException(response.data, response.status);
+      }
+
+      return response.data;
+    } catch (error) {
+      this.logger.error('Storage Explorer API proxy error', {
+        error: error.message,
+        status: error.response?.status,
+        path,
+        storage_url: baseUrl,
+        method: method.toUpperCase(),
+      });
+
+      if (error instanceof HttpException) {
+        throw error;
+      }
+
+      if (error.response) {
+        throw new HttpException(error.response.data, error.response.status);
+      }
+
+      if (error.code === 'ECONNREFUSED') {
+        throw new HttpException('Storage Explorer API service unavailable', 503);
+      }
+
+      if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+        throw new HttpException('Storage Explorer API request timeout', 504);
+      }
+
+      throw new HttpException('Internal server error', 500);
+    }
+  }
+
+  /**
+   * Proxy with file upload support (multipart/form-data)
+   */
+  async proxyFormData(
+    method: string,
+    path: string,
+    user: RequestUser,
+    formData: any,
+    query?: Record<string, any>,
+  ): Promise<any> {
+    // Validate customer_id is present for multi-tenant isolation
+    if (!user.customer_id) {
+      throw new HttpException('Customer ID is required for storage operations', 400);
+    }
+
+    // Get customer-specific storage-explorer URL
+    const baseUrl = STORAGE_EXPLORER_CONFIG.getUrl(user.customer_name);
+    const url = new URL(`${baseUrl}${path}`);
+
+    // Add query params
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+
+    const headers: Record<string, string> = {
+      // Let axios set Content-Type for multipart/form-data with boundary
+      ...formData.getHeaders?.(),
+    };
+
+    this.logger.info('Proxying form data request to storage-explorer', {
+      method: method.toUpperCase(),
+      path,
+      customer_id: user.customer_id,
+      storage_url: baseUrl,
+      user_id: user.user_id,
+    });
+
+    try {
+      const response: AxiosResponse = await axios({
+        method: method as Method,
+        url: url.href,
+        headers,
+        data: formData,
+        timeout: STORAGE_EXPLORER_CONFIG.timeout,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        validateStatus: () => true,
+      });
+
+      if (response.status >= 400) {
+        throw new HttpException(response.data, response.status);
+      }
+
+      return response.data;
+    } catch (error) {
+      this.logger.error('Storage Explorer API form data proxy error', {
+        error: error.message,
+        status: error.response?.status,
+        path,
+        storage_url: baseUrl,
+        method: method.toUpperCase(),
+      });
+
+      if (error instanceof HttpException) {
+        throw error;
+      }
+
+      if (error.response) {
+        throw new HttpException(error.response.data, error.response.status);
+      }
+
+      throw new HttpException('Internal server error', 500);
+    }
+  }
+}
@@ -124,4 +124,24 @@ export class ThemeController {
    }
  }

+  @Post('/:id/theme/reset')
+  @ApiOkResponse({ type: CustomerThemeResponse })
+  async resetTheme(@Param('id') id: string) {
+    this.logger.info('getCustomerTheme with id' + id);
+
+    try {
+      await this.themeService.resetTheme(id);
+
+      return { theme: null };
+    }catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND) {
+        this.logger.error('Error - getCustomerTheme - Expect CUSTOMER.NOT_FOUND');
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      } else {
+        this.logger.error('Error - getCustomerTheme Unknown Error:' + err?.message);
+        return { theme: null };
+      };
+    }
+  }
+
 }
@@ -44,6 +44,18 @@ export class ThemeService implements OnModuleInit {
    );
  }

+  async resetTheme(id: string) {
+    const { theme } = await firstValueFrom(
+      this.themeService.ResetCustomerTheme({
+        id
+      }),
+    );
+
+     return {
+      theme
+    }
+  }
+
  async createThemeByCustomer(id: string, theme: CustomerThemeRequest & Files) {
    if (!id) {
      this.logger.error('Error - saveCustomertheme - not found id:' + id);
@@ -1,5 +1,8 @@
-import { Info } from '@dadosfera/protospack/dist/lib/interfaces';
-
+export interface Info {
+  user_id: string;
+  customer_id: string;
+  customer: string;
+}
 export interface ICreateTransformationsRequest {
  transformations: Transformation[];
  info: Info;
@@ -38,6 +38,12 @@ export class User {
  department?: string;
  @ApiProperty()
  hierarchy?: string;
+  @ApiProperty()
+  bio?: string;
+  @ApiProperty()
+  companyName?: string;
+  @ApiProperty()
+  personalSite?: string;
  @ApiPropertyOptional()
  customer?: Customer;
  @ApiProperty()
@@ -58,6 +64,8 @@ export class UserNoRolesAndCustomer extends OmitType(UserNoRoles, [
 export class IUserByCustomer extends OmitType(User, ['customer']) {
  @ApiPropertyOptional()
  permissions?: string[];
+  @ApiPropertyOptional()
+  authProvider?: string;
 }

 export class CreateUserReq {
@@ -109,6 +117,12 @@ export class UpdateUserReq {
  @ApiPropertyOptional()
  hierarchy?: string;
  @ApiPropertyOptional()
+  bio?: string;
+  @ApiPropertyOptional()
+  personalSite?: string;
+  @ApiPropertyOptional()
+  companyName?: string;
+  @ApiPropertyOptional()
  roleNames?: string[];
 }

@@ -266,7 +266,6 @@ export class UsersController {
  }

  @Patch(':id')
-  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
  @ApiOkResponse({ type: UpdateUserRes })
  async updateUser(
    @User() user: RequestUser,
@@ -274,6 +273,18 @@ export class UsersController {
    @Param('id') id: string,
    @Language() language: LanguageEnum,
  ) {
+
+    const isSameUser = user.user_id === id;
+    const isSuperAdmin = user.permissions.includes(PERMISSIONS_GROUPS.USERS.permissions.ADMIN.seqid)
+    if (!isSameUser && !isSuperAdmin) {
+      throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
+    }
+
+    if (isSameUser && !isSuperAdmin && body.roleNames) {
+      // Prevent users from updating their own roles
+      delete body.roleNames;
+    }
+
    this.logger.info('updateUser', { user });
    this.userService.setLanguage(language);
    return await this.userService.updateUser(body, id, user.customer_id);
@@ -125,6 +125,7 @@ export class UsersService implements OnModuleInit {
      return { permissions };
    });
    res.user.permissions = permissions;
+    res.user.authProvider = process.env.AUTH_PROVIDER || 'cognito';
    return res;
  }

@@ -148,20 +149,23 @@ export class UsersService implements OnModuleInit {
  }

  async updateUser(req: UpdateUserReq, id: string, customerId: string) {
-    const { department, hierarchy, jobTitle, name, roleNames, email } = req;
-    if (roleNames) {
+    const { roleNames, ...updateUserDTO } = req;
+    if (roleNames && roleNames.length > 0) {
      await this.setRoles({ roleNames, userId: id }, customerId);
    }

    const { user } = await lastValueFrom(
      this.usersClientService.UserUpdate({
-        name,
+        department: updateUserDTO.department,
+        email: updateUserDTO.email,
+        hierarchy: updateUserDTO.hierarchy,
+        jobTitle: updateUserDTO.jobTitle,
+        name: updateUserDTO.name,
+        bio: updateUserDTO.bio,
+        companyName: updateUserDTO.companyName,
+        personalSite: updateUserDTO.personalSite,
        customerId,
        id,
-        department,
-        hierarchy,
-        jobTitle,
-        email,
        metabaseUserId: undefined,
      }),
    );
@@ -14,7 +14,10 @@ export class ValidationPipe implements PipeTransform<any> {
      return value;
    }
    const object = plainToInstance(metatype, value);
-    const errors = await validate(object);
+    const errors = await validate(object, {
+      forbidUnknownValues: false,
+      whitelist: true,
+    });
    if (errors.length > 0) {
      const errorMessages = errors.map((err) => err.constraints);
      throw new BadRequestException(errorMessages);
@@ -0,0 +1,4 @@
+export const DYNAMODB_CONFIG = {
+  region: () => process.env.AWS_REGION || 'us-east-1',
+  inputsTable: () => process.env.INPUTS_DB || 'dadosfera-inputs-prd',
+};
@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { DynamoDBService } from './dynamodb.service';
+
+@Module({
+  providers: [DynamoDBService, DadosferaLogger],
+  exports: [DynamoDBService],
+})
+export class DynamoDBModule {}
@@ -0,0 +1,238 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  DeleteCommand,
+  TranslateConfig,
+} from '@aws-sdk/lib-dynamodb';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { v4 as uuid } from 'uuid';
+import { DYNAMODB_CONFIG } from './dynamodb.config';
+
+export interface ReferenceColumn {
+  name: string;
+  type: string;
+}
+
+export interface InputDocument {
+  id: string;
+  client_id: string;
+  user_id: string;
+  created_at: string;
+  name: string;
+  description?: string;
+  plugin: string;
+  type: string;
+  tables?: Array<{
+    name: string;
+    type: string;
+    columns?: string[];
+    reference_column?: ReferenceColumn;
+  }>;
+  credentials?: Record<string, any>;
+}
+
+@Injectable()
+export class DynamoDBService {
+  private documentClient: DynamoDBDocumentClient;
+  private logger: any;
+
+  constructor(
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+
+    const dynamoConfig = { region: DYNAMODB_CONFIG.region() };
+    const marshallOptions: TranslateConfig = {
+      marshallOptions: {
+        removeUndefinedValues: true,
+      },
+    };
+
+    const dynamoDb = new DynamoDBClient(dynamoConfig);
+    this.documentClient = DynamoDBDocumentClient.from(dynamoDb, marshallOptions);
+  }
+
+  async createInput(
+    clientId: string,
+    userId: string,
+    data: {
+      name: string;
+      description?: string;
+      plugin: string;
+      type: string;
+      tables?: Array<{
+        name: string;
+        type: string;
+        columns?: string[];
+        reference_column?: ReferenceColumn;
+      }>;
+    },
+  ): Promise<InputDocument> {
+    const tableName = DYNAMODB_CONFIG.inputsTable();
+    const id = uuid();
+    const created_at = new Date().toISOString();
+
+    const item: InputDocument = {
+      id,
+      client_id: clientId,
+      user_id: userId,
+      created_at,
+      name: data.name,
+      description: data.description,
+      plugin: data.plugin,
+      type: data.type,
+      tables: data.tables,
+    };
+
+    this.logger.info('DynamoDB: Creating input', {
+      tableName,
+      inputId: id,
+      plugin: data.plugin,
+    });
+
+    const putCommand = new PutCommand({
+      TableName: tableName,
+      Item: item,
+    });
+
+    try {
+      await this.documentClient.send(putCommand);
+      this.logger.info('DynamoDB: Input created successfully', { inputId: id });
+      return item;
+    } catch (error) {
+      this.logger.error('DynamoDB: Failed to create input', {
+        tableName,
+        inputId: id,
+        region: DYNAMODB_CONFIG.region(),
+        error: error.message,
+        errorName: error.name,
+      });
+      throw error;
+    }
+  }
+
+  async findInput(clientId: string, inputId: string): Promise<InputDocument | null> {
+    const tableName = DYNAMODB_CONFIG.inputsTable();
+
+    const getCommand = new GetCommand({
+      TableName: tableName,
+      Key: {
+        id: inputId,
+        client_id: clientId,
+      },
+    });
+
+    try {
+      const { Item } = await this.documentClient.send(getCommand);
+      return Item as InputDocument | null;
+    } catch (error) {
+      this.logger.error('DynamoDB: findInput failed', { inputId, clientId, error: error.message });
+      throw error;
+    }
+  }
+
+  async deleteInput(clientId: string, inputId: string): Promise<void> {
+    const tableName = DYNAMODB_CONFIG.inputsTable();
+
+    this.logger.info('DynamoDB: Deleting input', {
+      tableName,
+      inputId,
+    });
+
+    const deleteCommand = new DeleteCommand({
+      TableName: tableName,
+      Key: {
+        id: inputId,
+        client_id: clientId,
+      },
+    });
+
+    await this.documentClient.send(deleteCommand);
+
+    this.logger.info('DynamoDB: Input deleted successfully', { inputId });
+  }
+
+  /**
+   * Update a specific table entry in the input document.
+   * Fetches the current document, updates the matching table, and saves.
+   */
+  async updateInputTable(
+    clientId: string,
+    inputId: string,
+    tableName: string,
+    changes: {
+      type?: string;
+      columns?: string[];
+      reference_column?: ReferenceColumn | null;
+    },
+  ): Promise<void> {
+    const dynamoTableName = DYNAMODB_CONFIG.inputsTable();
+
+    this.logger.info('DynamoDB: Updating input table', {
+      inputId,
+      tableName,
+      changes: Object.keys(changes),
+    });
+
+    // Get current document
+    const current = await this.findInput(clientId, inputId);
+    if (!current) {
+      this.logger.warn('DynamoDB: Input not found for update', { inputId });
+      return;
+    }
+
+    // Find and update the matching table
+    const tables = current.tables || [];
+    const tableIndex = tables.findIndex((t) => t.name === tableName);
+
+    if (tableIndex === -1) {
+      this.logger.warn('DynamoDB: Table not found in input', {
+        inputId,
+        tableName,
+      });
+      return;
+    }
+
+    // Merge changes into the table entry
+    const updatedTable = { ...tables[tableIndex] };
+    if ('type' in changes) updatedTable.type = changes.type;
+    if ('columns' in changes) updatedTable.columns = changes.columns;
+    if ('reference_column' in changes) {
+      if (changes.reference_column === null) {
+        delete updatedTable.reference_column;
+      } else {
+        updatedTable.reference_column = changes.reference_column;
+      }
+    }
+    tables[tableIndex] = updatedTable;
+
+    // Save updated document
+    const putCommand = new PutCommand({
+      TableName: dynamoTableName,
+      Item: {
+        ...current,
+        tables,
+        updated_at: new Date().toISOString(),
+      },
+    });
+
+    try {
+      await this.documentClient.send(putCommand);
+      this.logger.info('DynamoDB: Input table updated successfully', {
+        inputId,
+        tableName,
+      });
+    } catch (error) {
+      this.logger.error('DynamoDB: Failed to update input table', {
+        inputId,
+        tableName,
+        error: error.message,
+      });
+      throw error;
+    }
+  }
+
+}
@@ -0,0 +1,3 @@
+export * from './dynamodb.service';
+export * from './dynamodb.module';
+export * from './dynamodb.config';
@@ -0,0 +1,5 @@
+export const ELASTICSEARCH_CONFIG = {
+  getUrl: () => process.env.ELASTICSEARCH_URL || 'http://localhost:9200',
+  getApiKey: () => process.env.ELASTICSEARCH_API_KEY || '',
+  timeout: 10000, // 10 seconds
+};
@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ElasticsearchService } from './elasticsearch.service';
+
+@Module({
+  providers: [ElasticsearchService, DadosferaLogger],
+  exports: [ElasticsearchService],
+})
+export class ElasticsearchModule {}
@@ -0,0 +1,457 @@
+import { Injectable, Inject } from '@nestjs/common';
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ELASTICSEARCH_CONFIG } from './elasticsearch.config';
+
+interface MultiLang {
+  'en-us': string;
+  'pt-br': string;
+  'es-es': string;
+}
+
+interface MultiLangArray {
+  'en-us': string[];
+  'pt-br': string[];
+  'es-es': string[];
+}
+
+interface ConnectorInfo {
+  plugin: string;
+  name: MultiLang;
+  image: string;
+  version: string;
+  tags: string[];
+}
+
+interface PipelineDocument {
+  id: string;
+  name: MultiLang;
+  description: MultiLang;
+  customer_id: string;
+  user_id: string;
+  username: string;
+  status: string;
+  created_at: string;
+  updated_at: string;
+  last_status_updated: string;
+  tags: string[];
+  // Connector metadata
+  connection_id: string;
+  connector_name: string;
+  connector_plugin: string;
+  connector_version: string;
+  image_url: string;
+  // Config
+  config: {
+    cron: string;
+    tables?: string;
+  };
+  properties: string;
+  type: string;
+  in_use: number;
+  keywords: MultiLangArray;
+}
+
+@Injectable()
+export class ElasticsearchService {
+  private client: AxiosInstance;
+  private logger: any;
+
+  constructor(
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+    this.client = axios.create({
+      baseURL: ELASTICSEARCH_CONFIG.getUrl(),
+      headers: {
+        Authorization: `ApiKey ${ELASTICSEARCH_CONFIG.getApiKey()}`,
+        'Content-Type': 'application/json',
+      },
+      timeout: ELASTICSEARCH_CONFIG.timeout,
+    });
+  }
+
+  private getIndex(customerName: string): string {
+    return `${customerName}_pipelines`;
+  }
+
+  private formatMultiLang(value: string): MultiLang {
+    return {
+      'en-us': value,
+      'pt-br': value,
+      'es-es': value,
+    };
+  }
+
+  private formatMultiLangArray(value: string[] = []): MultiLangArray {
+    return {
+      'en-us': value,
+      'pt-br': value,
+      'es-es': value,
+    };
+  }
+
+  buildPipelineDocument(
+    pipelineId: string,
+    data: {
+      name: string;
+      description?: string;
+      user_id: string;
+      username: string;
+      customer_id: string;
+      plugin: string;
+      connection_id: string;
+      cron?: string;
+      tables?: string;
+      properties?: Record<string, any>;
+      type?: string;
+      status?: string;
+      created_at?: string;
+      keywords?: string[];
+    },
+    connector: ConnectorInfo | null,
+  ): PipelineDocument {
+    const now = new Date().toISOString();
+
+    return {
+      id: pipelineId,
+      connection_id: data.connection_id,
+      connector_name: connector?.name?.['en-us'] || '',
+      connector_plugin: connector?.plugin || data.plugin,
+      connector_version: connector?.version || '1.0.0',
+      created_at: data.created_at || now,
+      updated_at: now,
+      customer_id: data.customer_id,
+      description: this.formatMultiLang(data.description || ''),
+      image_url: connector?.image || '',
+      keywords: this.formatMultiLangArray(data.keywords),
+      name: this.formatMultiLang(data.name || ''),
+      status: data.status || 'CREATED',
+      user_id: data.user_id,
+      username: data.username,
+      config: {
+        cron: data.cron,
+        tables: data.tables,
+      },
+      properties: data.properties ? JSON.stringify(data.properties) : '{}',
+      type: data.type,
+      in_use: 1,
+      last_status_updated: now,
+      tags: connector?.tags || [],
+    };
+  }
+
+  async getConnectorByPlugin(plugin: string): Promise<ConnectorInfo | null> {
+    this.logger.info('Elasticsearch: Looking up connector', { plugin });
+
+    try {
+      const response = await this.client.post('/connectors/_search', {
+        query: {
+          term: { plugin: plugin },
+        },
+        size: 1,
+      });
+
+      const hits = response.data.hits?.hits || [];
+      if (hits.length === 0) {
+        this.logger.warn('Elasticsearch: Connector not found', { plugin });
+        return null;
+      }
+
+      const source = hits[0]._source;
+      return {
+        plugin: source.plugin,
+        name: source.name,
+        image: source.image,
+        version: source.version,
+        tags: source.tags || [],
+      };
+    } catch (error) {
+      this.handleError('getConnectorByPlugin', error, { plugin });
+      return null;
+    }
+  }
+
+  async createPipeline(
+    customerName: string,
+    pipelineId: string,
+    data: {
+      name: string;
+      description?: string;
+      user_id: string;
+      username: string;
+      customer_id: string;
+      status?: string;
+      created_at?: string;
+      plugin: string;
+      connection_id: string;
+      cron?: string;
+      tables?: string;
+      properties?: Record<string, any>;
+      type?: string;
+    },
+    connector: ConnectorInfo | null,
+  ): Promise<any> {
+    const index = this.getIndex(customerName);
+    const document = this.buildPipelineDocument(pipelineId, data, connector);
+
+    this.logger.info('Elasticsearch: Creating pipeline', {
+      index,
+      pipelineId,
+      plugin: document.connector_plugin,
+    });
+
+    try {
+      const response = await this.client.post(
+        `${index}/_doc/${pipelineId}`,
+        document,
+        { params: { refresh: 'wait_for' } },
+      );
+
+      this.logger.info('Elasticsearch: Pipeline created successfully', {
+        pipelineId,
+        result: response.data.result,
+      });
+
+      return response.data;
+    } catch (error) {
+      this.handleError('createPipeline', error, { pipelineId, index });
+      throw error;
+    }
+  }
+
+  async updatePipeline(
+    customerName: string,
+    pipelineId: string,
+    changes: {
+      name?: string;
+      description?: string;
+      cron?: string;
+      status?: string;
+      tags?: string[];
+    },
+  ): Promise<any> {
+    const index = this.getIndex(customerName);
+    const now = new Date().toISOString();
+
+    this.logger.info('Elasticsearch: Updating pipeline', {
+      index,
+      pipelineId,
+      fields: Object.keys(changes),
+    });
+
+    try {
+      // Fetch current document
+      const currentDoc = await this.client.get(`${index}/_doc/${pipelineId}`);
+      const current = currentDoc.data._source;
+
+      // Build updated document, preserving existing values
+      const updated: Record<string, any> = {
+        ...current,
+        updated_at: now,
+      };
+
+      if ('name' in changes) {
+        updated.name = this.formatMultiLang(changes.name);
+      }
+
+      if ('description' in changes) {
+        updated.description = this.formatMultiLang(changes.description);
+      }
+
+      if ('cron' in changes) {
+        updated.config = {
+          ...current.config,
+          cron: changes.cron,
+        };
+      }
+
+      if ('status' in changes) {
+        updated.status = changes.status;
+        updated.last_status_updated = now;
+      }
+
+      if ('tags' in changes) {
+        updated.tags = changes.tags;
+      }
+
+      const response = await this.client.post(
+        `${index}/_doc/${pipelineId}`,
+        updated,
+        { params: { refresh: 'wait_for' } },
+      );
+
+      this.logger.info('Elasticsearch: Pipeline updated successfully', {
+        pipelineId,
+        result: response.data.result,
+      });
+
+      return response.data;
+    } catch (error) {
+      this.handleError('updatePipeline', error, { pipelineId, index });
+      throw error;
+    }
+  }
+
+  async getPipeline(
+    customerName: string,
+    pipelineId: string,
+  ): Promise<PipelineDocument | null> {
+    const index = this.getIndex(customerName);
+
+    this.logger.info('Elasticsearch: Getting pipeline', {
+      index,
+      pipelineId,
+    });
+
+    try {
+      const response = await this.client.get(`${index}/_doc/${pipelineId}`);
+      return response.data._source as PipelineDocument;
+    } catch (error) {
+      if (error instanceof AxiosError && error.response?.status === 404) {
+        this.logger.warn('Elasticsearch: Pipeline not found', {
+          pipelineId,
+          index,
+        });
+        return null;
+      }
+      this.handleError('getPipeline', error, { pipelineId, index });
+      throw error;
+    }
+  }
+
+  async deletePipeline(
+    customerName: string,
+    pipelineId: string,
+  ): Promise<any> {
+    const index = this.getIndex(customerName);
+
+    this.logger.info('Elasticsearch: Deleting pipeline', {
+      index,
+      pipelineId,
+    });
+
+    try {
+      const response = await this.client.delete(
+        `${index}/_doc/${pipelineId}`,
+        { params: { refresh: 'wait_for' } },
+      );
+
+      this.logger.info('Elasticsearch: Pipeline deleted successfully', {
+        pipelineId,
+        result: response.data.result,
+      });
+
+      return response.data;
+    } catch (error) {
+      // If document not found, log warning but don't throw
+      if (error instanceof AxiosError && error.response?.status === 404) {
+        this.logger.warn('Elasticsearch: Pipeline not found for deletion', {
+          pipelineId,
+          index,
+        });
+        return { result: 'not_found' };
+      }
+
+      this.handleError('deletePipeline', error, { pipelineId, index });
+      throw error;
+    }
+  }
+
+  private getDataAssetIndex(customerName: string): string {
+    return `${customerName}_data_assets_catalog`;
+  }
+
+  async findDataAssetByTable(
+    customerName: string,
+    tableName: string,
+    tableSchema: string,
+  ): Promise<{ id: string; nimbus_id: number | null; [key: string]: any } | null> {
+    const index = this.getDataAssetIndex(customerName);
+
+    this.logger.info('Elasticsearch: Searching data asset', {
+      index,
+      tableName,
+      tableSchema,
+    });
+
+    try {
+      const response = await this.client.post(`/${index}/_search`, {
+        query: {
+          bool: {
+            must: [
+              { term: { 'table_name.keyword': tableName.toUpperCase() } },
+              { term: { 'table_schema.keyword': tableSchema.toUpperCase() } },
+            ],
+          },
+        },
+        size: 1,
+      });
+
+      const hits = response.data.hits?.hits || [];
+      if (hits.length === 0) {
+        this.logger.warn('Elasticsearch: Data asset not found', { tableName, tableSchema, index });
+        return null;
+      }
+
+      return { ...hits[0]._source, _es_id: hits[0]._id };
+    } catch (error) {
+      this.handleError('findDataAssetByTable', error, { tableName, tableSchema, index });
+      throw error;
+    }
+  }
+
+  async updateDataAsset(
+    customerName: string,
+    assetId: string,
+    updates: Record<string, any>,
+  ): Promise<any> {
+    const index = this.getDataAssetIndex(customerName);
+
+    this.logger.info('Elasticsearch: Updating data asset', {
+      index,
+      assetId,
+      fields: Object.keys(updates),
+    });
+
+    try {
+      const response = await this.client.post(
+        `/${index}/_update/${assetId}`,
+        { doc: updates },
+        { params: { refresh: 'wait_for' } },
+      );
+
+      this.logger.info('Elasticsearch: Data asset updated', {
+        assetId,
+        result: response.data.result,
+      });
+
+      return response.data;
+    } catch (error) {
+      this.handleError('updateDataAsset', error, { assetId, index });
+      throw error;
+    }
+  }
+
+  private handleError(
+    operation: string,
+    error: any,
+    context: Record<string, any>,
+  ): void {
+    if (error instanceof AxiosError) {
+      this.logger.error(`Elasticsearch: ${operation} failed`, {
+        ...context,
+        status: error.response?.status,
+        statusText: error.response?.statusText,
+        errorData: error.response?.data,
+        message: error.message,
+      });
+    } else {
+      this.logger.error(`Elasticsearch: ${operation} failed`, {
+        ...context,
+        message: error.message,
+        stack: error.stack,
+      });
+    }
+  }
+}
--- a/Show More
+++ b/Show More