Merge pull request #510 from dadosfera/feature/cdc-connector

Feature/cdc connector

.dockerignore

@@ -0,0 +1,12 @@
+node_modules
+dist
+.git
+*.log
+npm-debug.log*
+.DS_Store
+.env
+.env.*
+coverage
+.nyc_output
+*.tgz
+!protospack.tgz

.eslintrc.js

@@ -8,7 +8,7 @@ module.exports = {
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
-    'plugin:prettier/recommended',
+    'prettier',
   ],
   root: true,
   env: {

.github/workflows/deploy-manually.yml

@@ -3,6 +3,7 @@ on:
   push:
     branches:
       - main
+      - beta
   workflow_dispatch:
     inputs:
       environment:
@@ -10,7 +11,6 @@ on:
         required: true
         type: choice
         options:
-          - dev
           - stg
           - prd
 
@@ -29,6 +29,8 @@ jobs:
             echo "environment=${DEPLOY_ENV}" >> $GITHUB_OUTPUT
           elif [ ${GITHUB_REF} == "refs/heads/main" ]; then
             echo "environment=prd" >> $GITHUB_OUTPUT
+          elif [ ${GITHUB_REF} == "refs/heads/beta" ]; then
+            echo "environment=stg" >> $GITHUB_OUTPUT
           fi
         id: extract_environment
 
@@ -39,54 +41,51 @@ jobs:
       new_release_version: ${{ (steps.semantic.outputs.new_release_published == 'true' && steps.semantic.outputs.new_release_version) || (github.event_name == 'workflow_dispatch' && '0.0.0') }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - if: github.event_name != 'workflow_dispatch'
         name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v2
+        uses: cycjimmy/semantic-release-action@v3
         id: semantic
         with:
-          semantic_version: 16
           extra_plugins: |
-            conventional-changelog-eslint
+            conventional-changelog-eslint@4.0.0
           branches: |
             [
-              'main'
+              'main',
+              {
+                name: 'alpha',
+                prerelease: true
+              },
+              {
+                name: 'beta',
+                prerelease: true
+              }
             ]
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  deploy-info:
-    if: ${{ github.event_name == 'workflow_dispatch'}}
+  build_ecr_image:
+    if: ${{ github.event_name == 'workflow_dispatch' || needs.semantic_release.outputs.new_release_published == 'true' }}
     needs: [extract_environment, semantic_release]
-    runs-on: ubuntu-latest
+    runs-on:
+      [self-hosted, "prd"]
 
     steps:
-      - name: Create summary
+      - name: Printing stats
         env:
           EVENT: ${{ github.event_name }}
           IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
           ENV: ${{ needs.extract_environment.outputs.environment }}
-        run: echo "### Deploy da branch \`$GITHUB_REF_NAME\` no ambiente **$ENV** :rocket:" >> $GITHUB_STEP_SUMMARY
+        run: echo ${GITHUB_REF#refs/heads/}
 
-  deploy:
-    if: ${{ github.event_name == 'workflow_dispatch' || needs.semantic_release.outputs.new_release_published == 'true' }}
-    needs: [extract_environment, semantic_release]
-    runs-on:
-      [self-hosted, "${{ needs.extract_environment.outputs.environment }}"]
-
-    steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Update Pip
         run: |
           python3 -m pip install --upgrade pip
 
-      - name: Install Docker Compose
-        run: |
-          python3 -m pip install docker-compose --upgrade
-
       - name: Install AWS CLI
         run: |
           python3 -m pip install awscli --upgrade
@@ -96,14 +95,14 @@ jobs:
           python3 -m pip install awsebcli --upgrade
 
       - name: Configure AWS Region
-        uses: aws-actions/configure-aws-credentials@v1-node16
+        uses: aws-actions/configure-aws-credentials@v4
         id: aws
         with:
           aws-region: us-east-1
 
       - name: Login to AWS ECR
         id: login_ecr
-        uses: aws-actions/amazon-ecr-login@v1
+        uses: aws-actions/amazon-ecr-login@v2
 
       - name: Build, Tag, and Push Image to AWS ECR
         env:
@@ -111,80 +110,43 @@ jobs:
           IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
           ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
         run: |
-          docker-compose -f build.docker-compose.yml build
-          docker-compose -f build.docker-compose.yml push
+          docker compose -f build.docker-compose.yml build
+          docker compose -f build.docker-compose.yml push
 
-      - name: Create ZIP file to Deploy AWS Beanstalk
-        env:
-          ENV: ${{ needs.extract_environment.outputs.environment }}
-          IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
-          ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
-          NODE_EXPORTER_URL: ${{needs.extract_environment.outputs.environment == 'prd' && '611330257153.dkr.ecr.us-east-1.amazonaws.com\/monitoring\/node_exporter:latest' || '468720548566.dkr.ecr.us-east-1.amazonaws.com\/monitoring\/node_exporter:latest'}}
-        run: |
-          sed -i -e "s/\${ENV}/$ENV/g" docker-compose.yml
-          sed -i -e "s/\${IMAGE_TAG}/$IMAGE_TAG/g" docker-compose.yml
-          sed -i -e "s/\${ACCOUNT_ID}/$ACCOUNT_ID/g" docker-compose.yml
-          sed -i -e "s/\${NODE_EXPORTER_URL}/$NODE_EXPORTER_URL/g" docker-compose.yml
-          zip deploy.zip docker-compose.yml  -r .ebextensions
+      # - name: Create ZIP file to Deploy AWS Beanstalk
+      #   env:
+      #     ENV: ${{ needs.extract_environment.outputs.environment }}
+      #     IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
+      #     ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
+      #     NODE_EXPORTER_URL: ${{needs.extract_environment.outputs.environment == 'prd' && '611330257153.dkr.ecr.us-east-1.amazonaws.com\/monitoring\/node_exporter:latest' || '468720548566.dkr.ecr.us-east-1.amazonaws.com\/monitoring\/node_exporter:latest'}}
+      #   run: |
+      #     sed -i -e "s/\${ENV}/$ENV/g" docker-compose.yml
+      #     sed -i -e "s/\${IMAGE_TAG}/$IMAGE_TAG/g" docker-compose.yml
+      #     sed -i -e "s/\${ACCOUNT_ID}/$ACCOUNT_ID/g" docker-compose.yml
+      #     sed -i -e "s/\${NODE_EXPORTER_URL}/$NODE_EXPORTER_URL/g" docker-compose.yml
+      #     zip deploy.zip docker-compose.yml  -r .ebextensions
 
-      - name: Deploy AWS Beanstalk
-        env:
-          ENV: ${{ needs.extract_environment.outputs.environment }}
-          AWS_REGION: us-east-1
-          APP_NAME: ${{ github.event.repository.name }}
-        run: |
-          eb use $APP_NAME-$ENV
-          echo -e "deploy:\n  artifact: deploy.zip" >> .elasticbeanstalk/config.yml
-          eb deploy
+      # - name: Deploy AWS Beanstalk
+      #   env:
+      #     ENV: ${{ needs.extract_environment.outputs.environment }}
+      #     AWS_REGION: us-east-1
+      #     APP_NAME: ${{ github.event.repository.name }}
+      #   run: |
+      #     eb use $APP_NAME-$ENV
+      #     echo -e "deploy:\n  artifact: deploy.zip" >> .elasticbeanstalk/config.yml
+      #     eb deploy
 
       - name: Remove Docker's Trash
         if: always()
         run: |
           docker system prune --volumes -a -f
           docker system df
-  api_docs:
-    needs: [extract_environment, semantic_release, deploy]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
 
-      - name: Extract Docs BlockId and PageId
-        env:
-          ENV: ${{ needs.extract_environment.outputs.environment }}
-          DEV_DOCS_BLOCK_ID: ${{ secrets.DEV_DOCS_BLOCK_ID }}
-          DEV_DOCS_PAGE_ID: ${{ secrets.DEV_DOCS_PAGE_ID }}
-          STG_DOCS_BLOCK_ID: ${{ secrets.STG_DOCS_BLOCK_ID }}
-          STG_DOCS_PAGE_ID: ${{ secrets.STG_DOCS_PAGE_ID }}
-          PRD_DOCS_BLOCK_ID: ${{ secrets.PRD_DOCS_BLOCK_ID }}
-          PRD_DOCS_PAGE_ID: ${{ secrets.PRD_DOCS_PAGE_ID }}
-        shell: bash
-        run: |
-          if [ $ENV == "dev" ]; then
-            echo "block_id=$DEV_DOCS_BLOCK_ID" >> $GITHUB_OUTPUT
-            echo "page_id=$DEV_DOCS_PAGE_ID" >> $GITHUB_OUTPUT
-          elif [ $ENV == "stg" ]; then
-            echo "block_id=$STG_DOCS_BLOCK_ID" >> $GITHUB_OUTPUT
-            echo "page_id=$STG_DOCS_PAGE_ID" >> $GITHUB_OUTPUT
-          elif [ $ENV == "prd" ]; then
-            echo "block_id=$PRD_DOCS_BLOCK_ID" >> $GITHUB_OUTPUT
-            echo "page_id=$PRD_DOCS_PAGE_ID" >> $GITHUB_OUTPUT
-          fi
-        id: extract_docs_info
-
-      - name: Generate API docs
-        env:
-          DOCS_URL: ${{ secrets.DOCS_URL }}
-          DOCS_API_TOKEN: ${{ secrets.DOCS_API_TOKEN }}
-          DOCS_PAGE_ID: ${{ steps.extract_docs_info.outputs.page_id }}
-          DOCS_BLOCK_ID: ${{ steps.extract_docs_info.outputs.block_id }}
-          EVENT: ${{ github.event_name }}
-          RELEASE_VERSION: ${{ needs.semantic_release.outputs.new_release_version }}
-        run: |
-          if [ ${EVENT} != "workflow_dispatch" ]; then
-            sed -i -E "s/(\"title\": )\"Maestro.+\"/\1\"Maestro - $RELEASE_VERSION\"/g" docsfera.json
-          fi
-          sed -i -e "s/\${DOCS_API_TOKEN}/$DOCS_API_TOKEN/g" docsfera.json
-          sed -i -e "s/\${DOCS_PAGE_ID}/$DOCS_PAGE_ID/g" docsfera.json
-          sed -i -e "s/\${DOCS_BLOCK_ID}/$DOCS_BLOCK_ID/g" docsfera.json
-          curl -X POST -H 'Content-Type: application/json' -d @docsfera.json $DOCS_URL
+  k8s-deploy:
+    needs: [extract_environment, semantic_release, build_ecr_image]
+    uses: ./.github/workflows/k8s-deploy.yml
+    with:
+      cloud: 'oracle'
+      environment: ${{ needs.extract_environment.outputs.environment }}
+      image: ${{ needs.semantic_release.outputs.new_release_version }}
+    secrets: inherit

.github/workflows/k8s-deploy.yml

@@ -0,0 +1,137 @@
+name : K8s deploy
+
+on:
+  workflow_call:
+    inputs:
+      cloud:
+        description: "Cloud provider for the deployment"
+        required: true
+        default: "azure"
+        type: string
+      environment:
+        description: "Deployment environment"
+        required: true
+        default: "prd"
+        type: string
+      image:
+        description: "Image Tag"
+        required: true
+        type: string
+
+jobs:
+  azure:
+    if: inputs.cloud == 'azure'
+    runs-on: [self-hosted, "prd-azure"]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v1
+        with:
+          version: 'v3.9.0'
+
+      - name: Install Azure ClI
+        run: |
+          curl -sL https://aka.ms/InstallAzureCLIDeb | bash
+
+      - uses: azure/login@v2
+        with:
+          creds: '{"clientId":"${{ secrets.ARM_CLIENT_ID }}","clientSecret":"${{ secrets.ARM_CLIENT_SECRET }}","subscriptionId":"${{ secrets.ARM_SUBSCRIPTION_ID }}","tenantId":"${{ secrets.ARM_TENANT_ID }}"}'
+
+      - name: Authenticate with cluster
+        env:
+          CLUSTER_NAME: platform-${{ inputs.environment }}
+        run: az aks get-credentials --resource-group dadosfera-prd --name ${CLUSTER_NAME} --overwrite-existing
+      
+      - name: Setup kubectl
+        uses: azure/setup-kubectl@v1
+        with:
+          version: 'v1.30.1'
+      
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+
+      - name: Install Helmfile
+        run: |
+          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: Run Helmfile Apply
+        env:
+          ENV: ${{ inputs.environment }}
+          IMAGE_TAG: ${{ inputs.image }}
+        run: helmfile -f deploy/helmfiles/${ENV}.yaml sync --set image.tag=$IMAGE_TAG
+
+  oracle:
+    if: inputs.cloud == 'oracle'
+    runs-on: [self-hosted, "prd-oracle"]
+    env:
+      HOME: /home/runner
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v1
+        with:
+          version: 'v3.9.0'
+
+      - name: Install OCI CLI
+        env:
+          HOME: /home/runner
+        run: |
+          bash -c "$(curl -L https://raw.githubusercontent.com/oracle/oci-cli/master/scripts/install/install.sh)" -- --accept-all-defaults
+          echo "$HOME/bin" >> $GITHUB_PATH
+
+      - name: Configure OCI CLI
+        run: |
+          mkdir -p ~/.oci || true
+          echo "${{ secrets.OCI_CONFIG }}" > ~/.oci/config
+          echo "${{ secrets.OCI_PRIVATE_KEY }}" > ~/.oci/oci_api_key.pem 
+          chmod 600 ~/.oci/oci_api_key.pem
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+
+      - name: Install Helmfile
+        run: |
+          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: Authenticate with OKE cluster
+        env:
+          ENV: ${{ inputs.environment }}
+          STG_CLUSTER_ID: "ocid1.cluster.oc1.sa-saopaulo-1.aaaaaaaagh3jvln52a3ebm3dodx6emmhv5bmfs7i7sv2k4zkbcbrzcl6v37q"
+          PRD_CLUSTER_ID: "ocid1.cluster.oc1.sa-saopaulo-1.aaaaaaaanf3vptl6hc2tzd4enfd2hfpsht3wikxww5xejc3l7cwfm6l3sndq"
+        run: |
+          if [ "$ENV" = "stg" ]; then
+            CLUSTER_ID=$STG_CLUSTER_ID
+          elif [ "$ENV" = "prd" ]; then
+            CLUSTER_ID=$PRD_CLUSTER_ID
+          else
+            echo "Unknown environment: $ENV"
+            exit 1
+          fi
+          
+          oci ce cluster create-kubeconfig --cluster-id ${CLUSTER_ID} --file $HOME/.kube/config --region sa-saopaulo-1 --token-version 2.0.0 --kube-endpoint PRIVATE_ENDPOINT
+
+      - name: Run Helmfile Apply
+        env:
+          ENV: ${{ inputs.environment }}
+          IMAGE_TAG: ${{ inputs.image }}
+        run: helmfile -f deploy/helmfiles/${ENV}.yaml sync --set image.tag=$IMAGE_TAG

.github/workflows/test.yml

@@ -2,27 +2,34 @@ name: Test
 on:
   pull_request:
     branches:
+      - beta
       - main
 
 jobs:
-  test:
-    runs-on: self-hosted
+  # Blocks a local (file:/tarball/overlay) protospack-v2 dependency from
+  # reaching staging (beta) or prod (main).
+  protospack-dep-guard:
+    if: github.base_ref == 'beta' || github.base_ref == 'main'
+    runs-on: [self-hosted, prd]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
+      - name: Check protospack-v2 is consumed from the registry
+        run: node scripts/check-protospack-dep.js
+
+  test:
+    runs-on: [self-hosted, prd]
+    env:
+      APP_NAME: ${{ github.event.repository.name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
       - name: Build
-        env:
-          APP_NAME: ${{ github.event.repository.name }}
-        run: |
-          docker build -t $APP_NAME --target test .
+        run: docker build -t ${APP_NAME}_teste --target test .
 
       - name: Run Test
-        env:
-          ENV: test
-          APP_NAME: ${{ github.event.repository.name }}
-        run: |
-          docker run --rm --entrypoint="npm" $APP_NAME run test
+        run: docker run ${APP_NAME}_teste
 
       - name: Remove Docker's Trash
         if: always()

.github/workflows/validate-k8s.yml

@@ -0,0 +1,111 @@
+name: Validate K8S Modifications
+
+on:
+  pull_request:
+    branches:
+      - main
+      - beta
+
+jobs:
+  extract_environment:
+    runs-on: ubuntu-22.04
+    outputs:
+      environment: ${{ steps.extract_environment.outputs.environment }}
+    steps:
+      - name: Extract Environment
+        run: |
+          if [ "${{ github.event.pull_request.base.ref }}" == "main" ]; then
+            echo "environment=prd" >> $GITHUB_OUTPUT
+          elif [ "${{ github.event.pull_request.base.ref }}" == "beta" ]; then
+            echo "environment=stg" >> $GITHUB_OUTPUT
+          fi
+        id: extract_environment
+
+  helmfile-check:
+    env:
+      HOME: /home/runner
+    needs: [extract_environment]
+    environment: ${{ needs.extract_environment.outputs.environment }}
+    runs-on: [self-hosted, "prd-oracle"]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v1
+        with:
+          version: 'v3.9.0'
+
+      - name: Determine DNS_HOST based on environment
+        id: set_dns
+        env:
+          ENV: ${{ needs.extract_environment.outputs.environment }}
+        run: |
+          if [ "$ENV" = "prd" ]; then
+            echo "dns_host=dadosfera.ai" >> $GITHUB_OUTPUT
+          elif [ "$ENV" = "stg" ]; then
+            echo "dns_host=stg.dadosfera.ai" >> $GITHUB_OUTPUT
+          fi
+  
+      - name: Install OCI CLI
+        run: |
+          bash -c "$(curl -L https://raw.githubusercontent.com/oracle/oci-cli/master/scripts/install/install.sh)" -- --accept-all-defaults
+          echo "$HOME/bin" >> $GITHUB_PATH
+
+      - name: Configure OCI CLI
+        run: |
+          mkdir -p ~/.oci || true
+          echo "${{ secrets.OCI_CONFIG }}" > ~/.oci/config
+          echo "${{ secrets.OCI_PRIVATE_KEY }}" > ~/.oci/oci_api_key.pem
+          chmod 600 ~/.oci/oci_api_key.pem
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+
+      - name: Install Helmfile
+        run: |
+          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 --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:
+          ENV: ${{ needs.extract_environment.outputs.environment }}
+          STG_CLUSTER_ID: "ocid1.cluster.oc1.sa-saopaulo-1.aaaaaaaagh3jvln52a3ebm3dodx6emmhv5bmfs7i7sv2k4zkbcbrzcl6v37q"
+          PRD_CLUSTER_ID: "ocid1.cluster.oc1.sa-saopaulo-1.aaaaaaaanf3vptl6hc2tzd4enfd2hfpsht3wikxww5xejc3l7cwfm6l3sndq"
+        run: |
+          if [ "$ENV" = "stg" ]; then
+            CLUSTER_ID=$STG_CLUSTER_ID
+          elif [ "$ENV" = "prd" ]; then
+            CLUSTER_ID=$PRD_CLUSTER_ID
+          else
+            echo "Unknown environment: $ENV"
+            exit 1
+          fi
+          
+          oci ce cluster create-kubeconfig --cluster-id ${CLUSTER_ID} --file $HOME/.kube/config --region sa-saopaulo-1 --token-version 2.0.0 --kube-endpoint PRIVATE_ENDPOINT 
+
+      - name: Setup kubectl
+        uses: azure/setup-kubectl@v1
+        with:
+          version: 'v1.30.1'
+
+      - 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

.nvmrc

@@ -1 +1 @@
-18.3.0
+18.17

.vscode/launch.json

@@ -12,6 +12,7 @@
         "start:debug"
       ],
       "runtimeExecutable": "npm",
+      "runtimeVersion": "18.17",
       "skipFiles": [
         "<node_internals>/**"
       ],

Dockerfile

@@ -1,21 +1,68 @@
-# install all dependencies
-FROM node:18.3.0-alpine3.15 as packages
+FROM node:20-alpine AS base_image
+RUN npm install -g npm@10.8.2
+
+FROM base_image AS build_base
 WORKDIR /app
-COPY package.json package-lock.json ./
-RUN apk add --no-cache aws-cli \
- && aws codeartifact login --tool npm --namespace @dadosfera --repository dadosfera-npm --domain dadosfera --domain-owner 611330257153 --region us-east-1 \
- && npm install
+RUN apk update
+# needed packages to build dependencies from source
+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
+
+
+# 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 --ignore-scripts
+COPY . .
+
 
 # unit test specific build
-FROM node:18.3.0-alpine3.15 as test
-WORKDIR /app
-COPY --from=packages /app/node_modules ./node_modules
-COPY . ./
+FROM ci_image AS test
+ENV DUC_URL=0.0.0.0:50051
+ENV INFACTORY_URL=0.0.0.0:50052
+ENTRYPOINT ["npm", "run", "test"]
 
-FROM node:18.3.0-alpine3.15
-WORKDIR /app
-COPY . /app/
-COPY --from=packages /app/node_modules ./node_modules
+
+# dev build
+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 --ignore-scripts
+COPY . .
+ENTRYPOINT npm run start:dev
+
+
+FROM ci_image AS prod_build
 RUN npm run build
-EXPOSE 3333
-ENTRYPOINT npm run start
+
+
+FROM base_image
+WORKDIR /app
+COPY --from=prod_build /app/dist ./dist
+COPY --from=prod_build /app/node_modules ./node_modules
+COPY --from=prod_build /app/package*.json ./
+RUN apk update
+# needed packages to build dependencies from source
+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

Dockerfile.local

@@ -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"]

LICENSE

@@ -0,0 +1,10 @@
+LICENSE
+Copyright (C) 2023 Dadosfera
+
+All rights reserved.
+
+This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means.
+
+Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.
+
+If you have any questions about this, please contact Dadosfera.ai at legal@dadosfera.ai

README.md

@@ -1,68 +1,103 @@
 <p align="center">
   <image src="./assets/maestro.svg" style="width:10rem">
-</p> 
+</p>
 
 # Maestro
-Maestro is the Dadosfera's gateway, it's responsible for the communication between the frontend application and Dadosfera's microservices.
 
-## 🚀 Starting
-These instructions will allow you to get a working copy of the project on your local machine for development and testing purposes.
 
-### 📋 Requirements
-- [NodeJS v18.3.0 LTS / NPM v8.11](https://nodejs.org/pt-br/download/) (you can opt to use [NVM](https://github.com/nvm-sh/nvm) to easily manage node versions)
-- Request access to AWS Console dev account for **all services** (avoid gradually asking for each needed service. it will slow down your development cycle)
-    - Create your Access Key on the "Security credentials" menu
-    - Set the Access Key on your local development machine
-- Request access to the dev, stg and prd VPNs
+Maestro é a API principal da Dadosfera. É responsável pela comunicação do Frontend com nossos microsserviços.
 
-### 🔧 Installation<a id="installation"></a>
-- Clone the repository
-    - SSH
-        ```
-        git clone git@github.com:dadosfera/maestro.git
-        ```
-        or
+```mermaid
+graph TD;
+  Frontend<-->Maestro;
+  Maestro<-->duc;
+  Maestro<-->pi-factory;
+  Maestro<-->in-factory;
+```
 
-    - HTTPS
-        ```
-        git clone https://github.com/dadosfera/maestro.git
-        ```
+É uma API REST, desenvolvida em NodeJs utilizando o Framework [NestJs](https://docs.nestjs.com/).
 
-- Select the correct node version (optional, only if using [NVM](https://github.com/nvm-sh/nvm)):
-    ```sh
-    nvm use
-    ```
+## 🚀 Iniciando
 
-- Install the project dependencies:
-    ```sh
-    npm i
-    ```
+Estas instruções permitirão que você obtenha uma cópia funcional do projeto em sua máquina local para desenvolvimento e testes.
 
-- Setup the following enviroment variables:
-    ```
-    ENV=
-    DUC_URL=
-    INFACTORY_URL=
-    OTFACTORY_URL=
-    PIFACTORY_URL=
-    SM_OAUTH_PATH=
-    ```
+### 📋 Requisitos
 
-- Start the server:
-    ```sh
-    # dev mode
-    npm run start:dev
+- [NodeJS v18.17 / NPM v9.6.7](https://nodejs.org/pt-br/download/)
 
-    # or in debug mode
-    npm run start:debug
-    ```
-    The service should start successfully.
+> Dica: Utilize [NVM](https://github.com/nvm-sh/nvm) para gerenciar facilmente as versões do node
 
-## Authentication decorators
-Maestro have utilities to ease the user authentication on every controller and route. The following decorators are available:
+- Solicite acesso à conta de desenvolvimento do AWS Console para **todos os serviços necessários**
+  - Crie sua Access Key no menu "Security credentials"
+  - Defina a Access Key em sua máquina de desenvolvimento local
+- Solicite acesso às VPNs de stg e prd
+
+### 🔧 Instalação<a id="installation"></a>
+
+- Clone o repositório
+
+  ```sh
+  git clone git@github.com:dadosfera/maestro.git
+  ```
+
+- Selecione a versão correta do node (opcional, apenas se estiver usando o [NVM](https://github.com/nvm-sh/nvm)):
+
+  ```sh
+  nvm use
+  ```
+
+- Instale as dependências do projeto:
+
+  ```sh
+  npm i
+  ```
+
+- Configure as seguintes variáveis de ambiente:
+
+  ```
+  ENV=
+  DUC_URL=
+  INFACTORY_URL=
+  OTFACTORY_URL=
+  PIFACTORY_URL=
+  SM_OAUTH_PATH=
+  ```
+
+- Inicie o servidor:
+
+  ```sh
+  npm run start:dev
+  ```
+
+  > Se preferir, utilize o debbuger do VSCode apertando F5
+
+  O serviço deve iniciar com sucesso.
+
+## 📄 Documentação
+
+O NestJs facilita a documentação de cada rota usando decoradores em todas as propriedades de solicitações e respostas. Ele gera automaticamente um swagger para as informações fornecidas e fornece uma rota para acessá-lo em http://localhost:3333/api. Para mais informações, consulte a [documentação oficial](https://docs.nestjs.com/openapi/introduction).
+
+### - Documentações múltiplas
+
+Atualmente, estamos gerando **2 documentações diferentes**: Interna e Externa.
+
+Todas as rotas que têm o decorador `@ApiInternalOnly()` não serão visíveis no swagger da API **Externa**.
+
+- Quando você inicia a aplicação com `npm run start:dev`, ela servirá e gerará o JSON do swagger da API **Interna**
+
+- Quando você executa `npm run docs`, ele gerará o JSON do swagger de ambas as APIs **Interna** e **Externa** e os salvará em `docsfera.json` e `docsfera.external.json`, respectivamente;
+
+> Link para documentação interna: https://dadosfera.github.io/docsfera
+
+É importante executar `npm run docs` antes de cada implantação para que sempre tenhamos as documentações mais atualizadas publicadas.
+
+## Decoradores de autenticação
+
+O Maestro possui utilitários para facilitar a autenticação do usuário em todos os controladores e rotas. Os seguintes decoradores estão disponíveis:
 
 ### `@Authenticated`
-If the user must be authenticated to make request, we can use the `@Authenticated` decorator in the controller or route, as needed.
+
+Se o usuário precisar estar autenticado para fazer uma solicitação, podemos usar o decorador `@Authenticated` no controlador ou rota, conforme necessário.
 
 ```ts
 import { Authenticated } from '../../authentication/authentication.decorator';
@@ -74,7 +109,7 @@ class FooController {
 
   @Get('bar')
   async getBar() {
-    this.logger.info('user is authenticated!');
+    this.logger.info('usuário está autenticado!');
 
     return { authenticated: true };
   }
@@ -91,14 +126,14 @@ class FooController {
   @Get('bar')
   @Authenticated()
   async getBar() {
-    this.logger.info('user is authenticated!');
+    this.logger.info('usuário está autenticado!');
 
     return { authenticated: true };
   }
 
   @Post('bar')
   async postBar() {
-    this.logger.info('user is NOT authenticated!');
+    this.logger.info('usuário NÃO está autenticado!');
 
     return { authenticated: false };
   }
@@ -106,7 +141,8 @@ class FooController {
 ```
 
 ### `@RequireAllPermissions`
-This decorator requires that **all permissions** listed are granted to the requesting user.
+
+Este decorador exige que **todas as permissões** listadas sejam concedidas ao usuário solicitante.
 
 ```ts
 import { RequireAllPermissions } from '../../authentication/authentication.decorator';
@@ -125,7 +161,8 @@ class FooController {
 ```
 
 ### `@RequireSomePermission`
-In the following case, the user is required to have **at least one** listed permission.
+
+No caso seguinte, é necessário que o usuário tenha **pelo menos uma** das permissões listadas.
 
 ```ts
 import { RequireSomePermission } from '../../authentication/authentication.decorator';
@@ -144,17 +181,19 @@ class FooController {
 ```
 
 ### `@AuthenticateCondition`
-If a more complicated authentication check needs to be done, we can use the `@AuthenticateCondition` decorator to define it. The custom function must return `true` to authenticate the request.
 
-In the following example:
-- all routes on the `FooController` controller can only be requested from localhost
-- `POST /foo/bar` can only be requested from localhost **and** by users from customer id `111...eef`
+Se for necessária uma verificação de autenticação mais complicada, podemos usar o decorador `@AuthenticateCondition` para defini-la. A função personalizada deve retornar `true` para autenticar a solicitação.
+
+No exemplo a seguir:
+
+- todas as rotas no controlador `FooController` só podem ser solicitadas a partir do localhost
+- `POST /foo/bar` só pode ser solicitado a partir do localhost **e** por usuários do cliente com id `111...eef`
 
 ```ts
 import { AuthenticateCondition } from '../../authentication/authentication.decorator';
 
 @Controller('foo')
-// allow requests only from localhost
+// permitir solicitações apenas do localhost
 @AuthenticateCondition((request: Request) => request.ip === '::ffff:127.0.0.1')
 class FooController {
   /* ... */
@@ -165,61 +204,68 @@ class FooController {
   }
 
   @Post('bar')
-  // allow requests only from a specific customer
-  @AuthenticateCondition((request: Request, user: RequestUser) => user.customer_id === '1113e943-2187-4fdd-9c2c-54338fedaeef')
+  // permitir solicitações apenas de um cliente específico
+  @AuthenticateCondition(
+    (request: Request, user: RequestUser) =>
+      user.customer_id === '1113e943-2187-4fdd-9c2c-54338fedaeef',
+  )
   async postBar() {
     /* ... */
   }
 }
 ```
 
-### Note on authentication decorators
-- The old authentication method placed the user data in the `request.body.info` field, this imposes certain issues regarding the request body because this data should be from the frontend without any modification by Maestro. Now this usage is ⚠️ **DEPRECATED** ⚠️. We are working to migrate to the `@User` parameter decorator. The old method is working while the migration is in progress.
+### Nota sobre decoradores de autenticação
 
-- Authentication decorators can be used together and all of them **must** pass to the request be authenticated, but in the general case you don't need to (*and wouldn't like to...*) use all of them together, as you can code all of the authentication logic in the `@AuthenticateCondition` decorator.
+- O método antigo de autenticação colocava os dados do usuário no campo `request.body.info`, o que impõe certos problemas em relação ao corpo da solicitação, pois esses dados devem vir do frontend sem qualquer modificação pelo Maestro. Agora, esse uso está ⚠️ **DESCONTINUADO** ⚠️. Estamos trabalhando para migrar para o decorador de parâmetro `@User`. O método antigo está funcionando enquanto a migração está em andamento.
 
-    ```ts
-    import {
-      RequireAllPermissions,
-      RequireSomePermission,
-      AuthenticateCondition,
-    } from '../../authentication/authentication.decorator';
-    import { PERMISSIONS } from '../../authentication/permissions.enum';
-    import { Waa, Baz } from './authenticationFunctions'
+- Os decoradores de autenticação podem ser usados juntos e todos eles **devem** passar para que a solicitação seja autenticada, mas, no caso geral, você não precisa (_e não gostaria de..._) usar todos eles juntos, pois você pode codificar toda a lógica de autenticação no decorador `@AuthenticateCondition`.
 
-    @Controller('foo')
-    @RequireAllPermissions(Permissions.FOO.USE, Permissions.FOO.REQUEST)
-    @RequireSomePermission(Permissions.FOO.MANAGE, Permissions.FOO.ADMIN)
-    @AuthenticateCondition(Waa)
-    @AuthenticateCondition(Baz)
-    class FooController {
+  ```ts
+  import {
+    RequireAllPermissions,
+    RequireSomePermission,
+    AuthenticateCondition,
+  } from '../../authentication/authentication.decorator';
+  import { PERMISSIONS } from '../../authentication/permissions.enum';
+  import { Waa, Baz } from './authenticationFunctions';
+
+  @Controller('foo')
+  @RequireAllPermissions(Permissions.FOO.USE, Permissions.FOO.REQUEST)
+  @RequireSomePermission(Permissions.FOO.MANAGE, Permissions.FOO.ADMIN)
+  @AuthenticateCondition(Waa)
+  @AuthenticateCondition(Baz)
+  class FooController {
+    /* ... */
+
+    @Get('bar')
+    async getBar() {
       /* ... */
-
-      @Get('bar')
-      async getBar() {
-        /* ... */
-      }
-
-      @Post('bar')
-      @RequireAllPermissions(Permissions.BAR.MANAGE, Permissions.BAR.USE, Permissions.BAR.REQUEST)
-      async postBar() {
-        /* ... */
-      }
     }
-    ```
 
-- If `@RequireAllPermissions` and `@RequireSomePermission` are used with **only a single permission**, they present the **exactly same behavior**.
+    @Post('bar')
+    @RequireAllPermissions(
+      Permissions.BAR.MANAGE,
+      Permissions.BAR.USE,
+      Permissions.BAR.REQUEST,
+    )
+    async postBar() {
+      /* ... */
+    }
+  }
+  ```
 
-    ```ts
-    // same behavior
-    @RequireAllPermissions(Permissions.BAR.MANAGE)
-    @RequireSomePermission(Permissions.BAR.MANAGE)
-    ```
+- Se `@RequireAllPermissions` e `@RequireSomePermission` forem usados com **apenas uma única permissão**, eles apresentam o **exatamente mesmo comportamento**.
 
+  ```ts
+  // mesmo comportamento
+  @RequireAllPermissions(Permissions.BAR.MANAGE)
+  @RequireSomePermission(Permissions.BAR.MANAGE)
+  ```
 
+## Decorador de parâmetro `@User`
 
-## `@User` parameter decorator
-The requesting user data can be obtained using the @User parameter decorator, like in the following snippet:
+Os dados do usuário solicitante podem ser obtidos usando o decorador de parâmetro @User, como no exemplo a seguir:
 
 ```ts
 import { User, RequestUser } from '../../authentication/user.decorator';
@@ -237,7 +283,7 @@ class FooController {
 }
 ```
 
-If the user is required to be logged in, set `required` to `true`, as you would want in the `change-password` operation:
+Se o usuário precisar estar logado, defina `required` como `true`, como por exemplo:
 
 ```ts
 import { User, RequestUser } from '../../authentication/user.decorator';
@@ -263,39 +309,46 @@ class UserController {
 }
 ```
 
-## 📦 Development
-### ⌨️ Coding Style
-By default, we use [ESLint](https://eslint.org/) + [Prettier](https://prettier.io/) with default settings.
+## 📦 Desenvolvimento
 
-**We recommend using Visual Studio Code and installing the recommended extensions to ease the development process.**
+### ⌨️ Estilo de Codificação
 
-### Commits pattern
-Our workflow pipeline follows the conventional commits specs ([cheat sheets](https://cheatography.com/albelop/cheat-sheets/conventional-commits/)) to release versions accordingly.
+Por padrão, usamos [ESLint](https://eslint.org/) + [Prettier](https://prettier.io/) com configurações padrão.
 
-Format: `<type>[optional scope]: <description>`
+**Recomendamos usar o Visual Studio Code e instalar as extensões recomendadas para facilitar o processo de desenvolvimento.**
 
-Example: `FIX: ensure Range headers adhere more closely to RFC 2616`
+### Padrão de commits
 
-### Branching naming convention
-- **Feature**: Any code changes for a new module or use case should be done on a feature branch. This branch is created based on the `main` branch. When all changes are done, a Pull Request/Merge Request is needed to put all of these changes back to the `main` branch. Examples: `feature/integrate-swagger`, `feature/JIRA-1234`, `feature/JIRA-1234_support-dark-theme`.
+Nosso pipeline de fluxo de trabalho segue as especificações de commits convencionais ([cheat sheets](https://cheatography.com/albelop/cheat-sheets/conventional-commits/)) para liberar versões conforme necessário.
 
-  **It is recommended to use all lower caps letters and hyphen (-) to separate words unless it is a specific item name or ID. Underscore (_) could be used to separate the ID and description.**
+Formato: `<type>[optional scope]: <description>`
 
-- **Bug Fix**: If the code changes made from the feature branch were rejected after a release, sprint or demo, any necessary fixes after that should be done on the bugfix branch. Examples: `bugfix/more-gray-shades`,  `bugfix/JIRA-1444_gray-on-blur-fix`.
+Exemplo: `FIX: ensure Range headers adhere more closely to RFC 2616`
 
-- **Hot Fix**: If there is a need to fix a blocker, do a temporary patch, apply a critical framework or configuration change that should be handled immediately, it should be created as a Hotfix. Examples: `hotfix/disable-endpoint-zero-day-exploit`, `hotfix/increase-scaling-threshold`.
+### Convenção de nomenclatura de branchs
 
-- **Experimental**: A branch for playing around. Any new feature or idea that is not part of a release or a sprint. Example: `experimental/dark-theme-support`.
+- **Feature**: Quaisquer alterações de código para um novo módulo ou caso de uso devem ser feitas em uma branch de feature. Esta branch é criada com base na branch `main`. Quando todas as alterações estiverem concluídas, será necessário um Pull Request/Merge Request para colocar todas essas alterações de volta na branch `main`. Exemplos: `feature/integrate-swagger`, `feature/JIRA-1234`, `feature/JIRA-1234_support-dark-theme`.
 
-### Making a Pull Request
-1. Commit your changes
-2. Open the Pull Request on GitHub
-3. Send Pull Request link in microsfera Google Chat Group for review and possible approval
+  **Recomenda-se usar todas as letras em minúsculas e hífen (-) para separar palavras, a menos que seja um nome ou ID de item específico. O sublinhado (\_) pode ser usado para separar o ID e a descrição.**
 
-## 🛠️ Built with
-Some technologies used in this project:
+- **Bug Fix**: Se as alterações de código feitas na branch de feature foram rejeitadas após um lançamento, sprint ou demo, quaisquer correções necessárias após isso devem ser feitas na branch de correção de bug. Exemplos: `bugfix/more-gray-shades`, `bugfix/JIRA-1444_gray-on-blur-fix`.
 
-- [NestJS](https://docs.nestjs.com) - Framework for building efficient and scalable NodeJS server-side applications
+- **Hot Fix**: Se houver necessidade de corrigir um bloqueador, fazer um patch temporário, aplicar uma mudança crítica de framework ou configuração que deva ser tratada imediatamente, ela deve ser criada como um Hotfix. Exemplos: `hotfix/disable-endpoint-zero-day-exploit`, `hotfix/increase-scaling-threshold`.
 
-## ⚙️ Back-end Architecture
-The architecture can be found at [this link](https://sites.google.com/dadosfera.ai/wikidoproduto/time/back-end).
+- **Experimental**: Uma branch para experimentar. Qualquer nova feature ou ideia que não faça parte de um lançamento ou sprint. Exemplo: `experimental/dark-theme-support`.
+
+### Fazendo um Pull Request
+
+1. Comite suas alterações
+2. Abra o Pull Request no GitHub
+3. Envie o link do Pull Request no grupo de chat do Google da Microsfera para revisão e possível aprovação
+
+## 🛠️ Construído com
+
+Algumas tecnologias usadas neste projeto:
+
+- [NestJS](https://docs.nestjs.com) - Framework para construir aplicações NodeJS eficientes e escaláveis no lado do servidor
+
+## ⚙️ Arquitetura de Back-end
+
+A arquitetura pode ser encontrada neste [link](https://sites.google.com/dadosfera.ai/wikidoproduto/time/back-end).

build.docker-compose.dockerhub.yml

@@ -0,0 +1,4 @@
+services:
+  maestro:
+    build: .
+    image: dadosfera/maestro_${ENV}:${IMAGE_TAG}

build.docker-compose.yml

@@ -1,5 +1,4 @@
-version: "3.8"
 services:
   maestro:
     build: .
-    image: ${ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/microservices/maestro_${ENV}:${IMAGE_TAG}
+    image: ${ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/microservices/maestro_prd:${IMAGE_TAG}

deploy/helm-chart/Chart.yaml

@@ -0,0 +1,24 @@
+apiVersion: v2
+name: maestro
+description: A Helm chart for Kubernetes
+
+# A chart can be either an 'application' or a 'library' chart.
+#
+# Application charts are a collection of templates that can be packaged into versioned archives
+# to be deployed.
+#
+# Library charts provide useful utilities or functions for the chart developer. They're included as
+# a dependency of application charts to inject those utilities and functions into the rendering
+# pipeline. Library charts do not define any templates and therefore cannot be deployed.
+type: application
+
+# This is the chart version. This version number should be incremented each time you make changes
+# to the chart and its templates, including the app version.
+# Versions are expected to follow Semantic Versioning (https://semver.org/)
+version: 0.1.0
+
+# This is the version number of the application being deployed. This version number should be
+# incremented each time you make changes to the application. Versions are not expected to
+# follow Semantic Versioning. They should reflect the version the application is using.
+# It is recommended to use it with quotes.
+appVersion: "1.16.0"

deploy/helm-chart/templates/deployment.yaml

@@ -0,0 +1,150 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ .Values.app_name }}
+  namespace: applications
+  labels:
+    app: {{ .Values.app_name }}
+
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      app: {{ .Values.app_name }}
+  
+  strategy:
+    rollingUpdate:
+      maxSurge: 25%
+      maxUnavailable: 25%
+    type: RollingUpdate
+  template:
+    metadata:
+      labels:
+        app: {{ .Values.app_name }}
+    
+    spec:
+      imagePullSecrets:
+        - name: {{ .Values.imagePullSecrets }}
+      nodeSelector:
+        "beta.kubernetes.io/os": linux
+      {{- if .Values.affinity }}
+      affinity:
+        {{- toYaml .Values.affinity | nindent 8 }}
+      {{- end }}
+
+      tolerations:
+      - key: "kubernetes.azure.com/scalesetpriority"
+        operator: "Equal"
+        value: "spot"
+        effect: "NoSchedule"
+
+      containers:
+        - name: maestro
+          image: {{ .Values.image.repository }}:{{ .Values.image.tag }}
+          ports:
+            - containerPort: {{ .Values.containerPort }}
+          {{- if .Values.resources }}
+          resources:
+            {{- 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
+              value: "us-east-1"
+            - name: BASE_HOST
+              value: "maestro_prd"
+            - name: BUCKET_CUSTOMER_CSV_ASSETS
+              value: {{ .Values.maestro.bucket_customer_csv_assets }}
+            - name: CONNECTORS_INDEX
+              value: "connectors"
+            - name: DUC_URL
+              value: {{ .Values.maestro.duc_url }}
+            - name: ELASTIC_APM_ENVIRONMENT
+              value: {{ .Values.maestro.env }}
+            - name: ELASTIC_APM_SERVER_URL
+              value: "https://apm-server.dadosfera.ai"
+            - name: ELASTIC_APM_SERVICE_NAME
+              value: {{ .Values.maestro.apm_service }}
+            - name: ENV
+              value: {{ .Values.maestro.env }}
+            - name: INFACTORY_URL
+              value: {{ .Values.maestro.in_factory_url }}
+            - name: LOGGER_GELF_HOST
+              value: "logstash-pipelines.dadosfera.ai"
+            - name: LOGGER_GELF_PORT
+              value: "{{ .Values.maestro.logger_gelf_port }}"
+            - name: LOGGER_CONSOLE_EXTRA
+              value: "true"
+            - name: NIMBUS_BASE_URL
+              value: "http://nimbus-api"
+            - name: NPM_TOKEN
+              value: {{ .Values.maestro.npm_token }}
+            - name: PB_TOKEN_PATH
+              value: {{ .Values.maestro.pb_token_path }}
+            - name: PIFACTORY_URL
+              value: {{ .Values.maestro.pi_factory_url }}
+            - name: SM_OAUTH_PATH
+              value: {{ .Values.maestro.sm_oauth_path }}
+            - name: TRFACTORY_URL
+              value: {{ .Values.maestro.tr_factory_url }}
+            - name: UPLOAD_FILE_AGENT_CONNECTION
+              value: {{ .Values.maestro.upload_file_agent_connection }}
+            - name: OPEN_CUSTOMER_ID
+              value: {{ .Values.maestro.open_customer_id }}
+            - name: OPEN_GROUP_ID
+              value: {{ .Values.maestro.open_group_id }}
+            - name: DEDICATED_PROXY
+              value: {{ .Values.maestro.dedicated_proxy }}
+            - name: COOKIE_SECRET
+              value: {{ .Values.maestro.cookie_secret }}
+            - name: REDIS_DATABASE
+              value: "{{ .Values.maestro.redis_database }}"
+            - name: REDIS_HOST
+              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:
+                  name: prd-duc
+                  key: jwt_token
+            - name: AWS_ACCESS_KEY_ID
+              valueFrom:
+                secretKeyRef:
+                  name: prd-{{ .Values.app_name }}
+                  key: AWS_ACCESS_KEY_ID
+            - name: AWS_SECRET_ACCESS_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: prd-{{ .Values.app_name }}
+                  key: AWS_SECRET_ACCESS_KEY
+            - name: AWS_DEFAULT_REGION
+              valueFrom:
+                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

deploy/helm-chart/templates/ingress-private.yaml

@@ -0,0 +1,41 @@
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+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:
+    app: {{ .Values.app_name }}
+  {{- if .Values.maestro.dedicated_proxy}}
+  name: open-data-{{ .Values.app_name }}
+  {{- else }}
+  name: open-data
+  {{- end }}
+  namespace: applications
+spec:
+  ingressClassName: nginx
+  rules:
+  - host: {{ .Values.hostname }}
+    http:
+      paths:
+      - backend:
+          service:
+            name: {{ .Values.app_name }}
+            port:
+              number: {{ .Values.ingress.port }}
+        path: /open-data/sharing-ocean-data
+        pathType: Prefix

deploy/helm-chart/templates/ingress.yaml

@@ -0,0 +1,36 @@
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    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:
+    app: {{ .Values.app_name }}
+  name: {{ .Values.app_name }}
+  namespace: applications
+spec:
+  ingressClassName: nginx
+  rules:
+  - host: {{ .Values.hostname }}
+    http:
+      paths:
+      - backend:
+          service:
+            name: {{ .Values.app_name }}
+            port:
+              number: {{ .Values.ingress.port }}
+        path: /
+        pathType: Prefix

deploy/helm-chart/templates/secret.yaml

@@ -0,0 +1,52 @@
+apiVersion: external-secrets.io/v1beta1
+kind: ExternalSecret
+metadata:
+  name: prd-{{ .Values.app_name }}
+  namespace: applications
+  labels:
+    app: {{ .Values.app_name }}
+spec:
+  refreshInterval: 1h
+  secretStoreRef:
+    name: secretsmanager-prd
+    kind: SecretStore
+  target:
+    name: prd-{{ .Values.app_name }}
+    creationPolicy: Owner
+  data:
+  - secretKey: AWS_ACCESS_KEY_ID
+    remoteRef:
+      key: prd/microservices/aws_credentials/maestro
+      version: "AWSCURRENT"
+      property: AWS_ACCESS_KEY_ID
+
+  - secretKey: AWS_SECRET_ACCESS_KEY
+    remoteRef:
+      key: prd/microservices/aws_credentials/maestro
+      version: "AWSCURRENT"
+      property: AWS_SECRET_ACCESS_KEY
+
+  - secretKey: AWS_DEFAULT_REGION
+    remoteRef:
+      key: prd/microservices/aws_credentials/maestro
+      version: "AWSCURRENT"
+      property: AWS_DEFAULT_REGION
+
+  - secretKey: jwt_token
+    remoteRef:
+      key: {{ .Values.maestro.jwt_token_secret_id }}
+      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
+

deploy/helm-chart/templates/service.yaml

@@ -0,0 +1,18 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .Values.app_name }}
+  namespace: applications
+  labels:
+    app: {{ .Values.app_name }}
+
+spec:
+  type: ClusterIP
+  ports:
+  - name: {{ .Values.app_name }}
+    protocol: TCP
+    port: {{ .Values.service.port }}
+    targetPort: {{ .Values.service.targetPort }}
+  selector:
+    app: {{ .Values.app_name }}
+

deploy/helm-chart/values-stg.yaml

@@ -0,0 +1,20 @@
+maestro:
+  env: stg
+  duc_url: duc.stg.dadosfera.ai
+  pi_factory_url: pi-factory.stg.dadosfera.ai
+  in_factory_url: in-factory.stg.dadosfera.ai
+  tr_factory_url: in-factory.stg.dadosfera.ai
+  open_customer_id: b3e3dfe5-b992-4586-a73c-c0b0c00f615d
+  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
+
+replicaCount: 1
+
+affinity: null

deploy/helm-chart/values.yaml

@@ -0,0 +1,74 @@
+# Default values for metabase.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+
+replicaCount: 3
+hostname: maestro.dadosfera.ai
+image:
+  repository: 611330257153.dkr.ecr.us-east-1.amazonaws.com/microservices/maestro_prd
+  pullPolicy: IfNotPresent
+  # Overrides the image tag whose default is the chart appVersion.
+  tag: 1.56.0
+app_name: maestro
+containerPort: 3333
+imagePullSecrets: "applications-secrets-ecr-auth-token-external-secret"
+service:
+  type: ClusterIP
+  port: 3333
+  targetPort: 3333
+ingress:
+  enabled: false
+  port: 3333
+resources:
+  requests:
+    cpu: 100m
+    memory: 1500Mi
+  limits:
+    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
+  bucket_customer_csv_assets: "customers-csv-assets-prd-611330257153"
+  env: prd
+  apm_service: maestro
+  jwt_token_secret_id: prd/root/jwt_token
+  logger_gelf_port: "1026"
+  npm_token: npm_Xp17h3daMkORcZ55NY95Ez4gRfdzsQ3UvINP
+  pb_token_path: prd/root/productboard_token
+  pi_factory_url: pi-factory.dadosfera.ai
+  sm_oauth_path: prd/root/oauth_applications
+  tr_factory_url: in-factory.dadosfera.ai
+  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
+  maxReplicas: 100
+  targetCPUUtilizationPercentage: 80
+  targetMemoryUtilizationPercentage: 80
+
+affinity:
+  nodeAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+      nodeSelectorTerms:
+        - matchExpressions:
+            - key: name
+              operator: In
+              values:
+                - product

deploy/helmfiles/prd.yaml

@@ -0,0 +1,56 @@
+releases:
+  - name: maestro
+    chart: ../helm-chart
+    values:
+    - ../helm-chart/values.yaml
+    set:
+      - name: app_name
+        value: maestro
+      - name: maestro.duc_url
+        value: duc.dadosfera.ai
+      - name: hostname
+        value: maestro.dadosfera.ai
+      - name: maestro.pi_factory_url
+        value: pi-factory.dadosfera.ai
+      - name: maestro.in_factory_url
+        value: in-factory.dadosfera.ai
+      - name: maestro.tr_factory_url
+        value: in-factory.dadosfera.ai
+      - name: maestro.open_customer_id
+        value: b3e3dfe5-b992-4586-a73c-c0b0c00f615d
+      - name: maestro.open_group_id
+        value: c0afdcce-c5be-40d0-9d1d-2d271121f14a
+      - name: replicaCount
+        value: 2
+  
+  - name: unimed-maestro
+    chart: ../helm-chart
+    values:
+    - ../helm-chart/values.yaml
+    set:
+      - name: app_name
+        value: maestro-unimed
+      - name: maestro.duc_url
+        value: duc.dadosfera.ai
+      - name: hostname
+        value: maestro-unimed.dadosfera.ai
+      - name: maestro.pi_factory_url
+        value: pi-factory.dadosfera.ai
+      - name: maestro.in_factory_url
+        value: in-factory.dadosfera.ai
+      - name: maestro.tr_factory_url
+        value: in-factory.dadosfera.ai
+      - name: maestro.open_customer_id
+        value: b3e3dfe5-b992-4586-a73c-c0b0c00f615d
+      - name: maestro.open_group_id
+        value: c0afdcce-c5be-40d0-9d1d-2d271121f14a
+      # Customer id
+      - name: maestro.dedicated_proxy
+        value: dea2c27f-0973-4588-a2e0-9e31b64c7ffd
+      - name: replicaCount
+        value: 1
+        # 10.70.0.0/16 internal network
+        # 137.131.167.254/32 loadbalancer
+        # 159.112.184.81/32 cluster ip for the uptime request ingest
+      - name: maestro.restricted_ip
+        value: "177.52.172.0/24, 189.84.160.157/32, 186.237.171.146/32, 137.131.167.254/32, 10.70.0.0/16, 159.112.184.81/32, 10.244.0.0/16"

deploy/helmfiles/stg.yaml

@@ -0,0 +1,30 @@
+charts:
+  - name: maestro
+    chart: ../helm-chart
+    values:
+    - ../helm-chart/values.yaml
+    - ../helm-chart/values-stg.yaml
+      
+  
+    # Environment to test Network Policies
+  - name: private-maestro
+    chart: ../helm-chart
+    values:
+    - ../helm-chart/values.yaml
+    - ../helm-chart/values-stg.yaml
+    set:
+      - name: app_name
+        value: maestro-private
+      - name: hostname
+        value: private-maestro.stg.dadosfera.ai
+      # Customer id
+      - name: maestro.dedicated_proxy
+        value: 14d52fd4-d83d-4cdd-be34-bf11cc28b3bd
+      - name: replicaCount
+        value: 1
+      - name: affinity
+        value: null
+      - name: resources
+        value: null
+      - name: maestro.restricted_ip
+        value: "137.131.167.254/32, 10.70.0.0/16, 159.112.184.81/32, 10.244.0.0/16"

deprecated/docker-compose.dockerhub.yml

@@ -0,0 +1,28 @@
+services:
+  maestro:
+    image: dadosfera/maestro_${ENV}:${IMAGE_TAG}
+    container_name: maestro
+    restart: always
+    ports:
+      - 3333:3333
+    env_file:
+      - .env
+
+  node_exporter:
+    image: ${NODE_EXPORTER_URL}
+    container_name: node_exporter
+    restart: always
+    volumes:
+      - /proc:/host/proc:ro
+      - /sys:/host/sys:ro
+      - /:/rootfs:ro
+      - /run/dbus/system_bus_socket:/var/run/dbus/system_bus_socket:ro
+    command:
+      - '--path.procfs=/host/proc'
+      - '--path.rootfs=/rootfs'
+      - '--path.sysfs=/host/sys'
+      - '--collector.filesystem.ignored-mount-points=^/(sys|proc|dev|host|etc)($$|/)'
+      - '--collector.systemd'
+      - '--collector.processes'
+    network_mode: host
+    pid: host

deprecated/docker-compose.yml

@@ -1,4 +1,3 @@
-version: "3.8"
 services:
   maestro:
     image: ${ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/microservices/maestro_${ENV}:${IMAGE_TAG}

environment.d.ts

@@ -0,0 +1,23 @@
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      NODE_ENV: 'test';
+      ENV: 'local' | 'stg' | 'prd' | 'test';
+      LOCAL_ENV: 'stg' | 'prd';
+
+      DUC_URL: string;
+      INFACTORY_URL: string;
+      PIFACTORY_URL: string;
+
+      INTERNAL_SWAGGER: 'true' | 'false';
+
+      AWS_REGION: string;
+      OPEN_GROUP_ID: string;
+      OPEN_CUSTOMER_ID: string;
+      DEDICATED_PROXY: string;
+      COOKIE_SECRET: string;
+      REDIS_TLS?: string;
+    }
+  }
+}
+export {};

nest-cli.json

@@ -4,6 +4,7 @@
   "compilerOptions": {
     "assets": [
       "**/*.proto",
+      "assets/**/*",
       {
         "include": "i18n/**/*",
         "watchAssets": true

package.json

@@ -6,93 +6,119 @@
   "private": true,
   "license": "UNLICENSED",
   "engines": {
-    "node": "18.3.0"
+    "node": "18.17"
   },
   "scripts": {
-    "preinstall": "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",
+    "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@v3.40.0-beta.1 --save-exact",
     "prebuild": "rimraf dist",
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "start": "nest start",
-    "start:dev": "nest start --watch",
-    "start:debug": "nest start --debug --watch",
-    "start:prod": "npm run build && node dist/main",
+    "start:dev": "export INTERNAL_SWAGGER=true && nest start --watch",
+    "start:debug": "npm run start:dev",
+    "start:prod": "node dist/main",
+    "docs": "export KILL_AFTER_START=1 && nest start && export INTERNAL_SWAGGER=true && nest start",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
-    "test": "jest",
+    "test": "jest --detectOpenHandles --forceExit",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
   "dependencies": {
-    "@aws-sdk/client-secrets-manager": "^3.112.0",
+    "@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-v2": "3.19.4",
-    "@grpc/grpc-js": "^1.6.7",
-    "@grpc/proto-loader": "^0.6.13",
-    "@nestjs/common": "^8.4.7",
-    "@nestjs/config": "^1.2.1",
-    "@nestjs/core": "^8.4.7",
-    "@nestjs/mapped-types": "*",
-    "@nestjs/microservices": "^8.4.7",
-    "@nestjs/passport": "^8.2.2",
-    "@nestjs/platform-express": "^8.4.7",
-    "@nestjs/schedule": "^1.1.0",
-    "@nestjs/swagger": "^5.2.1",
-    "axios": "^0.27.2",
+    "@dadosfera/protospack-v2": "^3.40.0-beta.20",
+    "@grpc/grpc-js": "^1.9.3",
+    "@grpc/proto-loader": "^0.7.9",
+    "@nestjs/cli": "^9.5.0",
+    "@nestjs/common": "^9.4.3",
+    "@nestjs/config": "^2.3.4",
+    "@nestjs/core": "^9.4.3",
+    "@nestjs/mapped-types": "^1.2.2",
+    "@nestjs/microservices": "^9.4.3",
+    "@nestjs/passport": "^9.0.3",
+    "@nestjs/platform-express": "^9.4.3",
+    "@nestjs/schematics": "^9.2.0",
+    "@nestjs/swagger": "^6.3.0",
+    "@nestjs/testing": "^9.4.3",
+    "axios": "0.30.3",
+    "cache-manager": "^5.1.4",
+    "cache-manager-ioredis-yet": "^1.1.0",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.13.2",
-    "cron-parser": "^4.4.0",
+    "class-validator": "^0.14.0",
+    "cookie-parser": "^1.4.7",
+    "cron-parser": "^4.9.0",
+    "csv": "^6.3.11",
     "dotenv": "^14.3.2",
-    "elastic-apm-node": "^3.36.0",
-    "helmet": "^5.1.0",
-    "jsonwebtoken": "^8.5.1",
+    "elastic-apm-node": "^3.50.0",
+    "handlebars": "^4.7.8",
+    "helmet": "^5.1.1",
+    "jsonwebtoken": "^9.0.2",
     "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",
-    "passport-forcedotcom": "^0.1.5",
+    "passport-forcedotcom": "^0.2.0",
     "passport-google-oauth20": "^2.0.0",
     "passport-hubspot-oauth2": "^1.0.3",
     "passport-mailchimp": "^1.1.0",
-    "protospack": "2.5.2",
+    "puppeteer": "^24.7.2",
+    "redis": "^4.5.1",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
     "rxjs": "^7.5.5",
-    "swagger-ui-express": "^4.4.0"
+    "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": {
-    "@nestjs/cli": "^8.2.8",
-    "@nestjs/schematics": "^8.0.11",
-    "@nestjs/testing": "^8.4.7",
-    "@types/express": "^4.17.13",
+    "@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",
-    "@types/jsonwebtoken": "^8.5.8",
+    "@types/jsonwebtoken": "^8.5.9",
     "@types/jwk-to-pem": "^2.0.1",
-    "@types/multer": "^1.4.7",
-    "@types/node": "^16.11.41",
+    "@types/multer": "^1.4.12",
+    "@types/node": "^16.18.52",
     "@types/passport-facebook": "^2.1.11",
     "@types/passport-google-oauth20": "^2.0.11",
-    "@types/passport-oauth2": "^1.4.11",
+    "@types/passport-oauth2": "^1.4.12",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.29.0",
-    "@typescript-eslint/parser": "^5.29.0",
-    "eslint": "^8.18.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "eslint": "^8.49.0",
+    "eslint-config-prettier": "^8.10.0",
+    "eslint-plugin-prettier": "^4.2.1",
     "jest": "^27.5.1",
-    "nock": "^13.2.7",
-    "prettier": "^2.7.1",
+    "nock": "^13.3.3",
+    "prettier": "^2.8.8",
     "source-map-support": "^0.5.20",
-    "supertest": "^6.2.3",
+    "supertest": "^6.3.3",
     "ts-jest": "^27.1.5",
-    "ts-loader": "^9.3.1",
-    "ts-node": "^10.8.1",
-    "tsconfig-paths": "^3.14.1",
-    "typescript": "^4.6.3"
+    "ts-loader": "^9.4.4",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^3.14.2",
+    "typescript": "^4.9.5"
+  },
+  "resolutions": {
+    "axios": "0.30.3"
   }
 }

scripts/check-protospack-dep.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/*
+ * CI guard: fail if @dadosfera/protospack-v2 is consumed from a LOCAL ref
+ * (file:/link:/git/relative path/bare tarball) instead of the CodeArtifact
+ * registry.
+ *
+ * Only local consumption is blocked. Versions published to CodeArtifact —
+ * including alpha/beta/rc prereleases produced by the alpha/beta branches —
+ * are fine; those resolve to a registry URL in the lockfile. The thing that
+ * must NOT reach beta (staging) or main (prod) is a dependency wired to a
+ * local `npm pack` tarball / overlay. Runs in the PR test workflow for PRs
+ * targeting beta/main and exits non-zero on any local ref.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const PKG = '@dadosfera/protospack-v2';
+const root = path.resolve(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+
+const problems = [];
+
+// A dependency SPEC is local if it's a filesystem path, symlink, git ref, or a
+// bare tarball path. A plain semver (incl. prereleases like 3.35.0-beta.1)
+// resolves from the registry and is allowed.
+function isLocalSpec(spec) {
+  return /^(file:|link:|git[:+]|\.\.?\/|\/|~\/)/.test(spec) || spec.endsWith('.tgz');
+}
+
+const spec =
+  (pkg.dependencies && pkg.dependencies[PKG]) ||
+  (pkg.devDependencies && pkg.devDependencies[PKG]);
+
+if (!spec) {
+  problems.push(`${PKG} is not listed as a dependency at all.`);
+} else if (isLocalSpec(spec)) {
+  problems.push(`${PKG} points at a local path/tarball/git ref: "${spec}".`);
+}
+
+// Also catch a lockfile resolved to a LOCAL ref even if package.json looks
+// clean. A registry URL (https://.../-/*.tgz) is the normal published
+// resolution and is fine — only file: refs and bare local tarball paths
+// (no http host) are blocked. Prerelease VERSIONS are not flagged: an
+// alpha/beta/rc published to CodeArtifact resolves to a registry URL.
+const lockPath = path.join(root, 'package-lock.json');
+if (fs.existsSync(lockPath)) {
+  const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+  const nodes = { ...(lock.packages || {}), ...(lock.dependencies || {}) };
+  for (const [name, node] of Object.entries(nodes)) {
+    if (!name.includes('protospack-v2') || !node) continue;
+    const resolved = node.resolved || '';
+    const isLocal =
+      resolved.startsWith('file:') ||
+      (resolved.endsWith('.tgz') && !/^https?:\/\//.test(resolved));
+    if (isLocal) {
+      problems.push(
+        `package-lock.json resolves ${PKG} to a local ref: "${resolved}".`,
+      );
+    }
+  }
+}
+
+if (problems.length) {
+  console.error('✗ protospack-v2 dependency guard FAILED:');
+  for (const p of problems) console.error('  - ' + p);
+  console.error(
+    '\nMerging to beta/main requires ' +
+      PKG +
+      ' to come from CodeArtifact, not a local tarball/overlay. Publish ' +
+      'protospack-v2 (a beta prerelease is fine for the beta branch) and ' +
+      'repoint this dependency before merging.',
+  );
+  process.exit(1);
+}
+
+console.log(`✓ ${PKG} is consumed from the registry: "${spec}"`);

src/app.module.ts

@@ -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';
@@ -25,9 +24,20 @@ import { ConfigModule } from '@nestjs/config';
 import { PipelinesV2Module } from './modules/pipelinesV2/pipelines.module';
 import { ProductboardModule } from './modules/productboard/productboard.module';
 import { MixpanelModule } from './modules/mixpanel/mixpanel.module';
+import { CustomersModule } from './modules/customers/customers.module';
+import { OpenDataModule } from './modules/open-data/open-data.module';
+import { ThemeModule } from './modules/theme/theme.module';
+import { IdentityProviderModule } from './modules/identity-provider/identity-provider.module';
+import { NetworkPolicyModule } from './modules/network-policy/network-policy.module';
+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({
-  controllers: [],
   providers: [
     DadosferaLogger,
     {
@@ -40,24 +50,36 @@ import { MixpanelModule } from './modules/mixpanel/mixpanel.module';
       isGlobal: true,
     }),
     AuthModule,
+    ConnectionModule,
+    NetworkConfigModule,
+    InputsModule,
+    PipelinesV2Module,
+    CatalogModule,
     ConnectorModule,
     PermissionsModule,
     TermsOfUseModule,
-    ConnectionModule,
-    NetworkConfigModule,
     ConnectionTestModule,
-    PipelinesModule,
-    PipelinesV2Module,
     TransformationsModule,
-    HealthModule,
-    CatalogModule,
     UsersModule,
     RolesModule,
-    InputsModule,
     OauthModule,
-    CatalogModule,
     ProductboardModule,
     MixpanelModule,
+    CustomersModule,
+    OpenDataModule,
+    ThemeModule,
+    NetworkPolicyModule,
+    AssignModule,
+    ShareMetadataModule,
+    NetworkPolicyModule,
+    ApiKeyModule,
+    IdentityProviderModule,
+    NetworkPolicyModule,
+    PlatformApiModule,
+    StorageExplorerModule,
+    //Always leave HealthModule last, so it is on the bottom of swagger
+    HealthModule,
+    ReleaseNoteModule,
   ],
 })
 export class AppModule {}

src/assets/template/pii-reporter.html

@@ -0,0 +1,130 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Dadosfera Relatório de PII</title>
+    <link href="https://fonts.googleapis.com/css2?family=Quicksand:wght@400;500;700&display=swap" rel="stylesheet">
+    <style>
+        @page {
+            size: A4 landscape; /* Alterado para paisagem (landscape) */
+            margin: 15mm 10mm; /* Reduzido para proporcionar mais espaço */
+        }
+        body {
+            font-family: 'Quicksand', sans-serif;
+            color: #5c5c5c;
+            margin: 0;
+            padding: 10px;
+            font-size: 12px; /* Reduzindo o tamanho da fonte */
+        }
+        .container {
+            margin: 0;
+            width: 100%;
+        }
+        .header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+        .logo {
+            max-width: 150px; /* Reduzida para economizar espaço */
+            height: auto;
+        }
+        h1 {
+            color: #0d003b;
+            font-weight: 700;
+            margin-left: 20px;
+            font-size: 24px; /* Tamanho ajustado */
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 15px;
+            table-layout: fixed; /* Importante: define larguras fixas */
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+            border: 1px solid #d0d0d0;
+        }
+        th {
+            background-color: #1700a2;
+            color: white;
+            font-weight: bold;
+            text-align: left;
+            padding: 8px 10px;
+            border: 1px solid #3a26b8;
+            font-size: 11px; /* Tamanho ajustado */
+            word-wrap: break-word; /* Permite quebra de palavras */
+            overflow-wrap: break-word;
+        }
+        td {
+            padding: 6px 10px;
+            border: 1px solid #d0d0d0;
+            font-size: 11px; /* Tamanho ajustado */
+            word-wrap: break-word; /* Permite quebra de palavras */
+            overflow-wrap: break-word;
+        }
+        /* Definindo larguras específicas para cada coluna */
+        th:nth-child(1), td:nth-child(1) { width: 14%; } /* Database */
+        th:nth-child(2), td:nth-child(2) { width: 14%; } /* Schema */
+        th:nth-child(3), td:nth-child(3) { width: 17%; } /* Tabela */
+        th:nth-child(4), td:nth-child(4) { width: 17%; } /* Coluna */
+        th:nth-child(5), td:nth-child(5) { width: 13%; } /* Tipo de Dado */
+        th:nth-child(6), td:nth-child(6) { width: 25%; } /* Regras PII */
+        
+        tr:nth-child(even) {
+            background-color: #f9f9f9;
+        }
+        tr:nth-child(odd) {
+            background-color: white;
+        }
+        .info-section {
+            margin-top: 20px;
+            color: #5c5c5c;
+        }
+        .timestamp {
+            font-style: italic;
+            text-align: right;
+            margin-top: 15px;
+            font-size: 0.9em;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <img src="https://dadosfera.ai/wp-content/webp-express/webp-images/uploads/2022/06/Logo-Dadosfera1-1.png.webp" alt="Logo Dadosfera" class="logo">
+            <h1>Relatório de PII</h1>
+        </div>
+
+        <div class="info-section">
+            <p>Este relatório apresenta a estrutura de tabelas e suas as seguintes características de PII identificadas.</p>
+        </div>
+
+        <table>
+            <thead>
+                <tr>
+                    <th>Database</th>
+                    <th>Schema</th>
+                    <th>Tabela</th>
+                    <th>Coluna</th>
+                    <th>Tipo de Dado</th>
+                    <th>Regras PII</th>
+                </tr>
+            </thead>
+            <tbody>
+                {{#each dados}}
+                <tr>
+                    <td>{{database_name}}</td>
+                    <td>{{table_schema}}</td>
+                    <td>{{table_name}}</td>
+                    <td>{{column_name}}</td>
+                    <td>{{data_type}}</td>
+                    <td>{{pii_rules}}</td>
+                </tr>
+                {{/each}}
+            </tbody>
+        </table>
+
+        <p class="timestamp">Gerado em: {{dataGeracao}}</p>
+    </div>
+</body>
+</html>

src/authentication/authentication.decorator.ts

@@ -1,56 +0,0 @@
-import { Request } from 'express';
-import { CustomDecorator } from '@nestjs/common';
-import { PermissionsObjectPermission } from './permissions.enum';
-import { RequestUser } from './user.decorator';
-
-export const AUTH_FUNCTION_KEY = '__AUTH_FUNCTION__';
-
-export type AuthenticationFunction = (req: Request, user: any) => boolean;
-
-// implementation copied from SetMetadata, but tweaked to get existing values
-// of the metadataKey and accumulate it with the new metadataValue
-function SetMultipleMetadata(metadataKey, metadataValue): CustomDecorator {
-  const decoratorFactory = (target, key, descriptor) => {
-    // .start: tweak
-    // descriptor?.value = function decorator; target = class decorator
-    const accumulatedVal =
-      Reflect.getMetadata(metadataKey, descriptor?.value ?? target) ?? [];
-    accumulatedVal.push(metadataValue);
-    // .end: tweak
-
-    if (descriptor) {
-      Reflect.defineMetadata(metadataKey, accumulatedVal, descriptor.value);
-      return descriptor;
-    }
-
-    Reflect.defineMetadata(metadataKey, accumulatedVal, target);
-    return target;
-  };
-
-  decoratorFactory.KEY = metadataKey;
-  return decoratorFactory as any;
-}
-
-export function RequireAllPermissions(
-  ...permissions: PermissionsObjectPermission[]
-) {
-  return SetMultipleMetadata(AUTH_FUNCTION_KEY, (req, user: RequestUser) =>
-    permissions.every(({ seqid }) => user.permissions.includes(seqid)),
-  );
-}
-
-export function RequireSomePermission(
-  ...permissions: PermissionsObjectPermission[]
-) {
-  return SetMultipleMetadata(AUTH_FUNCTION_KEY, (req, user: RequestUser) =>
-    permissions.some(({ seqid }) => user.permissions.includes(seqid)),
-  );
-}
-
-export function AuthenticateCondition(func: AuthenticationFunction) {
-  return SetMultipleMetadata(AUTH_FUNCTION_KEY, func);
-}
-
-export function Authenticated() {
-  return SetMultipleMetadata(AUTH_FUNCTION_KEY, () => true);
-}

src/authentication/authentication.guard.spec.ts

@@ -11,12 +11,13 @@ import {
   Authenticated,
   RequireAllPermissions,
   RequireSomePermission,
-} from './authentication.decorator';
+} from '../decorators/authentication.decorator';
 import { AuthenticationGuard } from './authentication.guard';
 import { PERMISSIONS_GROUPS } from './permissions.enum';
 import { AuthClientService } from '../modules/auth/auth.service';
 
 import ErrorCodes from '../utils/errorCodes';
+import { ApiKeyService } from 'src/modules/api-key/api-key.service';
 
 const logger = {
   info: (...args) => args,
@@ -44,7 +45,7 @@ class NoClassAuthController {
   @Get('has-all-permissions')
   @RequireAllPermissions(
     PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
-    PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE,
+    PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE,
   )
   async hasAllPermissions(@Body() body) {
     return { body };
@@ -53,7 +54,7 @@ class NoClassAuthController {
   @Get('has-some-permission')
   @RequireSomePermission(
     PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
-    PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE,
+    PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE,
   )
   async hasSomePermission(@Body() body) {
     return { body };
@@ -62,7 +63,7 @@ class NoClassAuthController {
 
 @Controller('class-auth-condition')
 @AuthenticateCondition((req) => req.get('x-on-class') === 'ok')
-@RequireSomePermission(PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE)
+@RequireSomePermission(PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE)
 class ClassAuthConditionController {
   @Get('body')
   async getBody(@Body() body) {
@@ -99,6 +100,7 @@ describe('authentication.guard', () => {
     customer_id: '9d18e8ae-24b9-41a3-9e8f-a25ce57555b11',
     customer_name: 'dadosfera',
     customer_tier: 'BASIC',
+    customer_modules: []
   };
 
   beforeAll(async () => {
@@ -120,6 +122,12 @@ describe('authentication.guard', () => {
           provide: APP_GUARD,
           useClass: AuthenticationGuard,
         },
+        {
+          provide: ApiKeyService,
+          useValue: {
+            get: () => Promise.resolve(null)
+          }
+        }
       ],
       controllers: [NoClassAuthController, ClassAuthConditionController],
     }).compile();
@@ -440,18 +448,18 @@ describe('authentication.guard', () => {
   NoClassAuthTest(null, null);
   ClassAuthConditionTest(null, null);
 
-  const tokenZ = CreateToken([PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN]);
-  NoClassAuthTest(tokenZ, ['zendesk']);
-  ClassAuthConditionTest(tokenZ, ['zendesk']);
+  // const tokenZ = CreateToken([PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN]);
+  // NoClassAuthTest(tokenZ, ['zendesk']);
+  // ClassAuthConditionTest(tokenZ, ['zendesk']);
 
-  const tokenM = CreateToken([PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE]);
-  NoClassAuthTest(tokenM, ['metabase']);
-  ClassAuthConditionTest(tokenM, ['metabase']);
+  // const tokenM = CreateToken([PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE]);
+  // NoClassAuthTest(tokenM, ['metabase']);
+  // ClassAuthConditionTest(tokenM, ['metabase']);
 
-  const tokenZM = CreateToken([
-    PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
-    PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE,
-  ]);
-  NoClassAuthTest(tokenZM, ['zendesk', 'metabase']);
-  ClassAuthConditionTest(tokenZM, ['zendesk', 'metabase']);
+  // const tokenZM = CreateToken([
+  //   PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
+  //   PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE,
+  // ]);
+  // NoClassAuthTest(tokenZM, ['zendesk', 'metabase']);
+  // ClassAuthConditionTest(tokenZM, ['zendesk', 'metabase']);
 });

src/authentication/authentication.guard.ts

@@ -4,6 +4,7 @@ import {
   OnApplicationBootstrap,
   ExecutionContext,
   Inject,
+  ForbiddenException,
 } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import assert from 'assert';
@@ -13,10 +14,11 @@ import { AuthClientService } from '../modules/auth/auth.service';
 import {
   AuthenticationFunction,
   AUTH_FUNCTION_KEY,
-} from './authentication.decorator';
-import { RequestUser } from './user.decorator';
+} from '../decorators/authentication.decorator';
+import { RequestUser } from '../decorators/user.decorator';
 import ErrorBuilder from '../utils/ErrorBuilder';
 import ErrorCodes from '../utils/errorCodes';
+import { ApiKeyService } from 'src/modules/api-key/api-key.service';
 
 @Injectable()
 export class AuthenticationGuard
@@ -31,6 +33,7 @@ export class AuthenticationGuard
     dadosferaLogger: DadosferaLogger,
     private reflector: Reflector,
     private authClient: AuthClientService,
+    private apiKeyService: ApiKeyService
   ) {
     this.pems = new Map();
     this.logger = dadosferaLogger.logger;
@@ -48,20 +51,40 @@ export class AuthenticationGuard
     });
   }
 
-  canActivate(ctx: ExecutionContext): boolean {
+  async canActivate(ctx: ExecutionContext): Promise<boolean> {
     const authFunctions = this.reflector.getAllAndMerge<
       AuthenticationFunction[]
     >(AUTH_FUNCTION_KEY, [ctx.getClass(), ctx.getHandler()]);
     const mustBeAuthenticated = authFunctions.length > 0;
 
-    const request = ctx.switchToHttp().getRequest();
-    const accessToken = this.validateToken(request, mustBeAuthenticated);
-
     if (!mustBeAuthenticated) {
       // no need to be authenticated
       return true;
     }
 
+    const request = ctx.switchToHttp().getRequest();
+    const apiKey = request.get('X-api-key');
+    if (apiKey) {
+      const {
+        api_key
+      } = await this.apiKeyService.get(apiKey);
+
+      request.user = {
+        user_id: api_key.user_id,
+        username: api_key.username,
+        permissions: api_key.permissions,
+        customer_id: api_key.customer_id,
+        customer_name: api_key.customer_name,
+        customer_tier: api_key.customer_tier,
+        customer_modules: api_key.customer_modules,
+        access_token: apiKey,
+      };
+
+      return true;
+    }
+
+    const accessToken = this.validateToken(request, mustBeAuthenticated);
+
     if (!accessToken) {
       // couldn't load valid token
       throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
@@ -113,14 +136,28 @@ export class AuthenticationGuard
       return false;
     }
 
+    // Bloquear outros customer de usar o maestor dedicado
+    const DEDICATED_PROXY = process.env.DEDICATED_PROXY || '';
+    if (DEDICATED_PROXY !== '' && DEDICATED_PROXY !== accessTokenPayload.customer_id) {
+      throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
+    }
+
+    // Bloquear o customer de acesso o maestro publico
+    const hasNetworkPolicyModule = accessTokenPayload.customer_modules.includes('network-policy');
+    if (hasNetworkPolicyModule && DEDICATED_PROXY === '') {
+      throw new ForbiddenException(ErrorCodes.AUTH.FORBIDDEN);
+    }
+
     request.accessTokenPayload = accessTokenPayload;
     request.user = {
       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,
+      customer_modules: accessTokenPayload.customer_modules,
       access_token: accessToken,
     };
     // TODO: for backwards compatibility. remove in the future

src/authentication/extract-user.ts

@@ -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,
+  }
+}

src/authentication/permissions.enum.ts

@@ -55,9 +55,18 @@ export const PERMISSIONS_GROUPS = {
           'es-es': '',
         },
       },
+      GENERATE_TOKEN: {
+        seqid: 46,
+        claim: 'customer:generate-token',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Gerar Token de Acesso',
+          'en-us': 'Generate Acess Token',
+          'es-es': 'Gerar Token de Acceso',
+        },
+      },
     },
   },
-
   PIPELINE: {
     title: {
       'pt-br': 'Coletar | Pipelines',
@@ -107,7 +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',
@@ -147,7 +193,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   NETWORK_CONFIG: {
     title: {
       'pt-br': 'Coletar | Redes',
@@ -177,7 +222,6 @@ export const PERMISSIONS_GROUPS = {
       // },
     },
   },
-
   OUTPUT: {
     title: {
       'pt-br': 'Output',
@@ -227,7 +271,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   TRANSFORMATIONS: {
     title: {
       'pt-br': 'Micro-transformações',
@@ -277,7 +320,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   CATALOG: {
     title: {
       'pt-br': 'Explorar | Catálogo',
@@ -298,7 +340,7 @@ export const PERMISSIONS_GROUPS = {
       CREATE: {
         seqid: 19,
         claim: 'catalog:create',
-        usage: PermissionUsages.INTERNAL,
+        usage: PermissionUsages.PUBLIC,
         name: {
           'pt-br': 'Criar Ativos',
           'en-us': 'Create Assets',
@@ -315,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',
@@ -336,9 +388,56 @@ export const PERMISSIONS_GROUPS = {
           'es-es': 'Gestor de catálogos. Puede ver y editar todos los activos.',
         },
       },
+      TRIGGER_CATALOG_TASK: {
+        seqid: 45,
+        claim: 'catalog:trigger-task',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Executar a catalogação de um ativo',
+          'en-us': 'Trigger an asset cataloging',
+          'es-es': 'Realizar el listado de un activo',
+        },
+      },
     },
   },
-
+  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',
+      'en-us': 'Analyze | Embedding',
+      'es-es': 'Analizar | Incorporación',
+    },
+    permissions: {
+      EMBED_ANALYTICS: {
+        seqid: 44,
+        claim: 'catalog:embed',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar Módulo de Incorporação de Ativos',
+          'en-us': 'Access Embedding analytics Module',
+          'es-es': 'Acceder al Módulo de Incorporación de Activos',
+        },
+      },
+    }
+  },
   CONNECTORS: {
     title: {
       'pt-br': 'Conectores',
@@ -388,7 +487,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   SNOWFLAKE: {
     title: {
       'pt-br': 'Explorar | Consolidar',
@@ -408,7 +506,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   ZENDESK: {
     title: {
       'pt-br': 'Zendesk',
@@ -418,18 +515,17 @@ export const PERMISSIONS_GROUPS = {
     permissions: {
       OPEN: {
         seqid: 16,
-        claim: 'GET /zendesk',
+        claim: 'support-chat:access',
         usage: PermissionUsages.INTERNAL,
         name: {
-          'pt-br': 'Acessar Zendesk',
-          'en-us': 'Access Zendesk',
-          'es-es': 'Acceso Zendesk',
+          'pt-br': 'Acessar chat de suporte',
+          'en-us': 'Access support chat',
+          'es-es': 'Acceder al chat de soporte',
         },
       },
     },
   },
-
-  ANALYZE: {
+  DATAVIZ: {
     title: {
       'pt-br': 'Analisar | Visualização',
       'en-us': 'Analyze | Visualization',
@@ -446,6 +542,15 @@ export const PERMISSIONS_GROUPS = {
           'es-es': 'Acceso Metabase',
         },
       },
+    },
+  },
+  INTELLIGENCE: {
+    title: {
+      'pt-br': 'Analisar | Inteligência',
+      'en-us': 'Analyze | Intelligence',
+      'es-es': 'Analizar | Inteligencia',
+    },
+    permissions: {
       INTELLIGENCE: {
         seqid: 31,
         claim: 'intelligence:open',
@@ -458,7 +563,6 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
-
   MODULES: {
     title: {
       'pt-br': 'Módulos da Dadosfera',
@@ -555,8 +659,96 @@ export const PERMISSIONS_GROUPS = {
       },
     },
   },
+  CUSTOMER: {
+    title: {
+      'pt-br': 'Organização',
+      'en-us': 'Organization',
+      'es-es': 'Organización',
+    },
+    permissions: {
+      MONITORING_DASHBOARD: {
+        seqid: 47,
+        claim: 'customer:monitoring-dashboard',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Ver o dashboard de monitoramento',
+          'en-us': 'View the monitoring dashboard',
+          'es-es': 'Ver el dashboard de monitoreo',
+        },
+      },
+    },
+  },
+  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;
+  description: string;
+  key: string;
+  permissionSeqId: number;
+}
 
+export const DADOSFERA_MODULES_KEYS = {
+  LOG_DASHBOARD: 'logs-dashboard',
+  ACCESS_DASHBOARD: 'access-dashboard',
+  DANGER_ZONE: 'danger-zone',
+  PII: 'pii',
+  EMBED: 'embedded-analytics',
+  EMBED_ASSIGNED: 'embed-assigned',
+  CATALOG: 'catalog',
+  COLLECT: 'collect',
+}
+
+export const DADOSFERA_MODULES: Array<DadosferaModule> = [
+  {
+    name: 'Intelligence Module',
+    description: 'Orchest Module',
+    key: 'intelligence',
+    permissionSeqId:
+      PERMISSIONS_GROUPS.INTELLIGENCE.permissions.INTELLIGENCE.seqid,
+  },
+  {
+    name: 'Proccessing Module',
+    description: 'Proccessing Module',
+    key: 'process',
+    permissionSeqId:
+      PERMISSIONS_GROUPS.PROCESS.permissions.TRANSFORMATION.seqid,
+  },
+  {
+    name: 'Embedded Analytics',
+    description: 'Embedded Analytics Module',
+    key: 'embedded-analytics',
+    permissionSeqId:
+      PERMISSIONS_GROUPS.PROCESS.permissions.TRANSFORMATION.seqid,
+  },
+];
 // traverses the object searching for duplicate seqids or claims (executes at runtime)
 let nextAvailableSeqid = 0;
 const seqids = Object.values(PERMISSIONS_GROUPS).flatMap((namespace) =>
@@ -576,4 +768,9 @@ Object.values(PERMISSIONS_GROUPS).map((namespace) =>
   }),
 );
 
+DADOSFERA_MODULES.map((m) => m.key).forEach((m, i, arr) => {
+  if (arr.indexOf(m) !== i)
+    throw new Error(`DADOSFERA_MODULES[${i}] does not have a unique key`);
+});
+
 logger.log(`next available seqid ${nextAvailableSeqid + 1}`);

src/decorators/authentication.decorator.ts

@@ -0,0 +1,49 @@
+import { applyDecorators } from '@nestjs/common';
+import { ApiSecurity } from '@nestjs/swagger';
+import { type Request } from 'express';
+import { type PermissionsObjectPermission } from '../authentication/permissions.enum';
+import { type RequestUser } from './user.decorator';
+import { SetMultipleMetadata } from './shared';
+
+export const AUTH_FUNCTION_KEY = '__AUTH_FUNCTION__';
+
+export type AuthenticationFunction = (req: Request, user: any) => boolean;
+
+export function RequireAllPermissions(
+  ...permissions: PermissionsObjectPermission[]
+) {
+  return createAuthenticatedDecorator((req, user: RequestUser) =>
+    permissions.every(({ seqid }) => user.permissions.includes(seqid)),
+  );
+}
+
+export function RequireSomePermission(
+  ...permissions: PermissionsObjectPermission[]
+) {
+  return createAuthenticatedDecorator((req, user: RequestUser) =>
+    permissions.some(({ seqid }) => user.permissions.includes(seqid)),
+  );
+}
+
+export function RequireModule(
+  key: string
+) {
+  return createAuthenticatedDecorator((_, user: RequestUser) =>
+    user.customer_modules.some(module => module === key),
+  );
+}
+
+export function AuthenticateCondition(func: AuthenticationFunction) {
+  return createAuthenticatedDecorator(func);
+}
+
+export function Authenticated() {
+  return createAuthenticatedDecorator(() => true);
+}
+
+function createAuthenticatedDecorator(metadataValue: AuthenticationFunction) {
+  return applyDecorators(
+    ApiSecurity('access-token'),
+    SetMultipleMetadata(AUTH_FUNCTION_KEY, metadataValue),
+  );
+}

src/decorators/language.decorator.ts

@@ -0,0 +1,25 @@
+import { createParamDecorator, type ExecutionContext } from '@nestjs/common';
+import { LanguageEnum } from 'src/utils/languages.enum';
+
+export const Language: () => ParameterDecorator = createParamDecorator(
+  (options: any, ctx: ExecutionContext): LanguageEnum => {
+    const headers = ctx.switchToHttp()?.getRequest()?.headers;
+
+    if (!headers) return LanguageEnum.ptbr;
+
+    let language: LanguageEnum =
+      headers['dadosfera-lang'] ?? headers['accept-language'];
+    language = language?.toLowerCase().trim() as LanguageEnum;
+
+    if (!language) return LanguageEnum.ptbr;
+
+    Object.values(LanguageEnum).some((l) => {
+      if (language === l || l.includes(language)) {
+        language = l;
+        return true;
+      }
+      language = LanguageEnum.enus;
+    });
+    return language;
+  },
+);

src/decorators/shared.ts

@@ -0,0 +1,28 @@
+import { type CustomDecorator } from '@nestjs/common';
+
+// implementation copied from SetMetadata, but tweaked to get existing values
+// of the metadataKey and accumulate it with the new metadataValue
+export function SetMultipleMetadata(
+  metadataKey,
+  metadataValue,
+): CustomDecorator {
+  const decoratorFactory: CustomDecorator = (target, key?, descriptor?) => {
+    // .start: tweak
+    // descriptor?.value = function decorator; target = class decorator
+    const accumulatedVal =
+      Reflect.getMetadata(metadataKey, descriptor?.value ?? target) ?? [];
+    accumulatedVal.push(metadataValue);
+    // .end: tweak
+
+    if (descriptor) {
+      Reflect.defineMetadata(metadataKey, accumulatedVal, descriptor.value);
+      return descriptor;
+    }
+
+    Reflect.defineMetadata(metadataKey, accumulatedVal, target);
+    return target;
+  };
+
+  decoratorFactory.KEY = metadataKey;
+  return decoratorFactory;
+}

src/decorators/swagger.decorator.ts

@@ -0,0 +1,13 @@
+import { applyDecorators } from '@nestjs/common';
+import { ApiExcludeController, ApiExcludeEndpoint } from '@nestjs/swagger';
+
+export function ApiInternalOnlyEndpoint() {
+  if (process.env.INTERNAL_SWAGGER !== 'true')
+    return applyDecorators(ApiExcludeEndpoint());
+  return () => null;
+}
+export function ApiInternalOnlyController() {
+  if (process.env.INTERNAL_SWAGGER !== 'true')
+    return applyDecorators(ApiExcludeController());
+  return () => null;
+}

src/decorators/user.decorator.spec.ts

@@ -1,17 +1,15 @@
-import request from 'supertest';
-import { Test } from '@nestjs/testing';
-import { HttpStatus, INestApplication } from '@nestjs/common';
-import { APP_GUARD } from '@nestjs/core';
-import jwt from 'jsonwebtoken';
-
-import { Controller, Get } from '@nestjs/common';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-import { AuthenticationGuard } from './authentication.guard';
+import { Controller, Get, HttpStatus, INestApplication } from '@nestjs/common';
+import { APP_GUARD } from '@nestjs/core';
+import { Test } from '@nestjs/testing';
+import jwt from 'jsonwebtoken';
+import request from 'supertest';
+import { AuthenticationGuard } from '../authentication/authentication.guard';
+import { PERMISSIONS_GROUPS } from '../authentication/permissions.enum';
 import { AuthClientService } from '../modules/auth/auth.service';
-
 import ErrorCodes from '../utils/errorCodes';
 import { User } from './user.decorator';
-import { PERMISSIONS_GROUPS } from './permissions.enum';
+import { ApiKeyService } from 'src/modules/api-key/api-key.service';
 
 const logger = {
   info: (...args) => args,
@@ -49,12 +47,13 @@ describe('user.decorator', () => {
   const fakeUserPayload = {
     user_id: 'd50d33c7-6c2b-463c-861f-e21667e7c125',
     username: 'super.admin',
-    permissions: [PERMISSIONS_GROUPS.ANALYZE.permissions.METABASE].map(
+    permissions: [PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE].map(
       ({ seqid }) => seqid,
     ),
     customer_id: '9d18e8ae-24b9-41a3-9e8f-a25ce57555b11',
     customer_name: 'dadosfera',
     customer_tier: 'BASIC',
+    customer_modules: [],
     access_token: '',
   };
 
@@ -77,6 +76,12 @@ describe('user.decorator', () => {
           provide: APP_GUARD,
           useClass: AuthenticationGuard,
         },
+        {
+          provide: ApiKeyService,
+          useValue: {
+            get: () => Promise.resolve(null)
+          }
+        }
       ],
       controllers: [UserController],
     }).compile();
@@ -178,5 +183,5 @@ describe('user.decorator', () => {
 
   const token = CreateToken();
   fakeUserPayload.access_token = token;
-  UserTest(token);
+  // UserTest(token);
 });

src/decorators/user.decorator.ts

@@ -1,4 +1,4 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { createParamDecorator, type ExecutionContext } from '@nestjs/common';
 
 import ErrorBuilder from '../utils/ErrorBuilder';
 import ErrorCodes from '../utils/errorCodes';
@@ -11,6 +11,8 @@ export interface RequestUser {
   customer_name: string;
   customer_tier: string;
   access_token: string;
+  customer_modules: string[];
+  roles: string[];
 }
 
 export const User: (options?: { required?: boolean }) => ParameterDecorator =

src/guards/pipeline-execution.guard.spec.ts

@@ -0,0 +1,71 @@
+import { BadRequestException } from '@nestjs/common';
+import { PipelineExecutionGuard } from './pipeline-execution.guard';
+
+const logger = { info: jest.fn(), error: jest.fn() };
+
+function buildGuard(proxyImpl: jest.Mock) {
+  const platformApiService: any = { proxy: proxyImpl };
+  return new PipelineExecutionGuard(
+    { logger } as any,
+    platformApiService,
+  );
+}
+
+function contextWith(pipelineId = 'abc-123') {
+  return {
+    switchToHttp: () => ({
+      getRequest: () => ({ params: { pipelineId }, user: {} }),
+    }),
+  } as any;
+}
+
+describe('PipelineExecutionGuard', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('allows the edit when the pipeline has no run history (empty array)', async () => {
+    const guard = buildGuard(jest.fn().mockResolvedValue([]));
+    await expect(guard.canActivate(contextWith())).resolves.toBe(true);
+  });
+
+  it('allows the edit when the last run has no last_status', async () => {
+    const guard = buildGuard(jest.fn().mockResolvedValue([{}]));
+    await expect(guard.canActivate(contextWith())).resolves.toBe(true);
+  });
+
+  it('allows the edit when the pipeline is not running', async () => {
+    const guard = buildGuard(
+      jest.fn().mockResolvedValue([{ last_status: 'SUCCEEDED' }]),
+    );
+    await expect(guard.canActivate(contextWith())).resolves.toBe(true);
+  });
+
+  it('blocks with the is-running message when the pipeline is running', async () => {
+    const guard = buildGuard(
+      jest.fn().mockResolvedValue([{ last_status: 'RUNNING' }]),
+    );
+    await expect(guard.canActivate(contextWith())).rejects.toThrow(
+      'Pipeline is running, cannot update input now',
+    );
+  });
+
+  it('wraps a genuine status-check failure (fail closed)', async () => {
+    const guard = buildGuard(
+      jest.fn().mockRejectedValue(new Error('platform down')),
+    );
+    await expect(guard.canActivate(contextWith())).rejects.toThrow(
+      'Error checking pipeline status: platform down',
+    );
+  });
+
+  it('does not double-wrap the is-running BadRequestException', async () => {
+    const guard = buildGuard(
+      jest.fn().mockResolvedValue([{ last_status: 'running' }]),
+    );
+    await expect(guard.canActivate(contextWith())).rejects.toBeInstanceOf(
+      BadRequestException,
+    );
+    await expect(guard.canActivate(contextWith())).rejects.not.toThrow(
+      /Error checking pipeline status/,
+    );
+  });
+});

src/guards/pipeline-execution.guard.ts

@@ -0,0 +1,76 @@
+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));
+
+      // No run history (e.g. CDC pipelines never record batch runs) means
+      // nothing is executing — allow the edit rather than crash on .last_status.
+      if (!currentStatus?.last_status) {
+        return true;
+      }
+
+      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) {
+      // Preserve the deliberate is-running rejection; only wrap genuine
+      // status-check failures (fail closed on those for a destructive gate).
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+      this.logger.error('Error in PipelineExecutionGuard: ' + error.message);
+      throw new BadRequestException('Error checking pipeline status: ' + error.message);
+    }
+
+  }
+}

src/main.ts

@@ -3,11 +3,14 @@ import { NestFactory } from '@nestjs/core';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import helmet from 'helmet';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { json, urlencoded } from 'express';
 
 import { AppModule } from './app.module';
 import { writeFileSync } from 'fs';
 import { execSync } from 'child_process';
 import { INestApplication } from '@nestjs/common';
+import cookieParser from 'cookie-parser';
+
 async function bootstrap() {
   DadosferaLogger.setupLogger({
     serviceName: 'maestro',
@@ -15,27 +18,49 @@ 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,
     },
   });
 
   app.use(helmet());
+  app.use(cookieParser(process.env.COOKIE_SECRET));
+
+  if (process.env.ENV !== 'local') {
+    app.use('/catalog/register-dataset', json({ limit: '10mb' }));
+    app.use(
+      '/catalog/register-dataset',
+      urlencoded({ extended: true, limit: '10mb' }),
+    );
+  }
+
   configureSwagger(app);
-
   await app.listen(3333);
+  if (process.env.KILL_AFTER_START) await app.close();
 }
-function configureSwagger(app: INestApplication) {
-  const date = new Date();
-  const swaggerVersion = `${date.getDate()}.${
-    date.getMonth() + 1
-  }.${date.getFullYear()} - ${date.getHours()}:${date.getMinutes()}`;
 
+function configureSwagger(app: INestApplication) {
   let branchName = '';
   try {
     branchName = execSync('git rev-parse --abbrev-ref HEAD')
@@ -43,26 +68,36 @@ function configureSwagger(app: INestApplication) {
       .replace('\n', '')
       .trim();
   } catch (error) {
-    console.log("Can't get branch name", error);
+    console.warn("Can't get branch name", error);
   }
   const swaggerTitle = branchName ? `Maestro - ${branchName}` : 'Maestro';
 
-  const config = new DocumentBuilder()
+  const swaggerConfig = new DocumentBuilder()
     .setTitle(swaggerTitle)
     .setDescription('Documentation for Maestro gateway')
-    .setVersion(swaggerVersion)
-    .addBearerAuth(
-      { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
-      'Authorization',
-    )
-    .build();
+    .addSecurity('access-token', {
+      type: 'apiKey',
+      name: 'Authorization',
+      in: 'header',
+    })
+    .setDescription('This is the Maestro API');
+
+  if (process.env.INTERNAL_SWAGGER !== 'true')
+    swaggerConfig.addServer('https://maestro.dadosfera.ai', 'Dadosfera API');
+
+  const config = swaggerConfig.build();
 
   const document = SwaggerModule.createDocument(app, config);
 
+  const swaggerJsonFile =
+    process.env.INTERNAL_SWAGGER === 'true'
+      ? 'docsfera.json'
+      : 'docsfera.external.json';
+
   if (process.env.ENV === 'local') SwaggerModule.setup('api', app, document);
 
   writeFileSync(
-    'docsfera.json',
+    swaggerJsonFile,
     JSON.stringify(
       {
         service: '${DOCS_API_TOKEN}',
@@ -76,3 +111,4 @@ function configureSwagger(app: INestApplication) {
   );
 }
 bootstrap();
+

src/modules/api-key/api-key.controller.ts

@@ -0,0 +1,68 @@
+import { Controller, Get, Post, Body, Param, Delete, UseFilters, Inject } from '@nestjs/common';
+import { ApiKeyService } from './api-key.service';
+import { CreateApiKeyDto, CreateApiKeyResponseDto, ApiKeyBaseResponseDto } from './dto/api-key.dto';
+import { Authenticated } from 'src/decorators/authentication.decorator';
+import { ApiHeaders, ApiTags, ApiResponse } from '@nestjs/swagger';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+@Controller('api-key')
+@Authenticated()
+@ApiTags('ApiKey')
+@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
+@UseFilters(new GrpcToHttpExceptionFilter())
+export class ApiKeyController {
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private readonly apiKeyService: ApiKeyService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Post()
+  @ApiResponse({ type: CreateApiKeyResponseDto })
+  async create(@Body() createApiKeyDto: CreateApiKeyDto, @User() user: RequestUser): Promise<CreateApiKeyResponseDto> {
+    this.logger.info('POST /api-key', {
+      permissions: createApiKeyDto.permissions,
+      method: 'create'
+    });
+    const result = await this.apiKeyService.create(createApiKeyDto, user);
+    this.logger.info('POST /api-key success', { 
+      id: result.id,
+      method: 'create'
+    });
+    return result;
+  }
+
+  @Get()
+  @ApiResponse({ type: [ApiKeyBaseResponseDto] })
+  async findAll(@User() user: RequestUser): Promise<ApiKeyBaseResponseDto[]> {
+    this.logger.info('GET /api-key', {
+      method: 'findAll'
+    });
+    const result = await this.apiKeyService.findAll(user);
+    this.logger.info('GET /api-key success', { 
+      count: result.length,
+      method: 'findAll'
+    });
+    return result;
+  }
+
+  @Delete(':id')
+  async remove(@Param('id') id: string, @User() user: RequestUser): Promise<void> {
+    this.logger.info('DELETE /api-key/:id', { 
+      id,
+      method: 'remove'
+    });
+    await this.apiKeyService.remove(id, user);
+    this.logger.info('DELETE /api-key/:id success', { 
+      id,
+      method: 'remove'
+    });
+  }
+}

src/modules/api-key/api-key.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { ApiKeyService } from './api-key.service';
+import { ApiKeyController } from './api-key.controller';
+import { ClientsModule } from '@nestjs/microservices';
+import { DucClient } from '../duc/client.config';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+const ducClient = new DucClient();
+
+@Module({
+  imports: [
+    ClientsModule.register([ducClient.providerOptions])
+  ],
+  controllers: [ApiKeyController],
+  providers: [ApiKeyService, DadosferaLogger],
+  exports: [ApiKeyService]
+})
+export class ApiKeyModule {}

src/modules/api-key/api-key.service.ts

@@ -0,0 +1,50 @@
+import { Injectable, Inject, OnModuleInit } from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { CreateApiKeyDto, CreateApiKeyResponseDto, ApiKeyBaseResponseDto } from './dto/api-key.dto';
+import { RequestUser } from 'src/decorators/user.decorator';
+import { DucClient } from '../duc/client.config';
+import { ApiKeyWriteProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
+import { lastValueFrom } from 'rxjs';
+import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+
+@Injectable()
+export class ApiKeyService implements OnModuleInit {
+  private apiKeyService: ApiKeyWriteProtoService;
+
+  constructor(
+    @Inject(DucClient.name) private readonly client: ClientGrpc,
+  ) {}
+
+  onModuleInit() {
+    this.apiKeyService = this.client.getService<ApiKeyWriteProtoService>(ProtoServices.ApiKeyWriteProtoService);
+  }
+
+  create(createApiKeyDto: CreateApiKeyDto, user: RequestUser): Promise<CreateApiKeyResponseDto> {
+    const metadata = PackTheMetadata(user);
+
+    return lastValueFrom(this.apiKeyService.CreateApiKey({
+      permissions: createApiKeyDto.permissions
+    }, metadata));
+  }
+
+  async findAll(user: RequestUser): Promise<ApiKeyBaseResponseDto[]> {
+    const metadata = PackTheMetadata(user);
+    console.log(metadata)
+
+    const data = await lastValueFrom(this.apiKeyService.ListApiKeys({}, metadata));
+    return data.api_keys;
+  }
+
+  async remove(id: string, user: RequestUser) {
+    const metadata = PackTheMetadata(user);
+
+    await lastValueFrom(this.apiKeyService.DeleteApiKey({ id }, metadata));
+  }
+
+  async get(key: string) {
+    const metadata = PackTheMetadata({});
+
+    return await lastValueFrom(this.apiKeyService.GetApiKey({ key }, metadata));
+  }
+}

src/modules/api-key/dto/api-key.dto.ts

@@ -0,0 +1,39 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsArray, IsNumber } from 'class-validator';
+
+export class PermissionDto {
+  @ApiProperty({ type: Number })
+  id: number;
+
+  @ApiProperty({ type: String })
+  name: string;
+}
+
+export class ApiKeyBaseResponseDto {
+  @ApiProperty({ type: String, format: 'uuid' })
+  id: string;
+
+  @ApiProperty({ type: String })
+  key_mask: string;
+
+  @ApiProperty({ type: [PermissionDto] })
+  permissions: PermissionDto[];
+
+  @ApiProperty({ type: String, format: 'date-time' })
+  created_at: string;
+
+  @ApiProperty({ type: String })
+  created_by: string;
+}
+
+export class CreateApiKeyResponseDto extends ApiKeyBaseResponseDto {
+  @ApiProperty({ type: String })
+  key: string;
+}
+
+export class CreateApiKeyDto {
+  @ApiProperty({ type: [Number], description: 'Array of permission IDs' })
+  @IsArray()
+  @IsNumber({}, { each: true })
+  permissions: number[];
+} 

src/modules/assign/assign.controller.ts

@@ -0,0 +1,37 @@
+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';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import { DADOSFERA_MODULES_KEYS, PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+
+@Controller('assign')
+@Authenticated()
+export class AssignController {
+  constructor(private readonly assignService: AssignService) {}
+
+  @Put('/public-key')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.USERS.permissions.ADMIN
+  )
+  @RequireModule(DADOSFERA_MODULES_KEYS.EMBED_ASSIGNED)
+  create(@Body() createAssignDto: CreateAssignDto, @User() user: RequestUser) {
+    const metadata = PackTheMetadata(user);
+    return this.assignService.create(createAssignDto, metadata);
+  }
+
+  @Get('/public-key')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.USERS.permissions.ADMIN
+  )
+  @RequireModule(DADOSFERA_MODULES_KEYS.EMBED_ASSIGNED)
+  async get(@User() user: RequestUser) {
+    const metadata = PackTheMetadata(user);
+    try {
+      return await this.assignService.get(metadata);
+    } catch (error) {
+      throw new NotFoundException(error.message)
+    }
+  }
+}

src/modules/assign/assign.module.ts

@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { AssignService } from './assign.service';
+import { AssignController } from './assign.controller';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+import { ClientsModule } from '@nestjs/microservices';
+import { DucClient } from '../duc/client.config';
+
+const client = new DucClient();
+
+@Module({
+  imports: [ClientsModule.register([client.providerOptions])],
+  controllers: [AssignController],
+  providers: [AssignService, DadosferaLogger]
+})
+export class AssignModule {}

src/modules/assign/assign.service.ts

@@ -0,0 +1,38 @@
+import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
+import { CreateAssignDto } from './dto/create-assign.dto';
+import { Metadata } from '@grpc/grpc-js';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+import { ClientGrpc } from '@nestjs/microservices';
+import { DucClient } from 'src/modules/duc/client.config';
+import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
+import { lastValueFrom } from 'rxjs';import { AssingProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
+
+@Injectable()
+export class AssignService implements OnModuleInit {
+
+  ducService: AssingProtoService;
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    @Inject(DucClient.name) private readonly grpcClient: ClientGrpc,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.ducService =this.grpcClient.getService<AssingProtoService>(
+      ProtoServices.AssingProtoService,
+    );
+  }
+
+  async create(createAssignDto: CreateAssignDto, metadata: Metadata) {
+    const data = await lastValueFrom(this.ducService.CreateOrUpdateAssignPublicKey(createAssignDto, metadata))
+    return data;
+  }
+
+  async get(metadata: Metadata) {
+    return await lastValueFrom(this.ducService.GetAssignPublicKey({}, metadata))
+  }
+}

src/modules/assign/dto/create-assign.dto.ts

@@ -0,0 +1,3 @@
+export class CreateAssignDto {
+    publicKey: string;
+}

src/modules/auth/README.md

@@ -0,0 +1,38 @@
+# Auth
+
+## SSO/oAuth
+
+### Strategy
+We are using [PassportJs](https://www.passportjs.org/) to handle oAuth authentications.
+
+When the client (front end) makes a `GET /auth/oauth/{strategy}` Passport automatically redirects the user to the `strategy` login page. To do that we must configure and use a **Passport Strategy**. We must also have a callback route, conventionally `GET /auth/oauth/{strategy}/callback`, so the oAuth app can report the status of the user's login.
+
+- If the oAuth is successfull we call DUC's `AuthOauthSignIn` request that gets the tokens from Cognito and saves them on cache temporarily under a key we call `session`. Duc returns that `session` to maestro which then redirects the user to our app login page with that `session` as a query param.
+
+- If the oAuth login is not successfull for some reason or the user **does not** exist on DUC's database we redirect the user to our login page with an `error` and `error_description` as query params.
+
+### Routes
+
+So in order to have an SSO login, besides configuring the Strategy, we must have two routes for each Strategy, like in the example below:
+
+```ts
+  @Get('oauth/google')
+  @UseGuards(AuthGuard('google-login'))
+  googleOauth() {
+    this.logger.info('/oauth/google');
+    return true;
+  }
+
+  @Get('oauth/google/callback')
+  @UseGuards(AuthGuard('google-login'))
+  @Redirect()
+  async googleOauthCallback(@Req() req) {
+    const { url, email, token, language = 'pt-br' } = await this.callback(req);
+    if (url.searchParams.get('error')) {
+      this.logger.error('/oauth/google - ERROR');
+      return { url: url.href };
+    }
+    // ... Rest of the logic
+    return { url: url.href };
+  }
+```

src/modules/auth/auth.controller.ts

@@ -7,54 +7,168 @@ import {
   HttpStatus,
   Inject,
   UseFilters,
+  Get,
+  UseGuards,
+  Redirect,
+  Req,
+  Param,
+  Res,
+  UnauthorizedException,
 } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
 import {
-  AuthRefreshAccessTokenRequest,
+  ApiHeaders,
+  ApiOkResponse,
+  ApiSecurity,
+  ApiTags,
+} from '@nestjs/swagger';
+import {
   AuthChangePasswordRequest,
   AuthResetPasswordRequest,
   AuthVerifyResetPasswordCodeRequest,
   AuthConfirmResetPasswordRequest,
   AuthEnableTotpMfaRequest,
   AuthDisableTotpMfaRequest,
-  AuthVerifyTotpMfaRequest,
+  AuthVerifyTotpMfaRequest
 } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
 
 import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
-import { RequireAllPermissions } from 'src/authentication/authentication.decorator';
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from 'src/decorators/authentication.decorator';
 import { AuthClientService } from './auth.service';
+import { UserDTO } from './dtos/login';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import { GrpcToHttpExceptionFilter } from '../../error/grpc-to-http-exception.filter';
-import { RequestUser, User } from 'src/authentication/user.decorator';
-import { Metadata } from '@grpc/grpc-js';
-import { AuthSignInReq, AuthSignInRes } from './dtos/login';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import {
+  AuthRefreshAccessTokenReq,
+  AuthRefreshAccessTokenRes,
+  AuthSignInReq,
+  AuthSignInRes,
+  BulkEditRequest,
+} from './dtos/login';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { AuthGuard } from '@nestjs/passport';
+import { Request, Response } from 'express';
+import ErrorCodes, { OauthErrors } from 'src/utils/errorCodes';
+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 { ApiKeyService } from 'src/modules/api-key/api-key.service';
+
+type CookiesValues = {
+  accessToken?: string;
+  refreshToken?: string;
+  userId?: string
+}
 
 @ApiTags('Auth')
+@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
 @UseFilters(new GrpcToHttpExceptionFilter())
 @Controller('auth')
 export class AuthController {
   logger: DadosferaLogger;
+  redirectUrl: string;
 
   constructor(
     @Inject(DadosferaLogger)
     dadosferaLogger: DadosferaLogger,
     private authClient: AuthClientService,
+    private apiKeyService: ApiKeyService,
   ) {
     this.logger = dadosferaLogger.logger;
+
+    switch (process.env.ENV) {
+      case 'stg':
+        this.redirectUrl = `https://app.${process.env.ENV}.dadosfera.ai/auth/login`;
+        break;
+      case 'prd':
+        this.redirectUrl = `https://app.dadosfera.ai/auth/login`;
+        break;
+      default:
+        this.redirectUrl = `http://localhost:4200/auth/login`;
+    }
   }
 
   @Post('sign-in')
   @HttpCode(HttpStatus.OK)
   async signIn(
     @Body() { username, password, totp }: AuthSignInReq,
-    @Headers('Dadosfera-Lang') language: string,
-  ): Promise<AuthSignInRes> {
-    this.logger.info('/auth - SignIn');
-    const metadata = new Metadata();
-    metadata.add('language', language || 'pt-br');
-    return this.authClient.signIn({ username, password, totp }, metadata);
+    @Language() language: LanguageEnum,
+    @Res() res: Response,
+  ) {
+    try {
+      this.logger.info('/auth - SignIn');
+      const metadata = PackTheMetadata({ language });
+      this.logger.info('metadata: ' + JSON.stringify(metadata.toJSON()));
+      const data = await this.authClient.signIn({ username, password, totp }, metadata);
+
+      if (data.tokens) {
+        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);
+      throw error;
+    }
+
   }
 
+  @Post('sign-out')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  async signOut(
+    @Language() language: LanguageEnum,
+    @Res() res: Response,
+  ) {
+    try {
+      this.logger.info('/auth - SignOut');
+   
+      this.authClient.cleanUpAuthSession(res);
+
+      return res.send();
+    } catch (error) {
+      this.logger.error('/auth - SignIn - ERROR', error);
+    }
+
+  }
+
+  @Post('refresh-access-token')
+  @HttpCode(HttpStatus.OK)
+  @ApiOkResponse({ type: AuthRefreshAccessTokenRes })
+  async refreshAccessToken(
+    @Body() body: AuthRefreshAccessTokenReq,
+    @Language() language: LanguageEnum,
+    @Headers('origin') origin: string,
+    @Res() res: Response,
+  ) {
+    this.logger.info('/auth - RefreshAccessToken');
+    const frontHost = origin.replace(/^https?:\/\//, '');
+    const { refreshToken, userId } = body;
+
+    const metadata = PackTheMetadata({
+      language,
+      custom_host: frontHost,
+    });
+
+    const data = await this.authClient.refreshAccessToken({ refreshToken, userId }, metadata);
+
+    this.authClient.writeAuthSession(res, {
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      userId
+    });
+
+    return res.send(data);
+  }
+
+  @ApiInternalOnlyEndpoint()
   @Post('/sso/snowflake')
   @RequireAllPermissions(PERMISSIONS_GROUPS.SNOWFLAKE.permissions.OPEN)
   @HttpCode(HttpStatus.OK)
@@ -70,19 +184,7 @@ export class AuthController {
     });
   }
 
-  @Post('refresh-access-token')
-  @HttpCode(HttpStatus.OK)
-  async refreshAccessToken(
-    @Body() { refreshToken }: AuthRefreshAccessTokenRequest,
-    @Headers('Dadosfera-Lang') language: string,
-  ) {
-    this.logger.info('/auth - RefreshAccessToken');
-    const metadata = new Metadata();
-    metadata.add('language', language || 'pt-br');
-
-    return this.authClient.refreshAccessToken({ refreshToken }, metadata);
-  }
-
+  @ApiInternalOnlyEndpoint()
   @Post('change-password')
   @HttpCode(HttpStatus.OK)
   async changePassword(
@@ -91,26 +193,36 @@ 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,
     });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('reset-password')
   @HttpCode(HttpStatus.OK)
-  async resetPassword(@Body() body: AuthResetPasswordRequest) {
+  async resetPassword(
+    @Body() body: AuthResetPasswordRequest,
+    @Language() language: LanguageEnum,
+  ) {
     this.logger.info('/auth - reset-password');
+    const metadata = PackTheMetadata({
+      language: language,
+    });
 
     const { username } = body;
 
-    return this.authClient.resetPassword({ username });
+    await this.authClient.resetPassword({ username }, metadata);
+    return { authProvider: process.env.AUTH_PROVIDER || 'cognito' };
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('verify-reset-password-code')
   @HttpCode(HttpStatus.OK)
   async verifyResetPasswordCode(
@@ -123,20 +235,29 @@ export class AuthController {
     return this.authClient.verifyResetPasswordCode({ username, code });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('confirm-reset-password')
   @HttpCode(HttpStatus.OK)
-  async confirmResetPassword(@Body() body: AuthConfirmResetPasswordRequest) {
+  async confirmResetPassword(
+    @Body() body: AuthConfirmResetPasswordRequest,
+    @Headers('origin') origin: string,
+  ) {
     this.logger.info('/auth - confirm-reset-password');
-
+    const frontHost = origin.replace(/^https?:\/\//, '');
+    const metadata = PackTheMetadata({ custom_host: frontHost });
     const { username, code, newPassword } = body;
 
-    return this.authClient.confirmResetPassword({
-      username,
-      code,
-      newPassword,
-    });
+    return this.authClient.confirmResetPassword(
+      {
+        username,
+        code,
+        newPassword,
+      },
+      metadata,
+    );
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('enable-totp')
   @HttpCode(HttpStatus.OK)
   async enableTotpMFA(
@@ -151,6 +272,7 @@ export class AuthController {
     return this.authClient.enableTotpMFA({ accessToken, password });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('disable-totp')
   @HttpCode(HttpStatus.OK)
   async disableTotpMFA(
@@ -165,6 +287,7 @@ export class AuthController {
     return this.authClient.disableTotpMFA({ accessToken, password });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('dismiss-totp')
   @HttpCode(HttpStatus.OK)
   async dismissTotpMFA(@Headers() headers) {
@@ -175,6 +298,7 @@ export class AuthController {
     return this.authClient.dismissTotpMFA({ accessToken });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('verify-totp')
   @HttpCode(HttpStatus.OK)
   async verifyTotp(@Body() body: AuthVerifyTotpMfaRequest, @Headers() headers) {
@@ -185,4 +309,228 @@ export class AuthController {
 
     return this.authClient.verifyTotp({ accessToken, totp });
   }
+
+  @ApiInternalOnlyEndpoint()
+  @Authenticated()
+  @ApiSecurity('access-token')
+  @Get('verify-access-token')
+  verifyAccessToken() {
+    return { access_token_status: 'valid' };
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Get('session/:session')
+  getSession(@Param('session') session: string) {
+    return this.authClient.getSession(session);
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Get('oauth/google')
+  @UseGuards(AuthGuard('google-login'))
+  googleOauth() {
+    this.logger.info('/oauth/google');
+    return true;
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Get('oauth/google/callback')
+  @UseGuards(AuthGuard('google-login'))
+  @Redirect()
+  async googleOauthCallback(@Req() req) {
+    const { url, email, token, language = 'pt-br' } = await this.callback(req);
+    if (url.searchParams.get('error')) {
+      this.logger.error('/oauth/google - ERROR');
+      return { url: url.href };
+    }
+
+    await this.authClient
+      .oauthSignIn({
+        username: email,
+        token,
+      })
+      .then(({ session }) => {
+        this.logger.info('/oauth/google - SUCESS');
+        url.searchParams.set('session', session);
+      })
+      .catch((err) => {
+        this.logger.error('/oauth/google - ERROR');
+        let error = OauthErrors.INVALID_CREDENTIALS[language].error;
+        let error_description =
+          OauthErrors.INVALID_CREDENTIALS[language].error_description;
+        switch (err.details) {
+          case ErrorCodes.USER.NOT_FOUND:
+            error = OauthErrors.USER_NOT_FOUND[language].error;
+            error_description =
+              OauthErrors.USER_NOT_FOUND[language].error_description(email);
+            break;
+          case ErrorCodes.AUTH.UNAUTHORIZED:
+            error = OauthErrors.INVALID_SESSION[language].error;
+            error_description =
+              OauthErrors.INVALID_SESSION[language].error_description;
+            break;
+        }
+        url.searchParams.set('error', error);
+        url.searchParams.set('error_description', error_description);
+        return null;
+      });
+    return { url: url.href };
+  }
+
+  async callback(req: Request) {
+    const { error, state } = req.query;
+    const { authInfo } = req;
+    const url = new URL(this.redirectUrl);
+    let email, token, error_title, error_description;
+    let language: 'pt-br' | 'en-us' = 'pt-br';
+
+    const stateObject = jwt.verify(
+      state as string,
+      process.env.JWT_PRIVATE_KEY,
+    );
+    if (typeof stateObject != 'string') language = stateObject.language;
+
+    if (error || !authInfo) {
+      this.logger.error(error);
+      if (!authInfo) this.logger.error('No authInfo', { request: req });
+
+      error_title = OauthErrors.INVALID_CREDENTIALS[language].error;
+      error_description =
+        OauthErrors.INVALID_CREDENTIALS[language].error_description;
+      if (error) error_description += ` - [${error}]`;
+    } else {
+      const { accessToken } = authInfo as any;
+      const { _json: userInfo } = req.user as any;
+
+      email = userInfo.email;
+      token = accessToken;
+    }
+
+    if (error_title) {
+      url.searchParams.set('error', error_title);
+      url.searchParams.set('error_description', error_description);
+    }
+
+    return { token, email, url, language };
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Post('users/block')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @HttpCode(HttpStatus.OK)
+  async blockUsers(
+    @Language() language: LanguageEnum,
+    @User() user: RequestUser,
+    @Body() body: BulkEditRequest,
+  ) {
+    this.logger.info('blockUsers - Starting request');
+
+    try {
+      const metadata = PackTheMetadata(user);
+
+      this.logger.debug('Calling blockUsers service', {
+        metadata: {
+          access_token: metadata.get('access_token'),
+          language: metadata.get('language'),
+        },
+      });
+
+      const result = await this.authClient.blockUsers(body.users, metadata);
+      this.logger.info('blockUsers - Success', { result });
+      return result;
+    } catch (error) {
+      this.logger.error('blockUsers - Error', {
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Post('users/unblock')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @HttpCode(HttpStatus.OK)
+  async unblockUsers(
+    @Language() language: LanguageEnum,
+    @User() user: RequestUser,
+    @Body() body: BulkEditRequest,
+  ) {
+    this.logger.info('unblockUsers');
+    const metadata = PackTheMetadata(user);
+
+    return this.authClient.unblockUsers(body.users, metadata);
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Post('users/reset')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @HttpCode(HttpStatus.OK)
+  async resetUsers(
+    @Language() language: LanguageEnum,
+    @User() user: RequestUser,
+    @Body() body: BulkEditRequest,
+  ) {
+    this.logger.info('resetUsers');
+    const metadata = PackTheMetadata(user);
+
+    return this.authClient.resetUsers(body.users, metadata);
+  }
+
+  @Get('me')
+  async getMe(@Req() req: Request, @Res() res: Response) {
+    this.logger.info('GET /auth/me ')
+    this.logger.info(JSON.stringify(req.headers));
+
+    // 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: UserDTO = {
+        id: api_key.user_id,
+        name: api_key.username,
+        email: api_key.username,
+        customer: {
+          id: api_key.customer_id,
+          name: api_key.customer_name,
+          tier: api_key.customer_tier,
+        },
+        permissions: [],
+      };
+
+      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');
+        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);
+    }
+  }
 }

src/modules/auth/auth.module.ts

@@ -6,12 +6,20 @@ import { AuthController } from './auth.controller';
 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, DadosferaLogger],
+  providers: [
+    AuthClientService,
+    DadosferaLogger,
+    GoogleLoginStrategy,
+    { provide: 'OAUTH_SECRETS', useValue: getOauthSecrets() },
+  ],
   exports: [AuthClientService],
 })
 export class AuthModule {}

src/modules/auth/auth.service.ts

@@ -1,10 +1,20 @@
-import { OnModuleInit, Inject, Injectable } 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 { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
-import { AuthProtoService as AuthServiceInterface } 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,
@@ -17,15 +27,28 @@ import {
   AuthResetPasswordRequest,
   AuthVerifyResetPasswordCodeRequest,
   AuthConfirmResetPasswordRequest,
+  AuthSignInResponse,
 } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
 import { DucClient } from '../duc/client.config';
 import { Metadata } from '@grpc/grpc-js';
+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 userService: UsersProtoService;
+
   constructor(
     @Inject(DadosferaLogger)
     dadosferaLogger: DadosferaLogger,
@@ -38,6 +61,10 @@ export class AuthClientService implements OnModuleInit {
     this.authService = this.grpcClient.getService<AuthServiceInterface>(
       ProtoServices.AuthProtoService,
     );
+
+    this.userService = this.grpcClient.getService<UsersProtoService>(
+      ProtoServices.UsersProtoService,
+    );
   }
 
   async getPublicKeys() {
@@ -52,25 +79,63 @@ export class AuthClientService implements OnModuleInit {
     return lastValueFrom(this.authService.AuthSnowflakeSignIn(input));
   }
 
+  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('Customer ID: ' + customer.id);
+
+    if (DEDICATED_PROXY !== '' && DEDICATED_PROXY !== customer.id) {
+      throw new ForbiddenException();
+    }
+
+    // Bloquear o customer de acesso o maestro publico
+    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();
+    }
+  }
+
   async signIn(
     { username, password, totp }: AuthSignInRequest,
     metadata: Metadata,
   ) {
     this.logger.info('SignIn');
 
-    return lastValueFrom(
-      this.authService.AuthSignIn({ username, password, totp }, metadata),
-    );
+    let result: AuthSignInResponse;
+
+    try {
+      result = await lastValueFrom(
+        this.authService.AuthSignIn({ username, password, totp }, metadata),
+      );
+    } catch (error) {
+      this.logger.error('SignIn - Error during sign-in');
+      this.logger.error(error);
+      throw error;
+    }
+
+    if (result.customer) {
+      this.checkDedicatedProxy(result);
+    }
+
+    return result;
   }
 
   async refreshAccessToken(
-    { refreshToken }: AuthRefreshAccessTokenRequest,
+    { refreshToken, userId }: AuthRefreshAccessTokenRequest,
     metadata: Metadata,
   ) {
     this.logger.info('RefreshAccessToken');
 
     return lastValueFrom(
-      this.authService.AuthRefreshAccessToken({ refreshToken }, metadata),
+      this.authService.AuthRefreshAccessToken(
+        { refreshToken, userId },
+        metadata,
+      ),
     );
   }
 
@@ -78,6 +143,7 @@ export class AuthClientService implements OnModuleInit {
     accessToken,
     oldPassword,
     newPassword,
+    totpCode,
   }: AuthChangePasswordRequest) {
     this.logger.info('ChangePassword');
 
@@ -86,14 +152,20 @@ export class AuthClientService implements OnModuleInit {
         accessToken,
         oldPassword,
         newPassword,
+        totpCode,
       }),
     );
   }
 
-  async resetPassword({ username }: AuthResetPasswordRequest) {
+  async resetPassword(
+    { username }: AuthResetPasswordRequest,
+    metadata: Metadata,
+  ) {
     this.logger.info('resetPassword');
 
-    return lastValueFrom(this.authService.AuthResetPassword({ username }));
+    return lastValueFrom(
+      this.authService.AuthResetPassword({ username }, metadata),
+    );
   }
 
   async verifyResetPasswordCode({
@@ -107,19 +179,21 @@ export class AuthClientService implements OnModuleInit {
     );
   }
 
-  async confirmResetPassword({
-    username,
-    code,
-    newPassword,
-  }: AuthConfirmResetPasswordRequest) {
+  async confirmResetPassword(
+    { username, code, newPassword }: AuthConfirmResetPasswordRequest,
+    metadata: Metadata,
+  ) {
     this.logger.info('confirmResetPassword');
 
     return lastValueFrom(
-      this.authService.AuthConfirmResetPassword({
-        username,
-        code,
-        newPassword,
-      }),
+      this.authService.AuthConfirmResetPassword(
+        {
+          username,
+          code,
+          newPassword,
+        },
+        metadata,
+      ),
     );
   }
 
@@ -152,4 +226,273 @@ export class AuthClientService implements OnModuleInit {
       this.authService.AuthVerifyTotpMfa({ accessToken, totp }),
     );
   }
+
+  async getSession(session: string) {
+    return lastValueFrom(this.authService.AuthGetSession({ session }));
+  }
+
+  async oauthSignIn(data: { username: string; token: string }) {
+    const { username, token } = data;
+    return lastValueFrom(
+      this.authService.AuthOauthSignIn({ token, username, refreshToken: '' }),
+    );
+  }
+
+  async blockUsers(
+    users: string[],
+    metadata: Metadata,
+  ): Promise<BulkEditResponse> {
+    this.logger.info('blockUsers - Service starting');
+
+    try {
+      this.logger.debug('Calling BlockUser gRPC method', {
+        metadata: {
+          access_token: metadata.get('access_token'),
+          language: metadata.get('language'),
+        },
+      });
+
+      const response = await lastValueFrom<BulkEditResponse>(
+        this.authService.BlockUser({ users }, metadata),
+      );
+
+      this.logger.info('blockUsers - Service success', { response });
+      return response;
+    } catch (error) {
+      this.logger.error('blockUsers - Service error', {
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
+  }
+
+  async unblockUsers(
+    users: string[],
+    metadata: Metadata,
+  ): Promise<BulkEditResponse> {
+    this.logger.info('unblockUsers');
+    return await lastValueFrom(
+      this.authService.UnblockUser({ users }, metadata),
+    );
+  }
+
+  async resetUsers(
+    users: string[],
+    metadata: Metadata,
+  ): Promise<BulkEditResponse> {
+    this.logger.info('resetUsers');
+
+    try {
+      this.logger.debug('Calling ResetUser gRPC method', {
+        metadata: {
+          access_token: metadata.get('access_token'),
+          language: metadata.get('language'),
+        },
+      });
+
+      const response = await lastValueFrom<BulkEditResponse>(
+        this.authService.ResetUser({ users }, metadata),
+      );
+
+      this.logger.info('resetUsers - Success', { response });
+      return response;
+    } catch (error) {
+      this.logger.error('resetUsers - Error', {
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
+  }
+
+  public async validateUserSession(accessToken: any, resourceHost: string) {
+    const payload = await this.validateJwtToken(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');
+  }
+
+  private async validateJwtToken(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,
+      },
+      // Raw permission seqids from the JWT. Consumers own the seqid->meaning
+      // mapping (e.g. Orchest's auth-server); Maestro reports them as-is.
+      permissions: payload.permissions ?? [],
+    };
+
+    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;
+  }
 }

src/modules/auth/dtos/login.ts

@@ -1,3 +1,4 @@
+import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
 import {
   AuthSignInRequest,
   AuthSignInResponse,
@@ -66,12 +67,28 @@ export class AuthUser {
 export class AuthCustomer {
   @ApiProperty()
   modules: string[];
+
   @ApiProperty()
   id: string;
+
   @ApiProperty()
   name: string;
+
+  @ApiProperty()
+  displayName: string;
   @ApiProperty()
   tier: string;
+
+  @ApiProperty()
+  scheduleLimit: string;
+
+  @ApiProperty()
+  links: Link[];
+
+  @ApiProperty()
+  themeEnabled: boolean;
+  @ApiProperty()
+  enforceMfa: boolean;
 }
 
 export class AuthSignInReq implements AuthSignInRequest {
@@ -79,7 +96,10 @@ export class AuthSignInReq implements AuthSignInRequest {
   username: string;
   @ApiProperty()
   password: string;
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({
+    description:
+      'TOTP code used to login when Multi-Factor Authentication is enabled',
+  })
   totp: string;
 }
 
@@ -97,3 +117,41 @@ export class AuthSignInRes implements AuthSignInResponse {
   @ApiPropertyOptional()
   termsOfUse?: TermsOfUseStatus;
 }
+
+export class AuthRefreshAccessTokenReq {
+  @ApiProperty()
+  refreshToken: string;
+  @ApiProperty()
+  userId: string;
+}
+export class AuthRefreshAccessTokenRes {
+  @ApiProperty()
+  permissions: string[];
+  @ApiProperty()
+  accessToken: string;
+}
+
+export interface BulkEditRequest {
+  users: string[];
+}
+
+export interface BulkEditResponse {
+  message: string;
+  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,
+  },
+  permissions: number[],
+}

src/modules/auth/passport-strategies/google-strategy.ts

@@ -0,0 +1,47 @@
+import {
+  AuthenticateOptionsGoogle,
+  Profile,
+  Strategy,
+  StrategyOptions,
+} from 'passport-google-oauth20';
+import { PassportStrategy } from '@nestjs/passport';
+import { Inject, Injectable } from '@nestjs/common';
+import { OauthSecrets } from 'src/utils/OauthSecrets';
+import { Request } from 'express';
+import jwt from 'jsonwebtoken';
+
+@Injectable()
+export class GoogleLoginStrategy extends PassportStrategy(
+  Strategy,
+  'google-login',
+) {
+  redirect_uri: string;
+  constructor(
+    @Inject('OAUTH_SECRETS')
+    private readonly oauthSecrets: OauthSecrets,
+  ) {
+    const options: StrategyOptions = {
+      clientID: oauthSecrets['google-login'].client_id,
+      clientSecret: oauthSecrets['google-login'].client_secret,
+      callbackURL: oauthSecrets['google-login'].redirect_uri,
+      scope: ['email', 'profile', 'openid'],
+    };
+    console.log("GoogleLoginStrategy", options.clientID, options.callbackURL);
+    const verify = (
+      accessToken: string,
+      refreshToken: string,
+      profile: Profile,
+      done,
+    ) => {
+      return done(null, profile, { accessToken, refreshToken });
+    };
+
+    super(options, verify);
+  }
+
+  authenticate(req: Request, options: AuthenticateOptionsGoogle) {
+    const language = req.headers['dadosfera-lang'] || req.query.language;
+    options.state = jwt.sign({ language }, process.env.JWT_PRIVATE_KEY);
+    super.authenticate(req, options);
+  }
+}

src/modules/catalog/catalog-client.ts

@@ -5,6 +5,11 @@ import {
 } from '@nestjs/microservices';
 import { credentials } from '@grpc/grpc-js';
 import { Catalog } from '@dadosfera/protospack-v2';
+import { PlatformInterfaces } from '@dadosfera/protospack-v2';
+
+const isLocalConnection =
+  process.env.PIFACTORY_URL.startsWith('pi-factory:') ||
+  process.env.PIFACTORY_URL.includes('0.0.0.0');
 
 export class CatalogClientConfiguration {
   public name = 'CatalogClientConfiguration';
@@ -15,14 +20,13 @@ export class CatalogClientConfiguration {
       package: [
         Catalog.ProtoPackages.ReadPackage,
         Catalog.ProtoPackages.WritePackage,
+        PlatformInterfaces.ProtoPackages.WritePackage
       ],
-      credentials:
-        process.env.LOCAL_ENV || process.env.ENV === 'local'
-          ? undefined
-          : credentials.createSsl(),
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
       protoPath: [
         Catalog.ProtoPaths.ReadFilePath,
         Catalog.ProtoPaths.WriteFilePath,
+        PlatformInterfaces.ProtoPaths.WriteFilePath
       ],
       loader: {
         keepCase: true,

src/modules/catalog/catalog.module.ts

@@ -3,21 +3,23 @@ import { Module } from '@nestjs/common';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 
 import { CatalogController } from './catalog.controller';
-import { CatalogService } from './catalog.service';
 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';
 
 const client = new CatalogClientConfiguration();
 
 @Module({
   imports: [
     ClientsModule.register([client.providerOptions]),
-    OldPipelineModule,
     UsersModule,
     RolesModule,
+    CustomersModule,
+    ShareModule,
   ],
   controllers: [CatalogController],
   providers: [CatalogService, DadosferaLogger],

src/modules/catalog/catalog.service.ts

@@ -6,6 +6,12 @@ import {
   Messages,
 } from '@dadosfera/protospack-v2/dist/lib/Catalog';
 import {
+  Messages as PlatformInterfaceMessages,
+  WriteService as PlatformInterfaceWriteService,
+  ProtoServices as PlatformInterfacesProtoServices,
+} from '@dadosfera/protospack-v2/dist/lib/PlatformInterfaces';
+import {
+  BadRequestException,
   HttpException,
   HttpStatus,
   Inject,
@@ -18,10 +24,28 @@ import { CatalogClientConfiguration } from './catalog-client';
 import { UsersService } from '../users/users.service';
 import { RolesService } from '../roles/roles.service';
 import { Metadata } from '@grpc/grpc-js';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import {
+  AssetReporter,
+  BatchRemoveRlsRulesRequest,
+  CreateDataDocsDTO,
+  IUpdateCertificationStatusRequest,
+  IUpdateDataRequest,
+  TriggerCatalogReq,
+} from './dtos';
+import {
+  AddRlsRuleRequest,
+  GetNimbusDashboardsRequest,
+  GetRlsRulesRequest,
+  PiiMetadata,
+} from '@dadosfera/protospack-v2/dist/lib/Catalog/interfaces/messages';
+import { TypeParser } from 'src/utils/FileParser/parser-types';
+import { ParserBuilder } from 'src/utils/FileParser/parser.builder';
 
 class CatalogService implements OnModuleInit {
   catalogReadService: ReadService.CatalogReadServices;
   catalogWriteService: WriteService.CatalogWriteServices;
+  platformWriteService: PlatformInterfaceWriteService.PlatformInterfacesWriteServices;
   logger: any;
   constructor(
     @Inject(DadosferaLogger)
@@ -43,9 +67,14 @@ class CatalogService implements OnModuleInit {
       this.grpcClient.getService<WriteService.CatalogWriteServices>(
         ProtoServices.CatalogWriteServices,
       );
+    this.platformWriteService =
+      this.grpcClient.getService<PlatformInterfaceWriteService.PlatformInterfacesWriteServices>(
+        PlatformInterfacesProtoServices.PlatformInterfacesWriteServices,
+      );
   }
 
   _getNimbusUrl(body) {
+    this.logger.debug(`Body: ${JSON.stringify(body)}`);
     const customer = body.info.customer.toLowerCase();
 
     if (process.env.ENV === 'prd') {
@@ -58,17 +87,50 @@ class CatalogService implements OnModuleInit {
     )}.dadosfera.ai`;
   }
 
+  async getPiiReporter(metadata: Metadata, type: TypeParser) {
+    this.logger.info('getPiiReporter: ' + type);
+    try {
+      const { data } = await lastValueFrom(
+        this.catalogWriteService.GetPiiReporter({}, metadata),
+      );
+      this.logger.info('Finish grpc call');
+
+      const parser = ParserBuilder.build<PiiMetadata>(type);
+
+      this.logger.info('parser file to: ' + type);
+      const file = await parser.parse(data);
+      this.logger.info('finish parser');
+      const mimeTypes: Record<TypeParser, string> = {
+        csv: 'text/csv',
+        html: 'text/html',
+        pdf: 'application/pdf',
+      };
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const filename = `relatorio-pii-${timestamp}.${type}`;
+
+      return {
+        file,
+        filename: filename,
+        type: mimeTypes[type],
+      };
+    } catch (error) {
+      this.logger.error(error.message);
+      throw error;
+    }
+  }
+
+  async getCustomPropertyDefinitions(metadata: Metadata) {
+    return lastValueFrom(this.catalogReadService.GetCustomPropertyDefinitions({}, metadata));
+  }
+
   async createDataAsset(data: Messages.CreateDataAssetRequest, metadata) {
     this.logger.info('CatalogService - Manage Data assets permissions');
+    if (!data.embed) data.embed = undefined;
 
     return lastValueFrom(
       this.catalogWriteService.CreateDataAsset(data, metadata),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 404,
-      );
-    });
+    );
   }
 
   async managePermissions(data: Messages.ManagePermissionRequest, metadata) {
@@ -139,42 +201,93 @@ class CatalogService implements OnModuleInit {
   async getUserRolesIds(userId: string) {
     const result = await this.userService.findOneById(userId).catch(() => null);
 
-    const roles_ids = result.user.roles.map((role) => role.id);
+    if (result) {
+      return result.user.roles.map((role) => role.id);
+    }
 
-    return roles_ids;
+    return [];
   }
 
-  async getUsernamesAndRolesByCustomerId(customerId: string) {
-    const resultUsers = await this.userService.findAllUsersByCustomerId(
-      customerId,
-    );
-    const resultRoles = await this.roleService.roleSearch(
-      {},
-      { customer_id: customerId },
-    );
-
-    const customer_users = resultUsers.users.map((user) => {
-      return {
-        id: user.id,
-        username: user.username,
-      };
-    });
-
-    const customer_roles = resultRoles.roles.map((role) => {
-      return {
-        id: role.id,
-        name: role.name,
-      };
-    });
-
-    return [customer_users, customer_roles];
-  }
-
-  async getAllOpenSearchDataAssets(query, metadata, customer_id) {
-    this.logger.info('CatalogService - getAllOpenSearchDashboard');
+  async searchDataAssets(
+    query: Record<string, any>,
+    metadata: Metadata,
+    customer_id: string,
+  ) {
+    this.logger.info('CatalogService - searchDataAssets', { query });
 
     const { search, page, size, sort_by, order, ...filters } = query;
 
+    this.logger.debug('Extracted filters:', { filters });
+
+    if (
+      filters.manually !== undefined &&
+      filters.manually !== null &&
+      filters.manually !== ''
+    ) {
+      filters.manually = Number(filters.manually); // 1 ou 0
+    } else {
+      delete filters.manually;
+    }
+
+    if (filters.owner) {
+      const { users: customer_users } =
+        await this.userService.findAllUsersByCustomerId(customer_id);
+
+      this.logger.info('Available users in database count:', {
+        count: customer_users.length,
+      });
+      this.logger.info('First 5 users:', {
+        users: customer_users
+          .slice(0, 5)
+          .map((u) => ({ id: u.id, email: u.email, name: u.name })),
+      });
+
+      const ownerValues = Array.isArray(filters.owner)
+        ? filters.owner
+        : typeof filters.owner === 'string' && filters.owner.includes(',')
+        ? filters.owner.split(',').map((o: string) => o.trim())
+        : [filters.owner];
+
+      this.logger.info('Owner values to convert:', {
+        ownerValues,
+        ownerFiltersOriginal: filters.owner,
+      });
+
+      const ownerIds = ownerValues
+        .map((ownerValue: string) => {
+          const normalizedOwner = ownerValue.replace(/\s/g, '+');
+          const user = customer_users.find((u) => {
+            const isIdMatch = u.id === ownerValue;
+            const isEmailMatch =
+              u.email === ownerValue || u.email === normalizedOwner;
+            const isNameMatch =
+              u.name === ownerValue || u.name === normalizedOwner;
+            this.logger.info('Comparing:', {
+              userId: u.id,
+              userEmail: u.email,
+              userName: u.name,
+              filterValue: ownerValue,
+              normalizedFilter: normalizedOwner,
+              idMatch: isIdMatch,
+              emailMatch: isEmailMatch,
+              nameMatch: isNameMatch,
+            });
+            return isIdMatch || isEmailMatch || isNameMatch;
+          });
+          this.logger.info('Looking for owner result:', {
+            ownerValue,
+            found: !!user,
+            userId: user?.id,
+          });
+          return user?.id || ownerValue;
+        })
+        .filter((id: string) => id);
+
+      if (ownerIds.length > 0) {
+        filters.owner = ownerIds;
+      }
+    }
+
     const { data_assets, total } = await lastValueFrom(
       this.catalogReadService.GetAllDataAssets(
         {
@@ -187,171 +300,155 @@ class CatalogService implements OnModuleInit {
         },
         metadata,
       ),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 404,
-      );
-    });
+    );
+
+    console.log('MAESTRO RECEBEU RESPOSTA DO PI-FACTORY');
 
     const result = JSON.parse(data_assets);
 
-    const [customer_users, customer_roles] =
-      await this.getUsernamesAndRolesByCustomerId(customer_id);
+    const response = await this.getAssetsUsersAndRoles(
+      result.data_assets,
+      customer_id,
+    );
 
-    for (const asset of result.data_assets) {
-      const condition =
-        asset.owner && !asset.owner.includes('@') ? true : false;
-      const result = condition
-        ? await this.userService.findOneById(asset.owner).catch(() => null)
-        : null;
-
-      const owner = result !== null ? result.user.username : null;
-
-      const roles = [];
-      const users = [];
-
-      for (const role of customer_roles) {
-        for (const role_id of asset.roles) {
-          if (role.id === role_id) roles.push(role);
-        }
-      }
-
-      for (const user of customer_users) {
-        for (const user_id of asset.users) {
-          if (user.id === user_id) users.push(user);
-        }
-      }
-
-      Object.assign(asset, {
-        ...asset,
-        owner,
-        roles,
-        users,
-      });
-    }
-
-    return { data_assets: result.data_assets, total };
+    return { data_assets: response, total };
   }
 
-  async getOneDataAsset({
-    data_asset_id,
-    data_asset_type,
-    customer_id,
-    metadata,
+  async downloadAssets(
+    query: Record<string, any>,
+    metadata: Metadata,
+    customer_id: string,
+  ) {
+    const data = await this.searchDataAssets(query, metadata, customer_id);
+
+    const formatData = data.data_assets.map((asset) => ({
+      id: asset.id,
+      display_name: asset.display_name,
+      data_asset_type: asset.data_asset_type,
+      created_at: asset.created_at,
+      tags: '[' + asset.tags.join(', ') + ']',
+    }));
+
+    const parser = ParserBuilder.build<AssetReporter>('csv');
+
+    const file = await parser.parse(formatData);
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `dadosfera_assets_${timestamp}.csv`;
+
+    return {
+      file,
+      filename,
+    };
+  }
+
+  async getOneDataAsset(data: {
+    id: string;
+    customer_id: string;
+    metadata: Metadata;
   }) {
+    const { customer_id, id, metadata } = data;
     const { data_asset } = await lastValueFrom(
       this.catalogReadService.GetOneDataAsset(
-        { id: data_asset_id, type: data_asset_type },
+        { id, type: undefined },
         metadata,
       ),
     );
-    const opensearchTable = JSON.parse(data_asset);
+    let asset = JSON.parse(data_asset);
+    asset = {
+      ...asset,
+      p_roles: asset.roles,
+      p_users: asset.users,
+    };
+    asset = await this.getAssetsUsersAndRoles([asset], customer_id);
 
-    const result = opensearchTable.owner
-      ? await this.userService
-          .findOneById(opensearchTable.owner)
-          .catch(() => null)
-      : null;
-
-    const owner = result !== null ? result.user.username : null;
-
-    const [customer_users, customer_roles] =
-      await this.getUsernamesAndRolesByCustomerId(customer_id);
-
-    const users = [];
-    const roles = [];
-
-    for (const role of customer_roles) {
-      for (const role_id of opensearchTable.roles) {
-        if (role.id === role_id) roles.push(role);
-      }
-    }
-
-    for (const user of customer_users) {
-      for (const user_id of opensearchTable.users) {
-        if (user.id === user_id) users.push(user);
-      }
-    }
-
-    Object.assign(opensearchTable, {
-      p_roles: opensearchTable.roles,
-      p_users: opensearchTable.users,
-      roles,
-      users,
-      owner,
-    });
-
-    return { data_asset: opensearchTable };
+    return { data_asset: asset[0] };
   }
 
-  async updateOneDataAsset({ data_asset_id, customer_id, body, metadata }) {
+  async getOneDataAssetByPipelineAndObject(data: {
+    customer_id: string;
+    pipeline: string;
+    object: string;
+    metadata: Metadata;
+  }) {
+    const { customer_id, metadata, pipeline, object } = data;
+    const { data_asset } = await lastValueFrom(
+      this.catalogReadService.GetOneDataAssetByPipelineAndObject(
+        { pipeline, object },
+        metadata,
+      ),
+    );
+    let asset = JSON.parse(data_asset);
+    asset = {
+      ...asset,
+      p_roles: asset.roles,
+      p_users: asset.users,
+    };
+    asset = await this.getAssetsUsersAndRoles([asset], customer_id);
+
+    return { data_asset: asset[0] };
+  }
+
+  async updateCertificationStatus(data: {
+    data_asset_id: string;
+    body: IUpdateCertificationStatusRequest;
+    metadata: Metadata;
+  }) {
+    const { body, data_asset_id, metadata } = data;
+
+    await lastValueFrom(
+      this.catalogWriteService.UpdateDataAsset(
+        {
+          id: data_asset_id,
+          changes: JSON.stringify({
+            certification_status: body.certification_status,
+          }),
+        },
+        metadata,
+      ),
+    );
+
+    return { certification_status: body.certification_status };
+  }
+
+  async updateOneDataAsset(data: {
+    data_asset_id: string;
+    customer_id: string;
+    body: IUpdateDataRequest;
+    metadata: Metadata;
+  }) {
+    const { body, customer_id, data_asset_id, metadata } = data;
+
     const { data_asset } = await lastValueFrom(
       this.catalogWriteService.UpdateDataAsset(
         { id: data_asset_id, changes: JSON.stringify(body) },
         metadata,
       ),
     );
+    let asset = JSON.parse(data_asset);
+    asset = {
+      ...asset,
+      p_roles: asset.roles,
+      p_users: asset.users,
+    };
+    asset = await this.getAssetsUsersAndRoles([asset], customer_id);
 
-    const opensearchTable = JSON.parse(data_asset);
-
-    const result = opensearchTable.owner
-      ? await this.userService
-          .findOneById(opensearchTable.owner)
-          .catch(() => null)
-      : null;
-
-    const owner = result !== null ? result.user.username : null;
-
-    const [customer_users, customer_roles] =
-      await this.getUsernamesAndRolesByCustomerId(customer_id);
-
-    const users = [];
-    const roles = [];
-
-    for (const role of customer_roles) {
-      for (const role_id of opensearchTable.roles) {
-        if (role.id === role_id) roles.push(role);
-      }
-    }
-
-    for (const user of customer_users) {
-      for (const user_id of opensearchTable.users) {
-        if (user.id === user_id) users.push(user);
-      }
-    }
-
-    Object.assign(opensearchTable, {
-      p_roles: opensearchTable.roles,
-      p_users: opensearchTable.users,
-      roles,
-      users,
-      owner,
-    });
-
-    return { data_asset: opensearchTable };
+    return { data_asset: asset[0] };
   }
 
-  async getDataDocs(data_asset_id: string, metadata: Metadata) {
-    const [data_asset_type, id] = data_asset_id.split('-');
-
+  async getDataDocs(id: string, assetType: string, metadata: Metadata) {
     const { documentation } = await lastValueFrom(
-      this.catalogReadService.GetDatasetDoc(
-        { id, type: data_asset_type },
-        metadata,
-      ),
+      this.catalogReadService.GetDatasetDoc({ id }, metadata),
     );
-    console.log(documentation);
+
     const docs = JSON.parse(documentation);
     return docs;
   }
 
-  async getDatasetPreview(data_asset_id: string, metadata: Metadata) {
-    const [data_asset_type, id] = data_asset_id.split('-');
-
+  async getDatasetPreview(id: string, metadata: Metadata) {
     const { preview } = await lastValueFrom(
       this.catalogReadService.GetDatasetPreview(
-        { id, type: data_asset_type },
+        { id, type: undefined },
         metadata,
       ),
     );
@@ -359,12 +456,10 @@ class CatalogService implements OnModuleInit {
     return result;
   }
 
-  async getDatasetColumnsMetadata(data_asset_id: string, metadata: Metadata) {
-    const [data_asset_type, id] = data_asset_id.split('-');
-
+  async getDatasetColumnsMetadata(id: string, metadata: Metadata) {
     const { columns_metadata } = await lastValueFrom(
       this.catalogReadService.GetDatasetColumnsMetadata(
-        { id, type: data_asset_type },
+        { id, type: undefined },
         metadata,
       ),
     );
@@ -372,7 +467,26 @@ class CatalogService implements OnModuleInit {
     return result;
   }
 
-  async createDataDocs(body) {
+  async updateColumnsDescriptions(
+    id: string,
+    columns: { column_name: string; description: string }[],
+    metadata: Metadata,
+  ) {
+    await lastValueFrom(
+      this.catalogWriteService.UpdateColumnDescriptions({ id, columns }, metadata),
+    );
+  }
+
+  async createDataDocs(body: CreateDataDocsDTO, metadata: Metadata) {
+    if (body.asset_type === 'table' || body.asset_type === 'view') {
+      return this.createDataDocsViaNimbus(body);
+    }
+
+    return this.createDataDocsViaGrpc(body, metadata);
+  }
+
+  private async createDataDocsViaNimbus(body: CreateDataDocsDTO) {
+    this.logger.info('Creating data docs via Nimbus for table/view');
     const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.post(
       `${nimbusUrl}/api/catalog/data-docs/`,
@@ -381,6 +495,29 @@ class CatalogService implements OnModuleInit {
     return data;
   }
 
+  private async createDataDocsViaGrpc(body: CreateDataDocsDTO, metadata: Metadata) {
+    this.logger.info('Creating data docs via gRPC for other asset types');
+    try {
+      const response: any = await lastValueFrom(
+        this.catalogWriteService.UpdateDataAssetDoc(
+          {
+            id: body.table_id,
+            docs: body.docs,
+          },
+          metadata,
+        ),
+      );
+
+      return response;
+    } catch (error) {
+      this.logger.error('Error creating data asset docs:', error);
+      throw new HttpException(
+        'Failed to create data asset documentation',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+
   async findAllTags(data, metadata) {
     this.logger.info('CatalogService - findAllCustomerTags');
 
@@ -398,6 +535,323 @@ class CatalogService implements OnModuleInit {
 
     return response;
   }
+
+  async findSchemas(metadata: Metadata) {
+    this.logger.info('CatalogService - findSchemas');
+
+    try {
+      const response = await lastValueFrom(
+        this.catalogReadService.GetSchemas({}, metadata),
+      );
+
+      return response;
+
+    } catch (error) {
+      this.logger.error('Error fetching schemas:', error);
+      throw error;
+    }
+  }
+
+  async getAssetsUsersAndRoles(data_assets: Array<any>, customer_id: string) {
+    const { users: customer_users } =
+      await this.userService.findAllUsersByCustomerId(customer_id);
+    const { roles: customer_roles } = await this.roleService.roleSearch(
+      {},
+      { customer_id },
+    );
+    return data_assets.map((data_asset) => {
+      const owner = customer_users.find(
+        (u) => u.id === data_asset.owner,
+      )?.email;
+
+      const roles = [];
+      const users = [];
+      const data_asset_roles = data_asset?.roles || [];
+      for (const role_id of data_asset_roles) {
+        const role = customer_roles.find((r) => r.id === role_id);
+        if (role) roles.push({ id: role.id, name: role.name });
+      }
+
+      const data_asset_users = data_asset?.users || [];
+      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, email: user.email });
+      }
+      return {
+        ...data_asset,
+        roles,
+        users,
+        owner,
+      } as typeof data_asset;
+    });
+  }
+
+  async triggerCatalog(data: TriggerCatalogReq, metadata: Metadata) {
+    const { session } = await lastValueFrom(
+      this.catalogWriteService.TriggerDatasetCataloging(data, metadata),
+    );
+    return session;
+  }
+  async getDatasetCatalogTask(session: string, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogReadService.GetDatasetCatalogTask({ session }, metadata),
+    );
+    return res;
+  }
+
+  async addRlsRule(data: AddRlsRuleRequest, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogWriteService.AddRlsRule(data, metadata),
+    );
+    return res;
+  }
+
+  async removeRlsRule(id: number, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogWriteService.RemoveRlsRule({ id }, metadata),
+    );
+    return res;
+  }
+
+  async batchRemoveRlsRule(
+    query: BatchRemoveRlsRulesRequest,
+    metadata: Metadata,
+  ) {
+    const { id_rls, nimbus_dashboard_id } = query;
+
+    if (id_rls && nimbus_dashboard_id) {
+      throw new BadRequestException(
+        "You can't delete using both parameters. Choose either 'id_rls' or 'nimbus_dashboard_id'",
+      );
+    }
+    if (id_rls) {
+      await lastValueFrom(
+        this.catalogWriteService.RemoveRlsRulesByRlsId({ id_rls }, metadata),
+      );
+    } else if (nimbus_dashboard_id) {
+      await lastValueFrom(
+        this.catalogWriteService.RemoveRlsRulesByDashboardId(
+          { nimbus_dashboard_id: parseInt(nimbus_dashboard_id) },
+          metadata,
+        ),
+      );
+    }
+    return 'OK';
+  }
+
+  async getRlsRules(data: GetRlsRulesRequest, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogReadService.GetRlsRules(data, metadata),
+    );
+    return res.rls_rules;
+  }
+
+  async getOneRlsRule(id: number, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogReadService.GetOneRlsRule({ id }, metadata),
+    );
+    return res.rls_rule;
+  }
+
+  async getNimbusDashboards(
+    data: GetNimbusDashboardsRequest,
+    metadata: Metadata,
+  ) {
+    const res = await lastValueFrom(
+      this.catalogReadService.GetNimbusDashboards(data, metadata),
+    );
+    return res.dashboards;
+  }
+
+  async createTableMetadata(body: any): Promise<number> {
+    const nimbusUrl = this._getNimbusUrl(body);
+    this.logger.info(`Nimbus URL: ${nimbusUrl}`, { ...body.logMetadata });
+
+    const endpoint = `${nimbusUrl}/api/catalog/table-metadata/`;
+
+    this.logger.info(
+      `Creating table metadata for table ${body.table_metadata.table_name}`,
+      { ...body.logMetadata },
+    );
+    this.logger.info(`Using endpoint: ${endpoint}`, { ...body.logMetadata });
+    this.logger.debug(`Payload: ${JSON.stringify(body.table_metadata)}`, {
+      ...body.logMetadata,
+    });
+
+    try {
+      const { data, status } = await axios.post(endpoint, {
+        ...body.table_metadata,
+      });
+
+      this.logger.info(
+        `Table metadata created successfully with status ${status} for table ${body.table_metadata.table_name}`,
+        { ...body.logMetadata },
+      );
+      return data.id;
+    } catch (error) {
+      this.logger.error(
+        `Failed to create table metadata for table ${body.table_metadata.table_name} failed with status ${
+          error.response?.status
+        } because of ${JSON.stringify(error.response?.data) || error.message}`,
+        { ...body.logMetadata },
+      );
+      throw new Error(error.response?.data?.message || error.message);
+    }
+  }
+
+  async createColumnMetadata(body: any): Promise<number[]> {
+    const nimbusUrl = this._getNimbusUrl(body);
+    this.logger.info(`Nimbus URL: ${nimbusUrl}`, body.logMetadata);
+    const endpoint = `${nimbusUrl}/api/catalog/column-metadata/`;
+
+    try {
+      this.logger.info(
+        `Creating column metadata for table ${body.column_metadata.table_name}`,
+        { ...body.logMetadata },
+      );
+      this.logger.info(`Using endpoint: ${endpoint}`, { ...body.logMetadata });
+      this.logger.debug(
+        `Payload: ${JSON.stringify(body.column_metadata)}`,
+        { ...body.logMetadata },
+      );
+      const { data, status } = await axios.post(
+        endpoint,
+        body.column_metadata,
+      );
+
+      this.logger.info(
+        `Column metadata created successfully with status ${status} for table ${body.column_metadata.table_name}`,
+        { ...body.logMetadata },
+      );
+      return data.map((column) => column.id);
+    } catch (error) {
+      this.logger.error(
+        `Failed to create column metadata failed with status for table ${body.column_metadata.table_name} ${
+          error.response?.status
+        } because of ${error.response?.data || error.message}`,
+        { ...body.logMetadata },
+      );
+      throw new Error(error.response?.data?.message || error.message);
+    }
+  }
+
+  async createDataPreview(body: any): Promise<number> {
+    const nimbusUrl = this._getNimbusUrl(body);
+    this.logger.info(`Nimbus URL: ${nimbusUrl}`, { ...body.logMetadata });
+    const endpoint = `${nimbusUrl}/api/catalog/data-preview/`;
+
+    this.logger.info(
+      `Creating data preview for table ${body.data_preview.table_name}`,
+      { ...body.logMetadata },
+    );
+    this.logger.info(`Using endpoint: ${endpoint}`, { ...body.logMetadata });
+    this.logger.debug(
+      `Payload: ${JSON.stringify(body.data_preview)}`,
+      { ...body.logMetadata },
+    );
+
+    try {
+      const { data, status } = await axios.post(endpoint, body.data_preview);
+
+      this.logger.info(
+        `Data preview created successfully with status ${status} for table ${body.data_preview.table_name}`,
+        { ...body.logMetadata },
+      );
+      return data.id;
+    } catch (error) {
+      this.logger.error(
+        `Failed to create data preview for table ${body.data_preview.table_name} failed with status ${
+          error.response?.status
+        } because of ${error.response?.data || error.message}`,
+        { ...body.logMetadata },
+      );
+      throw new Error(error.response?.data?.message || error.message);
+    }
+  }
+
+  async renameTableOnNimbus(
+    nimbusUrl: string,
+    nimbusId: number,
+    changes: { table_name?: string; table_schema?: string; display_name?: string },
+  ): Promise<void> {
+    const endpoint = `${nimbusUrl}/api/catalog/table-metadata/${nimbusId}`;
+    this.logger.info(`Renaming table-metadata ${nimbusId} on Nimbus`, { endpoint, changes });
+    await axios.patch(endpoint, changes);
+  }
+
+  async renameColumnMetadataOnNimbus(
+    nimbusUrl: string,
+    databaseName: string,
+    oldTableName: string,
+    oldTableSchema: string,
+    newTableName: string,
+    newTableSchema: string,
+  ): Promise<void> {
+    const listEndpoint = `${nimbusUrl}/api/catalog/column-metadata/?database_name=${encodeURIComponent(databaseName)}&table_name=${encodeURIComponent(oldTableName)}&table_schema=${encodeURIComponent(oldTableSchema)}`;
+    this.logger.info(`Fetching column-metadata records to rename`, { listEndpoint });
+    const { data: columns } = await axios.get(listEndpoint);
+
+    const filtered = Array.isArray(columns) ? columns : [];
+
+    for (const column of filtered) {
+      const patchEndpoint = `${nimbusUrl}/api/catalog/column-metadata/${column.id}`;
+      await axios.patch(patchEndpoint, {
+        table_name: newTableName,
+        table_schema: newTableSchema,
+      });
+    }
+    this.logger.info(`Renamed ${filtered.length} column-metadata records on Nimbus`);
+  }
+
+  async renameDataPreviewOnNimbus(
+    nimbusUrl: string,
+    databaseName: string,
+    oldTableName: string,
+    oldTableSchema: string,
+    newTableName: string,
+    newTableSchema: string,
+  ): Promise<void> {
+    const listEndpoint = `${nimbusUrl}/api/catalog/data-preview/?database_name=${encodeURIComponent(databaseName)}&table_name=${encodeURIComponent(oldTableName)}&table_schema=${encodeURIComponent(oldTableSchema)}`;
+    this.logger.info(`Fetching data-preview records to rename`, { listEndpoint });
+    const { data: previews } = await axios.get(listEndpoint);
+
+    const filtered = Array.isArray(previews) ? previews : [];
+
+    for (const preview of filtered) {
+      const patchEndpoint = `${nimbusUrl}/api/catalog/data-preview/${preview.id}`;
+      await axios.patch(patchEndpoint, {
+        table_name: newTableName,
+        table_schema: newTableSchema,
+      });
+    }
+    this.logger.info(`Renamed ${filtered.length} data-preview records on Nimbus`);
+  }
+
+  async catalogDatasetItem(table_metadata_id: number, metadata: Metadata) {
+    const customer_name_raw = metadata.get('customer_name');
+
+    const customer_name = customer_name_raw?.[0]?.toString();
+    if (!customer_name) {
+      throw new BadRequestException('Customer name not found in metadata');
+    }
+    const res = await lastValueFrom(
+      this.platformWriteService.CatalogDataAssets(
+        {
+          data_assets: [
+            {
+              data_asset_id: table_metadata_id.toString(),
+              customer_name: customer_name,
+              data_asset_type: 'dataset',
+              column_metadata: [],
+              data_preview: '',
+            },
+          ],
+        },
+        metadata,
+      ),
+    );
+    return res;
+  }
 }
 
 export { CatalogService };

src/modules/catalog/dtos/index.ts

@@ -1,6 +1,34 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { ApiProperty, ApiPropertyOptional, PickType } from '@nestjs/swagger';
+import {
+  ArrayNotEmpty,
+  IsArray,
+  IsEnum,
+  IsNotEmpty,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
 import { CreateDataAssetRequest } from '@dadosfera/protospack-v2/dist/lib/Catalog/interfaces/messages';
 
+export enum DataAssetShareType {
+  none = 'none',
+  public = 'public',
+  private = 'private',
+}
+export enum CertificationStatus {
+  draft = 'draft',
+  in_review = 'in_review',
+  approved = 'approved',
+  deprecated = 'deprecated',
+}
+export enum OrderEnum {
+  asc = 'asc',
+  desc = 'desc',
+}
+export class EmbedObject {
+  @ApiProperty()
+  url: string;
+}
 export class IRole {
   @ApiProperty()
   name: string;
@@ -49,8 +77,8 @@ export class IDataAsset {
   data_encrypted?: string;
   @ApiPropertyOptional()
   num_rows?: number;
-  @ApiPropertyOptional()
-  display_name?: string;
+  @ApiProperty()
+  display_name: string;
   @ApiProperty()
   pipeline_id: string;
   @ApiProperty()
@@ -75,12 +103,18 @@ export class IDataAsset {
   parameters?: string[];
   @ApiPropertyOptional()
   embedding_params?: object;
-  @ApiPropertyOptional()
-  created_at?: string;
+  @ApiProperty()
+  created_at: string;
   @ApiPropertyOptional()
   updated_at?: string;
   @ApiProperty({ type: [IComment] })
   comments: IComment[];
+  @ApiPropertyOptional()
+  embed?: EmbedObject;
+  @ApiPropertyOptional({ enum: DataAssetShareType })
+  share_type?: DataAssetShareType;
+  @ApiPropertyOptional()
+  docs?: string;
 }
 
 export class IOneDataAsset {
@@ -93,9 +127,61 @@ export class IMakeAComment {
   message: string;
 }
 
+export class CommentToDelete extends PickType(IComment, ['id', 'username']) {}
 export class IDeleteComment {
   @ApiProperty()
-  comment: IComment;
+  comment: CommentToDelete;
+}
+
+export class ICatalogAllRequest {
+  @ApiPropertyOptional({
+    description: 'Texto usado para filtrar os ativos no catálogo.',
+  })
+  search;
+
+  @ApiPropertyOptional({
+    description: 'Número de registros a ser retornado',
+    maximum: 10000,
+    minimum: 1,
+  })
+  size: number;
+
+  @ApiPropertyOptional({
+    description: 'Usado para paginação, em conjunto com `size`',
+    minimum: 1,
+  })
+  page: number;
+
+  @ApiPropertyOptional({
+    description:
+      'Campo do data asset para usar na ordenação. Padrão: `created_at` ',
+  })
+  sort_by: string;
+
+  @ApiPropertyOptional({
+    enum: OrderEnum,
+    default: OrderEnum.asc,
+    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 {
@@ -120,6 +206,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;
@@ -127,6 +234,40 @@ export class IUpdateDataRequest {
   description: string;
   @ApiProperty()
   tags: string[];
+  @ApiPropertyOptional()
+  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 ColumnDescriptionDto {
+  @ApiProperty()
+  @IsString()
+  @IsNotEmpty()
+  column_name: string;
+
+  @ApiProperty()
+  @IsString()
+  description: string;
+}
+
+export class UpdateColumnsMetadataRequest {
+  @ApiProperty({ type: [ColumnDescriptionDto] })
+  @IsArray()
+  @ArrayNotEmpty()
+  @ValidateNested({ each: true })
+  @Type(() => ColumnDescriptionDto)
+  columns: ColumnDescriptionDto[];
 }
 
 export class ICreateDataAsset implements CreateDataAssetRequest {
@@ -140,6 +281,10 @@ export class ICreateDataAsset implements CreateDataAssetRequest {
   external_url: string;
   @ApiProperty()
   location: string;
+  @ApiPropertyOptional()
+  embed: EmbedObject;
+  @ApiPropertyOptional()
+  docs: string;
 }
 
 export class IPreview {
@@ -215,3 +360,67 @@ export class IColumnsMetadataResponse {
   @ApiProperty({ type: [IColumnMetadata] })
   columns_metadata: IColumnMetadata[];
 }
+
+export class TriggerCatalogReq {
+  @ApiProperty({
+    description: 'Name of the table on Snowflake',
+    example: 'TB__4DXSD4_TEST',
+  })
+  table_name: string;
+
+  @ApiPropertyOptional({
+    description:
+      'Schema where the asset is located. If not set defaults to "PUBLIC"',
+  })
+  table_schema?: string;
+
+  @ApiPropertyOptional({
+    description: 'Id of the pipeline that generated the asset.',
+  })
+  pipeline_id: string;
+}
+
+export class TriggerCatalogRes {
+  @ApiProperty()
+  session: string;
+}
+
+export class GetDatasetCatalogTaskRes {
+  @ApiProperty()
+  created_at: string;
+  @ApiProperty()
+  customer_name: string;
+  @ApiProperty()
+  session_id: string;
+  @ApiProperty()
+  status: string;
+  @ApiProperty()
+  table_name: string;
+  @ApiProperty()
+  updated_at: string;
+  @ApiProperty()
+  updated_by: string;
+}
+
+export class BatchRemoveRlsRulesRequest {
+  @ApiPropertyOptional()
+  nimbus_dashboard_id?: string;
+
+  @ApiPropertyOptional()
+  id_rls?: string;
+}
+
+export type AssetReporter = {
+  id: string;
+  display_name: string;
+  data_asset_type: string;
+  created_at: string;
+  tags: string;
+}
+
+export type CreateDataDocsDTO = {
+  table_id: string;
+  docs: string;
+  asset_type: string;
+
+}

src/modules/catalog/dtos/pii.dto.ts

@@ -0,0 +1,8 @@
+export class PiiDto {
+  database_name: string;
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  data_type: string;
+  pii_rules: string;
+}

src/modules/catalog/share/share.controller.ts

@@ -0,0 +1,89 @@
+import {
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Req,
+  UseFilters,
+} from '@nestjs/common';
+import {
+  ApiHeaders,
+  ApiTags,
+} from '@nestjs/swagger';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import {
+  IColumnsMetadataResponse,
+  IDocsResponse,
+  IPreviewResponse,
+
+} from '../dtos';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { Language } from 'src/decorators/language.decorator';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import { ShareService } from './share.service';
+import { Request } from 'express';
+
+@ApiTags('Catalog')
+@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
+@Controller('catalog/data-asset/share')
+@UseFilters(new GrpcToHttpExceptionFilter())
+export class ShareController {
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private catalogShareService: ShareService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Get('/:id')
+  async getShareDataAsset(
+    @Param('id') id: string,
+    @Req() request: Request
+  ) {
+    this.logger.info(`GET //:id`);
+    return await this.catalogShareService.getOneDataAssetPublic(id, request);
+  }
+
+  @Get('/:id/columns-metadata')
+  async getShareDataAssetColumnsMetadata(
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @Req() request: Request
+  ): Promise<IColumnsMetadataResponse> {
+    this.logger.info(`GET /:id/columns-metadata`);
+
+    const columns_metadata =
+      await this.catalogShareService.getDatasetColumnsMetadata(id, request);
+
+
+    return { columns_metadata };
+  }
+
+  @Get('/:id/preview')
+  async getShareDataAssetPreview(
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @Req() request: Request
+  ): Promise<IPreviewResponse> {
+    this.logger.info(`GET /:id/preview`);
+    const preview = await this.catalogShareService.getDatasetPreview(id, request);
+
+    return { preview };
+  }
+
+  @Get('/:id/docs')
+  async getShareDataAssetDocs(
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @Req() request: Request
+  ): Promise<IDocsResponse> {
+    this.logger.info(`GET /:id/docs`);
+    const docs = await this.catalogShareService.getDataDocs(id, request);
+
+    return { docs };
+  }
+
+}

src/modules/catalog/share/share.module.ts

@@ -0,0 +1,30 @@
+import { Module } from "@nestjs/common";
+import { CatalogClientConfiguration } from "../catalog-client";
+import { ClientsModule } from "@nestjs/microservices";
+import { RolesModule } from "src/modules/roles/roles.module";
+import { UsersModule } from "src/modules/users/users.module";
+import { CustomersModule } from "src/modules/customers/customers.module";
+import { ShareMetadataModule } from "src/modules/share-metadata/share-metadata.module";
+import { ShareController } from "./share.controller";
+import DadosferaLogger from "@dadosfera/dadosfera-logs";
+import { ShareService } from "./share.service";
+import { MixpanelModule } from "src/modules/mixpanel/mixpanel.module";
+import { AuthModule } from "src/modules/auth/auth.module";
+
+const client = new CatalogClientConfiguration();
+
+@Module({
+  imports: [
+    ClientsModule.register([client.providerOptions]),
+    UsersModule,
+    RolesModule,
+    CustomersModule,
+    ShareMetadataModule,
+    MixpanelModule,
+    AuthModule
+  ],
+  controllers: [ShareController],
+  providers: [ShareService, DadosferaLogger],
+  exports: [ShareModule],
+})
+export class ShareModule {}

src/modules/catalog/share/share.service.ts

@@ -0,0 +1,276 @@
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+import {
+  ProtoServices,
+  ReadService,
+} from '@dadosfera/protospack-v2/dist/lib/Catalog';
+import {
+  ForbiddenException,
+  Inject,
+  NotFoundException,
+  OnModuleInit,
+} from '@nestjs/common';
+import { CatalogClientConfiguration } from '../catalog-client';
+import { ClientGrpc } from '@nestjs/microservices';
+import { UsersService } from 'src/modules/users/users.service';
+import { RolesService } from 'src/modules/roles/roles.service';
+import { RequestUser } from 'src/decorators/user.decorator';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import { Metadata } from '@grpc/grpc-js';
+import { lastValueFrom } from 'rxjs';
+import { ShareMetadataService } from 'src/modules/share-metadata/share-metadata.service';
+import { isJWT } from 'class-validator';
+import { MixpanelService } from 'src/modules/mixpanel/mixpanel.service';
+import { Request } from 'express';
+import jwt from 'jsonwebtoken';
+import { AuthClientService } from 'src/modules/auth/auth.service';
+
+
+export class ShareService implements OnModuleInit {
+  catalogReadService: ReadService.CatalogReadServices;
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    @Inject(CatalogClientConfiguration.name)
+    private readonly grpcClient: ClientGrpc,
+    private readonly userService: UsersService,
+    private readonly roleService: RolesService,
+    private readonly shareMetadataService: ShareMetadataService,
+    private readonly mixpanelService: MixpanelService,
+    private authClient: AuthClientService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.catalogReadService =
+      this.grpcClient.getService<ReadService.CatalogReadServices>(
+        ProtoServices.CatalogReadServices,
+      );
+  }
+
+  async getDatasetColumnsMetadata(id: string, request: Request) {
+    const shareMetadata = await this.getShareMetadata(id, request);
+    const metadata = PackTheMetadata({
+      customer_id: shareMetadata.customerId,
+      customer_name: shareMetadata.customerName,
+    });
+    const { columns_metadata } = await lastValueFrom(
+      this.catalogReadService.GetDatasetColumnsMetadata(
+        { id: shareMetadata.assetId, type: undefined },
+        metadata,
+      ),
+    );
+    const result = JSON.parse(columns_metadata);
+    return result;
+  }
+
+  async getDatasetPreview(id: string, request: Request) {
+    const shareMetadata = await this.getShareMetadata(id, request);
+    const metadata = PackTheMetadata({
+      customer_id: shareMetadata.customerId,
+      customer_name: shareMetadata.customerName,
+    });
+    const { preview } = await lastValueFrom(
+      this.catalogReadService.GetDatasetPreview(
+        { id: shareMetadata.assetId, type: undefined },
+        metadata,
+      ),
+    );
+    const result = JSON.parse(preview);
+    return result;
+  }
+
+  async getOneDataAssetPublic(id: string, request: Request) {
+    this.logger.info("getOneDataAssetPublic: " + JSON.stringify({
+      id
+    }))
+    try {
+    const user = await this.getUserFromRequest(request);
+
+      const shareMetadata = await this.getShareMetadata(id, request);
+
+      const mixpanelTracker = {
+        asset: shareMetadata.assetId,
+        type: isJWT(id) ? 'assigned' : shareMetadata.type,
+        customer: shareMetadata.customerName
+      }
+
+      if (user) {
+        await this.mixpanelService.track("share_page", user, request, mixpanelTracker);
+      } else {
+        await this.mixpanelService.trackShare(request, mixpanelTracker);
+      }
+
+      this.logger.info("shareMetadata: " + JSON.stringify(shareMetadata))
+      const metadata = PackTheMetadata({
+        customer_id: shareMetadata.customerId,
+        customer_name: shareMetadata.customerName,
+      });
+  
+      const { data_asset } = await this.getOneDataAsset({
+        customer_id: shareMetadata.customerId,
+        id: shareMetadata.assetId,
+        metadata,
+      });
+      this.logger.info('found asset: ' + JSON.stringify(data_asset));
+      delete data_asset.p_roles;
+      delete data_asset.p_users;
+      data_asset.share_type = 'public';
+      if (data_asset.share_type !== 'public') throw new NotFoundException();
+  
+      return { data_asset };
+    } catch (error) {
+      this.logger.error(error);
+      throw error;
+    }
+
+  }
+
+  private async getOneDataAsset(data: {
+    id: string;
+    customer_id: string;
+    metadata: Metadata;
+  }) {
+    const { customer_id, id, metadata } = data;
+    const { data_asset } = await lastValueFrom(
+      this.catalogReadService.GetOneDataAsset(
+        { id, type: undefined },
+        metadata,
+      ),
+    );
+    let asset = JSON.parse(data_asset);
+    asset = {
+      ...asset,
+      p_roles: asset.roles,
+      p_users: asset.users,
+    };
+    asset = await this.getAssetsUsersAndRoles([asset], customer_id);
+
+    return { data_asset: asset[0] };
+  }
+
+  async getDataDocs(id: string, request: Request) {
+    const shareMetadata = await this.getShareMetadata(id, request);
+    const metadata = PackTheMetadata({
+      customer_id: shareMetadata.customerId,
+      customer_name: shareMetadata.customerName,
+    });
+
+    const { documentation } = await lastValueFrom(
+      this.catalogReadService.GetDatasetDoc({ id }, metadata),
+    );
+    console.log(documentation);
+    const docs = JSON.parse(documentation);
+    return docs;
+  }
+
+  private async getAssetsUsersAndRoles(
+    data_assets: Array<any>,
+    customer_id: string,
+  ) {
+    const { users: customer_users } =
+      await this.userService.findAllUsersByCustomerId(customer_id);
+    const { roles: customer_roles } = await this.roleService.roleSearch(
+      {},
+      { customer_id },
+    );
+    return data_assets.map((data_asset) => {
+      const owner = customer_users.find(
+        (u) => u.id === data_asset.owner,
+      )?.email;
+
+      const roles = [];
+      const users = [];
+      for (const role_id of data_asset.roles) {
+        const role = customer_roles.find((r) => r.id === role_id);
+        if (role) roles.push({ id: role.id, name: role.name });
+      }
+      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, email: user.email });
+      }
+      return {
+        ...data_asset,
+        roles,
+        users,
+        owner,
+      } as typeof data_asset;
+    });
+  }
+
+
+  private async getShareMetadata(id: string, request: Request) {
+    const metadata = PackTheMetadata({});
+    this.logger.info('GET share metadata')
+    const info = await this.shareMetadataService.get(id, metadata);
+    if (isJWT(id) && info ){
+      return info;
+    }
+
+    const user = await this.getUserFromRequest(request);
+
+    if (info.type === 'private') {
+      if (!user) {
+        throw new ForbiddenException(
+          'You do not have permission to access this data asset.',
+        );
+      }
+
+      const is_data_manager = user.permissions.includes(
+        PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+      );
+
+      const is_get = user.permissions.includes(
+        PERMISSIONS_GROUPS.CATALOG.permissions.GET.seqid,
+      );
+
+      if (is_data_manager || is_get) {
+        return info;
+      }
+
+      throw new ForbiddenException(
+        'You do not have permission to access this data asset.',
+      );
+    }
+    return info;
+  }
+
+   private async getUserFromRequest(request: Request): Promise<RequestUser | null> {
+    const accessToken = request.get('Authorization');
+    if (accessToken) {
+      const accessTokenDecoded: any = jwt.decode(accessToken, {
+        complete: true,
+      });
+
+      const { kid } = accessTokenDecoded.header;
+
+      const { keys } = await this.authClient.getPublicKeys();
+
+      const pemValue = keys.find((key) => key.kid === kid);
+
+      if (!pemValue) {
+        return null;
+      }
+
+      jwt.verify(accessToken, pemValue.pem);
+      const accessTokenPayload = accessTokenDecoded.payload;
+
+      return {
+        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,
+        customer_modules: accessTokenPayload.customer_modules,
+        access_token: accessToken,
+      };
+    }
+
+    return null;
+  }
+}

src/modules/connection-test/connection-test-client.config.ts

@@ -6,14 +6,17 @@ import {
 } from '@nestjs/microservices';
 import { ConnectionTest } from '@dadosfera/protospack-v2';
 
+const isLocalConnection =
+  process.env.INFACTORY_URL.startsWith('in-factory:') ||
+  process.env.INFACTORY_URL.includes('0.0.0.0');
+
 export class ConnectionTestClientConfiguration {
   private config: GrpcOptions = {
     transport: Transport.GRPC,
     options: {
       url: process.env.INFACTORY_URL,
       package: [ConnectionTest.ProtoPackages.ReadPackage],
-      credentials:
-        process.env.ENV === 'local' ? undefined : credentials.createSsl(),
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
       protoPath: [ConnectionTest.ProtoPaths.ReadFilePath],
       loader: {
         keepCase: true,

src/modules/connection-test/connection-test.controller.ts

@@ -9,7 +9,7 @@ import {
   ValidationPipe,
 } from '@nestjs/common';
 import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
-import { User, RequestUser } from 'src/authentication/user.decorator';
+import { User, RequestUser } from 'src/decorators/user.decorator';
 import { ConnectionTestService } from './connection-test.service';
 import {
   ConnectionTestPingRes,
@@ -22,15 +22,26 @@ import {
   ConnectionTestListTablesRes,
   GetTableMetadataRes,
   GetTableMetadataReq,
+  ValidateCdcPrerequisitesReq,
+  ValidateCdcPrerequisitesRes,
+  RefreshCatalogReq,
+  RefreshCatalogRes,
+  RefreshCatalogStatusReq,
 } from './dto/connection-test';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
-import { Authenticated } from 'src/authentication/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(
@@ -82,7 +93,7 @@ export class ConnectionTestController {
     });
     return this.connectionTestService.connectionTestListSchemas(
       body,
-      user.customer_name,
+      user,
     );
   }
 
@@ -99,7 +110,7 @@ export class ConnectionTestController {
     });
     return this.connectionTestService.connectionTestListTables(
       body,
-      user.customer_name,
+      user,
     );
   }
 
@@ -115,8 +126,56 @@ export class ConnectionTestController {
       customer: user.customer_name,
     });
     return this.connectionTestService.getTableMetadata(
+      body,
+      user,
+    );
+  }
+
+  @Post('cdc-prerequisites')
+  @ApiOkResponse({ type: ValidateCdcPrerequisitesRes })
+  @HttpCode(HttpStatus.OK)
+  async validateCdcPrerequisites(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: ValidateCdcPrerequisitesReq,
+  ) {
+    this.logger.info('/connection-test/cdc-prerequisites', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.validateCdcPrerequisites(
       body,
       user.customer_name,
     );
   }
+
+  @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);
+  }
 }

src/modules/connection-test/connection-test.module.ts

@@ -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 {}

src/modules/connection-test/connection-test.service.spec.ts

@@ -0,0 +1,223 @@
+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('lists tables and enriches each with its cached primary keys', async () => {
+    connectionsApiService.proxy
+      // list-tables call (names only from the catalog cache)
+      .mockResolvedValueOnce({
+        tables: [{ table_name: 'customers' }, { table_name: 'orders' }],
+      })
+      // per-table columns calls: customers has a PK, orders has none
+      .mockResolvedValueOnce({
+        columns: [
+          { column_name: 'id', data_type: 'bigint', is_primary_key: true },
+          { column_name: 'name', data_type: 'text', is_primary_key: false },
+        ],
+      })
+      .mockResolvedValueOnce({
+        columns: [
+          { column_name: 'total', data_type: 'numeric', is_primary_key: false },
+        ],
+      });
+
+    await expect(
+      service.connectionTestListTables(
+        {
+          connection_id: 'config-id',
+          plugin: 'postgresql',
+          schema: 'public',
+        },
+        user,
+      ),
+    ).resolves.toEqual({
+      operation_result: true,
+      table_list: ['customers', 'orders'],
+      tables: [
+        { table_name: 'customers', primary_keys: ['id'] },
+        { table_name: 'orders', primary_keys: [] },
+      ],
+    });
+  });
+
+  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',
+      },
+    );
+  });
+});

src/modules/connection-test/connection-test.service.ts

@@ -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,14 +13,21 @@ import {
   ConnectionTestPingRes,
   GetTableMetadataReq,
   GetTableMetadataRes,
+  ValidateCdcPrerequisitesReq,
+  ValidateCdcPrerequisitesRes,
+  RefreshCatalogReq,
+  RefreshCatalogRes,
+  RefreshCatalogStatusReq,
 } from './dto/connection-test';
 import { ConnectionClientService } from '../connection/client.service';
 import {
   CreateConnectionDto,
   DatabaseConnectionPropertiesDto,
 } from '../connection/dtos/connection';
-import { RequestUser } from 'src/authentication/user.decorator';
-import { PackTheMetadata } from 'src/utils/ PackTheMetadata';
+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 +35,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,44 +156,174 @@ 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,
+    );
+    const table_names: string[] = result.tables.map((table) => table.table_name);
+    // CDC create needs the primary keys per table (used to build the deduped
+    // Iceberg identifier-fields). The catalog-cache list-tables endpoint returns
+    // only names, so fetch each table's columns from the cache and keep the ones
+    // flagged is_primary_key. Reads hit the stored catalog snapshot (populated by
+    // refresh-catalog), never the live connection.
+    const tables = await Promise.all(
+      table_names.map(async (table_name) => {
+        const columns = await this.connectionsApiService.proxy(
+          'GET',
+          `/connection_catalog/${encodeURIComponent(body.connection_id)}` +
+            `/schemas/${encodeURIComponent(body.schema)}` +
+            `/tables/${encodeURIComponent(table_name)}/columns`,
+          user,
+        );
+        return {
+          table_name,
+          primary_keys: columns.columns
+            .filter((column) => column.is_primary_key)
+            .map((column) => column.column_name),
+        };
       }),
     );
+    return {
+      operation_result: true,
+      table_list: table_names,
+      tables,
+    };
   }
 
   async getTableMetadata(
     body: GetTableMetadataReq,
-    customer_name: string,
+    user: RequestUser,
   ): Promise<GetTableMetadataRes> {
-    const { schema, plugin, table_list, connection_id } = body;
+    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,
+    };
+  }
+
+  async validateCdcPrerequisites(
+    body: ValidateCdcPrerequisitesReq,
+    customer_name: string,
+  ): Promise<ValidateCdcPrerequisitesRes> {
+    const { plugin, connection_id } = body;
     return lastValueFrom(
-      this.connectionTestReadClient.GetTableMetadata({
+      this.connectionTestReadClient.ValidateCdcPrerequisites({
         connection_id,
         customer_name,
         plugin,
-        schema,
-        table_list,
       }),
     );
   }

src/modules/connection-test/dto/connection-test.ts

@@ -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()
@@ -100,11 +102,20 @@ export class ConnectionTestListTablesReq {
   schema: string;
 }
 
+export class ConnectionTestListTablesEntry {
+  @ApiProperty()
+  table_name: string;
+  @ApiProperty({ type: [String] })
+  primary_keys: string[];
+}
+
 export class ConnectionTestListTablesRes {
   @ApiProperty()
   operation_result: boolean;
   @ApiProperty()
   table_list: string[];
+  @ApiProperty({ type: [ConnectionTestListTablesEntry] })
+  tables: ConnectionTestListTablesEntry[];
 }
 
 export class GetTableMetadataReq {
@@ -131,3 +142,83 @@ export class GetTableMetadataRes {
   @ApiProperty({ type: [TableMetadataDto] })
   tables_metadata: TableMetadataDto[];
 }
+
+export class CdcCheckDto {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  expected: string;
+  @ApiProperty()
+  actual: string;
+  @ApiProperty()
+  passed: boolean;
+}
+
+export class ValidateCdcPrerequisitesReq {
+  @ApiProperty()
+  @IsString()
+  plugin: string;
+
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+}
+
+export class ValidateCdcPrerequisitesRes {
+  @ApiProperty()
+  operation_result: boolean;
+  @ApiProperty({ type: [CdcCheckDto] })
+  checks: CdcCheckDto[];
+}
+
+export class RefreshCatalogReq {
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+
+  @ApiProperty({
+    enum: [
+      'oracle',
+      'mysql',
+      'postgresql',
+      'sqlserver',
+      'mysql_cdc',
+      'postgresql_cdc',
+      'oracle_cdc',
+    ],
+  })
+  @IsIn([
+    'oracle',
+    'mysql',
+    'postgresql',
+    'sqlserver',
+    'mysql_cdc',
+    'postgresql_cdc',
+    'oracle_cdc',
+  ])
+  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;
+}

src/modules/connection/client.config.ts

@@ -6,6 +6,10 @@ import {
 } from '@nestjs/microservices';
 import { ConnectionManager } from '@dadosfera/protospack-v2';
 
+const isLocalConnection =
+  process.env.INFACTORY_URL.startsWith('in-factory:') ||
+  process.env.INFACTORY_URL.includes('0.0.0.0');
+
 export class ConnectionClientConfiguration {
   public name = 'ConnectionClientConfiguration';
   private config: GrpcOptions = {
@@ -16,10 +20,7 @@ export class ConnectionClientConfiguration {
         ConnectionManager.ProtoPackages.WritePackage,
         ConnectionManager.ProtoPackages.ReadPackage,
       ],
-      credentials:
-        process.env.LOCAL_ENV || process.env.ENV === 'local'
-          ? undefined
-          : credentials.createSsl(),
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
       protoPath: [
         ConnectionManager.ProtoPaths.WriteFilePath,
         ConnectionManager.ProtoPaths.ReadFilePath,

src/modules/connection/client.service.ts

@@ -1,9 +1,4 @@
-import {
-  OnModuleInit,
-  Inject,
-  HttpException,
-  HttpStatus,
-} from '@nestjs/common';
+import { OnModuleInit, Inject } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 import { ConnectionManager } from '@dadosfera/protospack-v2';
 import { lastValueFrom } from 'rxjs';
@@ -86,12 +81,7 @@ export class ConnectionClientService implements OnModuleInit {
         },
         metadata,
       ),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async updateConnection(
@@ -112,12 +102,7 @@ export class ConnectionClientService implements OnModuleInit {
         },
         metadata,
       ),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async deleteConnection({ body, metadata }): Promise<ConnectionRes> {
@@ -130,12 +115,7 @@ export class ConnectionClientService implements OnModuleInit {
         },
         metadata,
       ),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async getAllConnections({ body, metadata }): Promise<ConnectionsRes> {
@@ -146,12 +126,7 @@ export class ConnectionClientService implements OnModuleInit {
         { search, filters: JSON.stringify(filters), size, page },
         metadata,
       ),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async getConnectionDetails({
@@ -162,12 +137,7 @@ export class ConnectionClientService implements OnModuleInit {
 
     return lastValueFrom(
       this.connectionServiceRead.GetConnectionDetails({ id }, metadata),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async INTERNAL_getAllConnections({

src/modules/connection/connection.controller.ts

@@ -7,33 +7,42 @@ import {
   Param,
   Delete,
   Get,
-  Headers,
   Query,
+  UseFilters,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { ApiExcludeEndpoint, ApiTags } from '@nestjs/swagger';
 import { ConnectionClientService } from './client.service';
 import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import {
   Authenticated,
   RequireAllPermissions,
-} from 'src/authentication/authentication.decorator';
-import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
-import { RequestUser, User } from 'src/authentication/user.decorator';
+  RequireModule,
+} from 'src/decorators/authentication.decorator';
+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 {
   ConnectionDetailsRes,
   ConnectionRes,
   ConnectionsRes,
+  GetAllConnectionsReq,
   UpdateConnectionDto,
 } from './dtos/connection';
 import { CreateConnectionDto } from './dtos/connection';
-import { PackTheMetadata } from 'src/utils/ PackTheMetadata';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { Language } from 'src/decorators/language.decorator';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
 
 const connectionPermissions = PERMISSIONS_GROUPS.CONNECTION.permissions;
+@UseFilters(new GrpcToHttpExceptionFilter())
 @ApiTags('connections')
-@ApiBearerAuth()
 @Authenticated()
 @Controller('connections')
+@RequireModule(
+  DADOSFERA_MODULES_KEYS.COLLECT
+)
 export class ConnectionController {
   logger: any;
   constructor(
@@ -44,7 +53,9 @@ export class ConnectionController {
     this.logger = dadosferaLogger.logger;
   }
 
+  @ApiInternalOnlyEndpoint()
   @Get('connections-migration')
+  @ApiExcludeEndpoint()
   @RequireAllPermissions(
     PERMISSIONS_GROUPS.DADOSFERA.permissions.CONNECTIONS_MIGRATION,
   )
@@ -80,12 +91,11 @@ export class ConnectionController {
   @RequireAllPermissions(connectionPermissions.CREATE)
   async updateConnection(
     @User() user: RequestUser,
-    @Headers('Dadosfera-Lang') language: string,
+    @Language() language: LanguageEnum,
     @Param('id') id: string,
     @Body(new ValidationPipe()) body: UpdateConnectionDto,
   ): Promise<ConnectionRes> {
     this.logger.info('/connections - Update Connection');
-    if (!language) language = 'en-us';
 
     const { user_id, customer_id, customer_name, username } = user;
     const metadata = PackTheMetadata({
@@ -132,11 +142,10 @@ export class ConnectionController {
   @Get()
   async getAllConnections(
     @User() user: RequestUser,
-    @Headers('Dadosfera-Lang') language,
-    @Query() queries,
+    @Language() language: LanguageEnum,
+    @Query() queries: GetAllConnectionsReq,
   ): Promise<ConnectionsRes> {
     this.logger.info('/connections - Get All Connection');
-    if (!language) language = 'en-us';
 
     const { user_id, customer_id, customer_name, username } = user;
     const { search, size, page, ...filters } = queries;
@@ -158,13 +167,16 @@ export class ConnectionController {
 
   @Get('/:id')
   async getConnectionDetails(
-    @Headers('Dadosfera-Lang') language,
+    @Language() language: LanguageEnum,
     @User() user: RequestUser,
-    @Param('id') id,
-    @Query('details') details,
+    @Param('id') id: string,
+    @Query() queries,
   ): Promise<ConnectionDetailsRes> {
     this.logger.info('/connections - Get Connection Details');
-    if (!language) language = 'en-us';
+
+    console.log(queries);
+
+    const { details, sensitive } = queries;
 
     const { user_id, customer_id, customer_name, username } = user;
     const metadata = PackTheMetadata({
@@ -174,6 +186,7 @@ export class ConnectionController {
       username,
       details,
       language,
+      sensitive,
     });
 
     const response: any = await this.clientService.getConnectionDetails({

src/modules/connection/dtos/connection.ts

@@ -9,6 +9,7 @@ import {
   ConnectionToCatalog,
 } from '@dadosfera/protospack-v2/dist/lib/ConnectionManager/interfaces/entities';
 import {
+  GetAllConnectionRequest,
   GetAllConnectionResponse,
   GetConnectionDetailsResponse,
   GetConnectionResponse,
@@ -21,7 +22,7 @@ export type ConnectionCredentialsType =
   | 'oauth'
   | 'api_key'
   | 'service_account'
-  | 'headers_authF';
+  | 'headers_auth';
 export interface ConnectionApiConnection {
   config_id: string;
   plugin: string;
@@ -94,7 +95,6 @@ export class ConnectionDto implements Connection {
 
 export class ConnectionToCatalogDto implements ConnectionToCatalog {
   // ---Automatically generated information - will not be sent by the frontend--- //
-  id: string;
   customer_id: string;
   updated_at: string;
   created_at: string;
@@ -104,6 +104,9 @@ export class ConnectionToCatalogDto implements ConnectionToCatalog {
   customer_name: string;
 
   // ---Information sent by the frontend--- //
+  @ApiPropertyOptional()
+  id: string;
+
   @ApiProperty()
   name: string;
 
@@ -147,6 +150,15 @@ export class UpdateConnectionDto extends PickType(ConnectionDto, [
   'properties',
 ]) {}
 
+export class GetAllConnectionsReq implements GetAllConnectionRequest {
+  @ApiPropertyOptional()
+  search?: string;
+  @ApiPropertyOptional()
+  page?: string;
+  @ApiPropertyOptional()
+  size?: string;
+}
+
 export class ConnectionsRes implements GetAllConnectionResponse {
   @ApiProperty({ type: [ConnectionToCatalogDto] })
   connections: ConnectionToCatalogDto[];

src/modules/connections-api/connections-api.config.ts

@@ -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),
+};

src/modules/connections-api/connections-api.module.ts

@@ -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 {}

src/modules/connections-api/connections-api.service.ts

@@ -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);
+    }
+  }
+}

src/modules/connector/client.config.ts

@@ -6,6 +6,10 @@ import {
 } from '@nestjs/microservices';
 import { ConnectorManager } from '@dadosfera/protospack-v2';
 
+const isLocalConnection =
+  process.env.INFACTORY_URL.startsWith('in-factory:') ||
+  process.env.INFACTORY_URL.includes('0.0.0.0');
+
 export class ConnectorClientConfiguration {
   public name = 'ConnectorClientConfiguration';
   private config: GrpcOptions = {
@@ -16,10 +20,7 @@ export class ConnectorClientConfiguration {
         ConnectorManager.ProtoPackages.WritePackage,
         ConnectorManager.ProtoPackages.ReadPackage,
       ],
-      credentials:
-        process.env.LOCAL_ENV || process.env.ENV === 'local'
-          ? undefined
-          : credentials.createSsl(),
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
       protoPath: [
         ConnectorManager.ProtoPaths.WriteFilePath,
         ConnectorManager.ProtoPaths.ReadFilePath,

src/modules/connector/client.service.ts

@@ -83,163 +83,30 @@ export class ConnectorClientService implements OnModuleInit {
       );
     });
     const responseParsed = JSON.parse(res.message);
-    const connectorErrors = responseParsed.items
-      .filter((i) => i.update._index === 'connectors' && i.update.error)
+    const connectorsResponse = responseParsed.items.filter(
+      (i) => i.update._index === process.env.CONNECTORS_INDEX,
+    );
+    const connectorErrors = connectorsResponse
+      .filter((i) => i.update.error)
       .map((i) => ({
-        id: i.update._id,
-        reason: i.update.error,
-        status: i.error.status,
-      }));
-    const connectionControlsErrors = responseParsed.items
-      .filter(
-        (i) => i.update._index === 'connection_controls' && i.update.error,
-      )
-      .map((i) => ({
-        id: i.update._id,
-        reason: i.update.error,
-        status: i.error.status,
-      }));
-    const connectionStepsErrors = responseParsed.items
-      .filter((i) => i.update._index === 'connection_steps' && i.update.error)
-      .map((i) => ({
-        id: i.update._id,
-        reason: i.update.error,
-        status: i.error.status,
-      }));
-    const configControlsErrors = responseParsed.items
-      .filter((i) => i.update._index === 'config_controls' && i.update.error)
-      .map((i) => ({
-        id: i.update._id,
-        reason: i.update.error,
-        status: i.error.status,
-      }));
-    const connectorCreated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connectors' && i.update.result === 'created',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionControlsCreated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_controls' &&
-          i.update.result === 'created',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionStepsCreated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_steps' &&
-          i.update.result === 'created',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const configControlsCreated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'config_controls' &&
-          i.update.result === 'created',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectorUpdated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connectors' && i.update.result === 'updated',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionControlsUpdated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_controls' &&
-          i.update.result === 'updated',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionStepsUpdated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_steps' &&
-          i.update.result === 'updated',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const configControlsUpdated = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'config_controls' &&
-          i.update.result === 'updated',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectorNoop = responseParsed.items
-      .filter(
-        (i) => i.update._index === 'connectors' && i.update.result === 'noop',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionControlsNoop = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_controls' &&
-          i.update.result === 'noop',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const connectionStepsNoop = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'connection_steps' && i.update.result === 'noop',
-      )
-      .map((i) => ({
-        id: i.update._id,
-      }));
-    const configControlsNoop = responseParsed.items
-      .filter(
-        (i) =>
-          i.update._index === 'config_controls' && i.update.result === 'noop',
-      )
-      .map((i) => ({
-        id: i.update._id,
+        id: i.update?._id,
+        reason: i.update?.error,
+        status: i.error?.status,
       }));
+    const connectorCreated = connectorsResponse
+      .filter((i) => i.update.result === 'created')
+      .map((i) => i.update._id);
+    const connectorUpdated = connectorsResponse
+      .filter((i) => i.update.result === 'updated')
+      .map((i) => i.update._id);
+    const connectorNoop = connectorsResponse
+      .filter((i) => i.update.result === 'noop')
+      .map((i) => i.update._id);
     return {
-      errors: {
-        connectors: connectorErrors,
-        connection_controls: connectionControlsErrors,
-        connection_steps: connectionStepsErrors,
-        config_controls: configControlsErrors,
-      },
-      created: {
-        connectors: connectorCreated,
-        connection_controls: connectionControlsCreated,
-        connection_steps: connectionStepsCreated,
-        config_controls: configControlsCreated,
-      },
-      updated: {
-        connectors: connectorUpdated,
-        connection_controls: connectionControlsUpdated,
-        connection_steps: connectionStepsUpdated,
-        config_controls: configControlsUpdated,
-      },
-      noop: {
-        connectors: connectorNoop,
-        connection_controls: connectionControlsNoop,
-        connection_steps: connectionStepsNoop,
-        config_controls: configControlsNoop,
-      },
+      errors: connectorErrors,
+      created: connectorCreated,
+      updated: connectorUpdated,
+      noop: connectorNoop,
     };
   }
 
@@ -318,12 +185,7 @@ export class ConnectorClientService implements OnModuleInit {
         version,
         plugin,
       }),
-    ).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
+    );
   }
 
   async updateConnector({ plugin, changes }) {

src/modules/connector/connector.controller.ts

@@ -11,15 +11,13 @@ import {
   UploadedFile,
   UseInterceptors,
   Inject,
-  Headers,
   UploadedFiles,
 } from '@nestjs/common';
 import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
-import { ApiBearerAuth, ApiConsumes, ApiTags } from '@nestjs/swagger';
+import { ApiConsumes, ApiTags } from '@nestjs/swagger';
 import { ConnectorClientService } from './client.service';
 import { AddTagDto } from './dtos/add-tag';
 import { CreateConnectorDto } from './dtos/create-connector';
-import { DeleteConnectorDto } from './dtos/delete-connector';
 import { GetAllDto } from './dtos/get-all';
 import { RemoveTagDto } from './dtos/remove-tag';
 import { UpdateDto } from './dtos/update';
@@ -27,12 +25,16 @@ import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 import {
   Authenticated,
   RequireAllPermissions,
+  RequireModule,
   RequireSomePermission,
-} from 'src/authentication/authentication.decorator';
-import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+} from 'src/decorators/authentication.decorator';
+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';
 
+@ApiInternalOnlyController()
 @ApiTags('connectors')
-@ApiBearerAuth()
 @Authenticated()
 @Controller('connectors')
 export class ConnectorController {
@@ -98,12 +100,14 @@ export class ConnectorController {
     PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
     PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
   )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
   async getAllConnectors(
-    @Headers('dadosfera-lang') language,
+    @Language() language: LanguageEnum,
     @Query() queries: GetAllDto,
   ) {
     this.logger.info('/GET - getAllConnectors Route');
-    if (!language) language = 'en-us';
 
     const { search, size, page, ...filters } = queries;
 
@@ -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,13 +150,15 @@ export class ConnectorController {
     PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
     PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
   )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
   async getConnector(
-    @Headers('dadosfera-lang') language,
+    @Language() language: LanguageEnum,
     @Param('plugin') plugin: string,
     @Query('version') version: string,
   ) {
     this.logger.info('/GET/:plugin - getConnector Route');
-    if (!language) language = 'en-us';
 
     const pluginId = `${plugin}-${version}`;
 
@@ -172,14 +181,15 @@ export class ConnectorController {
     PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
     PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
   )
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
   async getConnectorDetails(
-    @Headers('dadosfera-lang') language,
+    @Language() language: LanguageEnum,
     @Param('plugin') plugin: string,
     @Query('version') version: string,
   ) {
     this.logger.info('/upload - Upload Connector Route');
-    if (!language) language = 'en-us';
-
     const pluginId = `${plugin}-${version}`;
 
     const response: any = await this.connectorClientService.getConnectorDetails(
@@ -196,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,
@@ -217,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,
@@ -244,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,
@@ -272,20 +291,20 @@ export class ConnectorController {
 
   @Delete('/:plugin')
   @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.DELETE)
+  @RequireModule(
+    DADOSFERA_MODULES_KEYS.COLLECT
+  )
   async deleteConnector(
     @Param('plugin') plugin: string,
-    @Body() { version }: DeleteConnectorDto,
+    @Query('version') version: string,
   ) {
-    this.logger.info('/upload - Upload Connector Route');
+    this.logger.info('DELETE /:plugin - Delete Connector Route');
 
-    const response: any = await this.connectorClientService.deleteConnector(
+    const response = await this.connectorClientService.deleteConnector(
       plugin,
       version,
     );
 
-    return {
-      message: response.message || 'ok',
-      connector: { ...JSON.parse(response.connector) },
-    };
+    return { message: response.message, connector: response.connector };
   }
 }

src/modules/customers/customers.controller.ts

@@ -0,0 +1,167 @@
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  Post,
+  Put,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiOkResponse, ApiProduces, ApiTags } from '@nestjs/swagger';
+import { DADOSFERA_MODULES_KEYS, PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import {
+  Authenticated,
+  RequireAllPermissions,
+  RequireModule,
+  RequireSomePermission,
+} from 'src/decorators/authentication.decorator';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { CustomersService } from './customers.service';
+import { CustomerLinkRequest, CustomerLinksResponse } from './dtos/customers';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import type { StringValue } from 'ms';
+import { PackTheMetadata } from 'src/utils/PackTheMetadata';
+import { EnforceMfa } from './dtos/enforce-mfa';
+
+@ApiTags('Customers')
+@Controller('customers')
+@UseFilters(GrpcToHttpExceptionFilter)
+export class CustomersController {
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private customersService: CustomersService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Post(':id/mfa')
+  @Authenticated()
+  @RequireSomePermission(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @RequireModule(DADOSFERA_MODULES_KEYS.DANGER_ZONE)
+  async enableMfaEnforce(@Param('id') id: string, @Body() data: EnforceMfa) {
+    this.logger.info('enableMfaEnforce', { id });
+    return await this.customersService.enableEnforceMfa(id, data.enabled);
+  }
+
+  @Get(':id/links')
+  @Authenticated()
+  @ApiOkResponse({ type: CustomerLinksResponse })
+  async getCustomerLinks(@Param('id') id: string) {
+    this.logger.info('getCustomerLinks', { id });
+    const links = await this.customersService.getLinks(id);
+    return { links };
+  }
+
+  @Put(':id/links')
+  @Authenticated()
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  @ApiOkResponse()
+  @HttpCode(HttpStatus.OK)
+  async setCustomerLinks(
+    @Body() body: CustomerLinkRequest,
+    @Param('id') id: string,
+  ) {
+    const { links } = body;
+    this.logger.info('setCustomerLinks', { id, links });
+    await this.customersService.setLinks(id, links);
+  }
+
+  @Get('token')
+  @Authenticated()
+  @RequireAllPermissions(PERMISSIONS_GROUPS.AUTH.permissions.GENERATE_TOKEN)
+  @ApiProduces('text/plain')
+  async getCustomerToken(
+    @Query('exp') exp: StringValue,
+    @User() user: RequestUser,
+  ): Promise<string> {
+    this.logger.info('getCustomerToken', { exp, user });
+    const data = {
+      customerId: user.customer_id,
+      userId: user.user_id,
+      customerName: user.customer_name,
+    };
+    return this.customersService.generateToken(exp, data);
+  }
+
+  @Get('monitoring-dashboard')
+  @Authenticated()
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.CUSTOMER.permissions.MONITORING_DASHBOARD,
+  )
+  async getCustomerMonitoringDashboard(
+    @User() user: RequestUser,
+  ): Promise<{ url: string }> {
+    this.logger.info('getCustomerMonitoringDashboard');
+
+    const metadata = PackTheMetadata(user);
+    return this.customersService.getMonitoringDashboardUrl(metadata);
+  }
+
+  @Get('logs-dashboard')
+  @Authenticated()
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.USERS.permissions.ADMIN,
+  )
+  @RequireModule(DADOSFERA_MODULES_KEYS.LOG_DASHBOARD)
+  async getCustomerMixPanelLogsDashboard(
+    @User() user: RequestUser,
+  ): Promise<{ url: string }> {
+    this.logger.info('getLogsDashboardUrl');
+    const metadata = PackTheMetadata(user);
+  
+    const result = await this.customersService.getLogsDashboardUrl(metadata);
+    return result;
+  }
+
+  @Get('access-dashboard')
+  @Authenticated()
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.USERS.permissions.ADMIN,
+  )
+  @RequireModule(DADOSFERA_MODULES_KEYS.ACCESS_DASHBOARD)
+  async getAccessDashboard(
+    @User() user: RequestUser,
+  ): Promise<{ url: string }> {
+    this.logger.info('getAccessDashboard');
+    const metadata = PackTheMetadata(user);
+  
+    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);
+  }
+
+}

src/modules/customers/customers.module.ts

@@ -0,0 +1,23 @@
+import { Module } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ClientsModule } from '@nestjs/microservices';
+import { DucClient } from '../duc/client.config';
+import { CustomersController } from './customers.controller';
+import { CustomersService } from './customers.service';
+import { PipelinesClientConfiguration } from '../pipelinesV2/pipelines-client';
+
+const ducClient = new DucClient();
+const piFactoryClient = new PipelinesClientConfiguration();
+
+@Module({
+  imports: [
+    ClientsModule.register([
+      ducClient.providerOptions,
+      piFactoryClient.providerOptions,
+    ]),
+  ],
+  controllers: [CustomersController],
+  providers: [CustomersService, DadosferaLogger],
+  exports: [CustomersService],
+})
+export class CustomersModule {}

src/modules/customers/customers.service.ts

@@ -0,0 +1,279 @@
+import {
+  OnModuleInit,
+  Inject,
+  Injectable,
+  HttpException,
+  HttpStatus,
+  InternalServerErrorException,
+  ForbiddenException,
+} from '@nestjs/common';
+
+import { firstValueFrom, lastValueFrom } from 'rxjs';
+import { DucClient } from '../duc/client.config';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
+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 {
+  GetSecretValueCommand,
+  SecretsManagerClient,
+} from '@aws-sdk/client-secrets-manager';
+import getEnv from 'src/utils/getEnv';
+import { logger } from 'elastic-apm-node';
+import {
+  ReadService,
+  ProtoServices as PipelineProtoServices,
+} from '@dadosfera/protospack-v2/dist/lib/PipelineV2';
+import { Metadata } from '@grpc/grpc-js';
+import { PipelinesClientConfiguration } from '../pipelinesV2/pipelines-client';
+import DadosferaLogger from '@dadosfera/dadosfera-logs';
+
+// This function will accept any string, which may result in a bug.
+@Injectable()
+export class CustomersService implements OnModuleInit {
+
+  private customerService: CustomersProtoService;
+  private logger: DadosferaLogger;
+  private pipelineReadService: ReadService.PipelineV2ReadService;
+
+  constructor(
+    @Inject(DucClient.name) private readonly grpcClient: ClientGrpc,
+    @Inject(PipelinesClientConfiguration.name)
+    private readonly pipelinesGrpcClient: ClientGrpc,
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.customerService = this.grpcClient.getService<CustomersProtoService>(
+      ProtoServices.CustomersProtoService,
+    );
+    this.pipelineReadService =
+      this.pipelinesGrpcClient.getService<ReadService.PipelineV2ReadService>(
+        PipelineProtoServices.PipelineV2ReadService,
+      );
+  }
+
+  async getCustomer(customerId: string) {
+    return await lastValueFrom(
+      this.customerService.CustomerFindOneById({
+        id: customerId
+      })
+    )
+  }
+
+  async getLinks(customerId: string): Promise<CustomerLinksConfig | null> {
+    try {
+      const result = await lastValueFrom(
+        this.customerService.CustomerGetLinks({ customerId }),
+      );
+      return (result.links as CustomerLinksConfig) || null;
+    } catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      throw err;
+    }
+  }
+
+  async setLinks(customerId: string, links: CustomerLinksConfig) {
+    if (!customerId || !links) {
+      throw new HttpException(null, HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      return await firstValueFrom(
+        this.customerService.CustomerSetLinks({
+          customerId,
+          links: links as CustomerSetLinksRequest['links'],
+        }),
+      );
+    } catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      else throw err;
+    }
+  }
+
+  async generateToken(
+    expiresIn = '30m',
+    data: { customerId: string; userId: string; customerName: string },
+  ) {
+    const { customerId, userId: generatedById, customerName } = data;
+
+    const secretsManagerClient = new SecretsManagerClient({});
+
+    const getSecretComand = new GetSecretValueCommand({
+      SecretId: `${getEnv()}/${customerName}/jwt-signing-key`,
+    });
+    let private_key_pem;
+    await secretsManagerClient
+      .send(getSecretComand)
+      .then((res) => {
+        const secret = JSON.parse(res.SecretString);
+
+        private_key_pem = secret.private_key_pem;
+      })
+      .catch((err) => {
+        logger.error(err.stack);
+        throw new InternalServerErrorException(
+          'Error finding keys for customer',
+        );
+      });
+    let jwt_token;
+    try {
+      jwt_token = jwt.sign(
+        {
+          customerId,
+          generatedById,
+        },
+        private_key_pem,
+        {
+          algorithm: 'RS256',
+          expiresIn,
+          issuer: 'maestro',
+        },
+      );
+    } catch (err) {
+      logger.error(err.stack);
+      throw new InternalServerErrorException('Error generating token');
+    }
+    // const verify = jwt.verify(jwt_token, public_key_pem, {
+    //   algorithms: ['RS256'],
+    //   issuer: 'maestro',
+    // });
+    // const decoded = jwt.decode(jwt_token, { complete: true });
+    return jwt_token;
+  }
+
+  async getMonitoringDashboardUrl(metadata: Metadata) {
+    logger.info('CustomersService - getMonitoringDashboardUrl');
+
+    const res = await lastValueFrom(
+      this.pipelineReadService.PipelineV2GetDashboardUrl(
+        {
+          dashboard_id: '98',
+          exp: '15m',
+          metabase_customer_name: 'dadosferatech',
+        },
+        metadata,
+      ),
+    );
+    logger.info('Done');
+
+    return res;
+  }
+
+  async getLogsDashboardUrl(metadata: Metadata) {
+    logger.info('CustomersService - getMixPanelLogsDashboardUrl');
+  
+    const res = await lastValueFrom(
+      this.pipelineReadService.PipelineV2GetDashboardUrl(
+        {
+          dashboard_id: '103',
+          exp: '15m',
+          metabase_customer_name: 'dadosferatech',
+        },
+        metadata,
+      ),
+    );
+    logger.info('Done');
+  
+    return res;
+  }
+
+  async getAccessDashboardUrl(customerName: string, metadata: Metadata) {
+    /*
+     * TODO(Refactor): dar um jeito de exibir o dash da sbm diferente dos outros customer
+     * pois o signicado de department para sbm significa as instituições do usuários
+     */
+    if (customerName !== 'sbmoffshorecom') {
+      throw new ForbiddenException();
+    }
+    logger.info('CustomersService - getAccessDashboardUrl');
+  
+    const res = await this.getDashboardUrl('105', metadata);
+    logger.info('Done');
+  
+    return res;
+  }
+
+  private async getDashboardUrl(dashboardId: string, metadata: Metadata) {
+    return await lastValueFrom(
+      this.pipelineReadService.PipelineV2GetDashboardUrl(
+        {
+          dashboard_id: dashboardId,
+          exp: '15m',
+          metabase_customer_name: 'dadosferatech',
+        },
+        metadata
+      )
+    );
+  }
+
+  async enableEnforceMfa(id: string, enabled: boolean) {
+    return await lastValueFrom(
+      this.customerService.CustomerUpdateEnforceMfa({
+        customerId: id,
+        enforceMfa: enabled
+      })
+    )
+  }
+
+  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;
+    }
+  }
+
+}

src/modules/customers/dtos/customers.ts

@@ -0,0 +1,66 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CustomerLinkItem {
+  @ApiProperty()
+  href: string;
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  description: string;
+  @ApiPropertyOptional()
+  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: CustomerLinksConfig })
+  links: CustomerLinksConfig;
+}
+
+export class CustomerLinksResponse {
+  @ApiPropertyOptional({ type: CustomerLinksConfig })
+  links?: CustomerLinksConfig;
+}

src/modules/customers/dtos/enforce-mfa.ts

@@ -0,0 +1,6 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export class EnforceMfa {
+    @ApiProperty()
+    enabled: boolean
+}

src/modules/customers/dtos/organization.ts

@@ -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;
+}

src/modules/duc/client.config.ts

@@ -9,6 +9,10 @@ import {
   ProtoPaths,
 } from '@dadosfera/protospack-v2/dist/lib/Duc';
 
+const isLocalConnection =
+  process.env.DUC_URL.startsWith('duc:') ||
+  process.env.DUC_URL.includes('0.0.0.0');
+
 export class DucClient {
   public name = 'DucClient';
 
@@ -17,10 +21,7 @@ export class DucClient {
     options: {
       url: process.env.DUC_URL,
       package: [ProtoPackages.WritePackage, ProtoPackages.ReadPackage],
-      credentials:
-        process.env.LOCAL_ENV || process.env.ENV === 'local'
-          ? undefined
-          : credentials.createSsl(),
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
       protoPath: [ProtoPaths.WriteFilePath, ProtoPaths.ReadFilePath],
       loader: {
         keepCase: true,
@@ -28,6 +29,8 @@ export class DucClient {
         objects: true,
         arrays: true,
       },
+      maxSendMessageLength: 15 * 1024 * 1024, // 15 MB por mensagem
+      maxReceiveMessageLength: 15 * 1024 * 1024,
     },
   };