Merge pull request #218 from dadosfera/feat/choose-deploy-dockerhub

[ TECN-6603 ] CI: update action versions and choose wether to upload to dockerhub

.eslintrc.js

@@ -6,6 +6,7 @@ module.exports = {
   },
   plugins: ['@typescript-eslint/eslint-plugin'],
   extends: [
+    'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
     'plugin:prettier/recommended',
   ],

.github/workflows/deploy-manually.yml

@@ -6,13 +6,18 @@ on:
   workflow_dispatch:
     inputs:
       environment:
-        description: 'Deployment environment'
+        description: "Deployment environment"
         required: true
         type: choice
         options:
-          - dev
           - stg
+          - stg2
           - prd
+      push_to_dockerhub:
+        description: "Push image to Dockerhub?"
+        required: true
+        type: boolean
+        default: false
 
 jobs:
   extract_environment:
@@ -26,55 +31,57 @@ jobs:
       - name: Extract Environment
         run: |
           if [ ${EVENT} == "workflow_dispatch" ]; then
-            echo "##[set-output name=environment;]$(echo ${DEPLOY_ENV})"
+            echo "environment=${DEPLOY_ENV}" >> $GITHUB_OUTPUT
           elif [ ${GITHUB_REF} == "refs/heads/main" ]; then
-            echo "##[set-output name=environment;]$(echo "prd")"
+            echo "environment=prd" >> $GITHUB_OUTPUT
           fi
         id: extract_environment
 
   semantic_release:
     runs-on: ubuntu-latest
     outputs:
-      #new_release_published: ${{ steps.semantic.outputs.last_release_version != steps.semantic.outputs.new_release_version }}
       new_release_published: ${{ steps.semantic.outputs.new_release_published }}
-      #new_release_version: ${{ steps.semantic.outputs.new_release_version }}
       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@v2
+        uses: actions/checkout@v4
 
       - if: github.event_name != 'workflow_dispatch'
         name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v2
+        uses: cycjimmy/semantic-release-action@v4
         id: semantic
         with:
-          semantic_version: 16
           extra_plugins: |
-            conventional-changelog-eslint
+            conventional-changelog-eslint@4.0.0
           branches: |
             [
               'main'
             ]
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+  deploy-info:
+    if: ${{ github.event_name == 'workflow_dispatch'}}
+    needs: [extract_environment, semantic_release]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Create summary
+        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
 
   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 }}']
+      [self-hosted, "${{ needs.extract_environment.outputs.environment }}"]
 
     steps:
-      - 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 ${GITHUB_REF#refs/heads/}
-
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Update Pip
         run: |
@@ -93,34 +100,52 @@ jobs:
           python3 -m pip install awsebcli --upgrade
 
       - name: Configure AWS Region
-        uses: aws-actions/configure-aws-credentials@v1
+        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:
           ENV: ${{ needs.extract_environment.outputs.environment }}
           IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
           ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: |
-          docker-compose -f build.docker-compose.yml build --build-arg NPM_TOKEN=${NPM_TOKEN}
+          docker-compose -f build.docker-compose.yml build
           docker-compose -f build.docker-compose.yml push
 
+      - name: Login to Docker Hub
+        if: ${{inputs.push_to_dockerhub}}
+        uses: docker/login-action@v2
+        with:
+          username: dadosfera
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      - name: Build, Tag, and Push Image to Dockerhub
+        if: ${{inputs.push_to_dockerhub}}
+        env:
+          ENV: ${{ needs.extract_environment.outputs.environment }}
+          IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
+          ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
+        run: |
+          docker-compose -f build.docker-compose.dockerhub.yml build
+          docker-compose -f build.docker-compose.dockerhub.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: Deploy AWS Beanstalk
@@ -138,3 +163,66 @@ jobs:
         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@v3
+
+      - name: Extract Docs BlockId and PageId
+        env:
+          ENV: ${{ needs.extract_environment.outputs.environment }}
+          STG2_DOCS_BLOCK_ID: ${{ secrets.DEV_DOCS_BLOCK_ID }}
+          STG2_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 == "stg2" ]; then
+            echo "block_id=$STG2_DOCS_BLOCK_ID" >> $GITHUB_OUTPUT
+            echo "page_id=$STG2_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
+
+      - name: Generate External API docs
+        env:
+          DOCS_URL: ${{ secrets.DOCS_URL }}
+          DOCS_API_TOKEN: ${{ secrets.DOCS_API_TOKEN }}
+          DOCS_PAGE_ID: ${{secrets.EXTERNAL_DOCS_PAGE_ID}}
+          DOCS_BLOCK_ID: ${{secrets.EXTERNAL_DOCS_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.external.json
+          fi
+          sed -i -e "s/\${DOCS_API_TOKEN}/$DOCS_API_TOKEN/g" docsfera.external.json
+          sed -i -e "s/\${DOCS_PAGE_ID}/$DOCS_PAGE_ID/g" docsfera.external.json
+          sed -i -e "s/\${DOCS_BLOCK_ID}/$DOCS_BLOCK_ID/g" docsfera.external.json
+          curl -X POST -H 'Content-Type: application/json' -d @docsfera.external.json $DOCS_URL

.github/workflows/test.yml

@@ -2,8 +2,6 @@ name: Test
 on:
   pull_request:
     branches:
-      - alpha
-      - beta
       - main
 
 jobs:
@@ -11,33 +9,20 @@ jobs:
     runs-on: self-hosted
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Install Docker Compose
-        run: |
-          python3 -m pip install docker-compose --upgrade
+        uses: actions/checkout@v3
 
       - name: Build
         env:
-          ENV: test
-          IMAGE_TAG: test
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          APP_NAME: ${{ github.event.repository.name }}
         run: |
-          export ENV=test
-          export IMAGE_TAG=test
-          export ACCOUNT_ID=test
-          docker-compose -f build.docker-compose.yml build --build-arg NPM_TOKEN=${NPM_TOKEN}
+          docker build -t $APP_NAME --target test .
 
       - name: Run Test
         env:
           ENV: test
-          IMAGE_TAG: test
-          ACCOUNT_ID: test
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          APP_NAME: ${{ github.event.repository.name }}
         run: |
-          export ENV=test
-          export IMAGE_TAG=test
-          docker-compose -f build.docker-compose.yml run -e NPM_TOKEN=${NPM_TOKEN} --rm --entrypoint="npm run test" maestro
+          docker run --rm --entrypoint="npm" $APP_NAME run test
 
       - name: Remove Docker's Trash
         if: always()

.gitignore

@@ -37,4 +37,4 @@ lerna-debug.log*
 # Ignore .env files
 *.env
 
-.env
+.env

.npmrc

@@ -1 +0,0 @@
-//registry.npmjs.org/:_authToken=${NPM_TOKEN}

.nvmrc

@@ -1 +1 @@
-18.3.0
+18.10.0

.releaserc.json

@@ -26,7 +26,6 @@
         "preset": "eslint"
       }
     ],
-    "@semantic-release/npm",
     "@semantic-release/github"
   ]
 }

.vscode/launch.json

@@ -0,0 +1,22 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug NestJs",
+      "request": "launch",
+      "runtimeArgs": [
+        "run",
+        "start:debug"
+      ],
+      "runtimeExecutable": "npm",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "type": "node",
+      "console": "integratedTerminal"
+    }
+  ]
+}

Dockerfile

@@ -1,17 +1,21 @@
-FROM node:18.3.0-alpine3.15 as packages
-WORKDIR /packages
-ARG NPM_TOKEN
-COPY package.json .
-COPY package-lock.json .
-COPY .npmrc .
-RUN npm install
-RUN rm -f ./.npmrc 
+# install all dependencies
+FROM node:18.10-alpine as packages
+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
 
-FROM node:14.15.4-alpine3.12
+# unit test specific build
+FROM node:18.10-alpine as test
+WORKDIR /app
+COPY --from=packages /app/node_modules ./node_modules
+COPY . ./
+
+FROM node:18.10-alpine
 WORKDIR /app
 COPY . /app/
-ARG NPM_TOKEN
-COPY --from=packages /packages/node_modules /app/node_modules
+COPY --from=packages /app/node_modules ./node_modules
 RUN npm run build
 EXPOSE 3333
-ENTRYPOINT npm run start
+ENTRYPOINT npm run start

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,50 +1,350 @@
-# Maestro
 <p align="center">
   <image src="./assets/maestro.svg" style="width:10rem">
-  <h1 align="center">Maestro</h1>  
-</p> 
-This is the Dadosfera´s gateway repository, it´s responsable for the communication between frontend application and Dadosfera´s mirosservices.
+</p>
 
-## 💻 Requirements
+# Maestro
 
-Before you start, make sure you have done the following steps:
+Maestro is the Dadosfera's gateway, it's responsible for the communication between the frontend application and Dadosfera's microservices.
 
-* Installed Nodejs version 16.14.2
-* Installed latest NPM version
+## 🚀 Starting
 
+These instructions will allow you to get a working copy of the project on your local machine for development and testing purposes.
 
+### 📋 Requirements
 
-## 🚀 Installing Maestro
+- [NodeJS v18.10.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
 
-First of all clone the repository:
- * SSH:
-```
-git clone git@github.com:dadosfera/maestro.git
-```
- * HTTPS:
-```
-git clone git@github.com:dadosfera/maestro.git
+### 🔧 Installation<a id="installation"></a>
+
+- Clone the repository
+
+  - SSH
+
+    ```
+    git clone git@github.com:dadosfera/maestro.git
+    ```
+
+    or
+
+  - HTTPS
+    ```
+    git clone https://github.com/dadosfera/maestro.git
+    ```
+
+- Select the correct node version (optional, only if using [NVM](https://github.com/nvm-sh/nvm)):
+
+  ```sh
+  nvm use
+  ```
+
+- Install the project dependencies:
+
+  ```sh
+  npm i
+  ```
+
+- Setup the following enviroment variables:
+
+  ```
+  ENV=
+  DUC_URL=
+  INFACTORY_URL=
+  OTFACTORY_URL=
+  PIFACTORY_URL=
+  SM_OAUTH_PATH=
+  ```
+
+- Start the server:
+
+  ```sh
+  # dev mode
+  npm run start:dev
+
+  # or in debug mode
+  npm run start:debug
+  ```
+
+  The service should start successfully.
+
+## 📄 Documentation
+
+NestJs makes it easy to document each route using decorators on all requests and responses properties. It automatically generates a swagger for given information and provides a route to access it http://localhost:3333/api.
+For more info check the [official documentation](https://docs.nestjs.com/openapi/introduction).
+
+### - Multiple documentations
+
+We are currently generating **2 different** documentations: Internal and External.
+
+All routes that have the decorator `@ApiInternalOnly()` will not be visible on the **External** API swagger.
+
+- When you start the application with `npm run start` it will serve and generate the swagger JSON of the **External** API
+- When you start the application with `npm run start:internal` it will serve and generate the swagger JSON of the **Internal** API
+- When you run `npm run docs` it will generate the swagger JSON of both **Internal** and **External** API, and save them to `docsfera.json` and `docsfera.external.json` respectively;
+
+It is important to run `npm run docs` before every deploy so we can always have the most updated docs published.
+
+## Authentication decorators
+
+Maestro have utilities to ease the user authentication on every controller and route. The following decorators are available:
+
+### `@Authenticated`
+
+If the user must be authenticated to make request, we can use the `@Authenticated` decorator in the controller or route, as needed.
+
+```ts
+import { Authenticated } from '../../authentication/authentication.decorator';
+
+@Controller('foo')
+@Authenticated()
+class FooController {
+  /* ... */
+
+  @Get('bar')
+  async getBar() {
+    this.logger.info('user is authenticated!');
+
+    return { authenticated: true };
+  }
+}
 ```
 
-## Enviroment variables
+```ts
+import { Authenticated } from '../../authentication/authentication.decorator';
 
-Here is a list of enviroment variables needed in order to run the application correctly.
+@Controller('foo')
+class FooController {
+  /* ... */
 
-```
-ENV=
-DUC_URL=
-INFACTORY_URL=
-TRFACTORY_URL=
-OTFACTORY_URL=
-PIFACTORY_URL=
-JWT_PRIVATE_KEY=
-AWS_IDENTITY_POOL_ID=
+  @Get('bar')
+  @Authenticated()
+  async getBar() {
+    this.logger.info('user is authenticated!');
+
+    return { authenticated: true };
+  }
+
+  @Post('bar')
+  async postBar() {
+    this.logger.info('user is NOT authenticated!');
+
+    return { authenticated: false };
+  }
+}
 ```
 
-## Running Maestro
+### `@RequireAllPermissions`
 
-In order to run Maestro just run the following command:
+This decorator requires that **all permissions** listed are granted to the requesting user.
+
+```ts
+import { RequireAllPermissions } from '../../authentication/authentication.decorator';
+import { PERMISSIONS } from '../../authentication/permissions.enum';
+
+@Controller('foo')
+class FooController {
+  /* ... */
+
+  @Get('bar')
+  @RequireAllPermissions(Permissions.BAR.MANAGE, Permissions.BAR.CREATE)
+  async getBar() {
+    /* ... */
+  }
+}
 ```
-npm run start:dev
+
+### `@RequireSomePermission`
+
+In the following case, the user is required to have **at least one** listed permission.
+
+```ts
+import { RequireSomePermission } from '../../authentication/authentication.decorator';
+import { PERMISSIONS } from '../../authentication/permissions.enum';
+
+@Controller('foo')
+@RequireSomePermission(Permissions.FOO.MANAGE, Permissions.FOO.CREATE)
+class FooController {
+  /* ... */
+
+  @Get('bar')
+  async getBar() {
+    /* ... */
+  }
+}
 ```
-If everything is fine the Maestro will start and be ready to receive HTTP requests
+
+### `@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`
+
+```ts
+import { AuthenticateCondition } from '../../authentication/authentication.decorator';
+
+@Controller('foo')
+// allow requests only from localhost
+@AuthenticateCondition((request: Request) => request.ip === '::ffff:127.0.0.1')
+class FooController {
+  /* ... */
+
+  @Get('bar')
+  async getBar() {
+    /* ... */
+  }
+
+  @Post('bar')
+  // allow requests only from a specific customer
+  @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.
+
+- 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.
+
+  ```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() {
+      /* ... */
+    }
+
+    @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**.
+
+  ```ts
+  // same behavior
+  @RequireAllPermissions(Permissions.BAR.MANAGE)
+  @RequireSomePermission(Permissions.BAR.MANAGE)
+  ```
+
+## `@User` parameter decorator
+
+The requesting user data can be obtained using the @User parameter decorator, like in the following snippet:
+
+```ts
+import { User, RequestUser } from '../../authentication/user.decorator';
+
+@Controller('foo')
+class FooController {
+  /* ... */
+
+  @Get('bar')
+  async getBar(@User() user: RequestUser) {
+    this.logger.info(user);
+
+    return { user };
+  }
+}
+```
+
+If the user is required to be logged in, set `required` to `true`, as you would want in the `change-password` operation:
+
+```ts
+import { User, RequestUser } from '../../authentication/user.decorator';
+
+@Controller('user')
+class UserController {
+  /* ... */
+
+  @Post('change-password')
+  @HttpCode(HttpStatus.OK)
+  async changePassword(
+    @User({ required: true }) user: RequestUser,
+    @Body() body: AuthChangePasswordRequest,
+  ) {
+    const { oldPassword, newPassword } = body;
+
+    return this.authClient.changePassword({
+      userId: user.user_id,
+      oldPassword,
+      newPassword,
+    });
+  }
+}
+```
+
+## 📦 Development
+
+### ⌨️ Coding Style
+
+By default, we use [ESLint](https://eslint.org/) + [Prettier](https://prettier.io/) with default settings.
+
+**We recommend using Visual Studio Code and installing the recommended extensions to ease the development process.**
+
+### Commits pattern
+
+Our workflow pipeline follows the conventional commits specs ([cheat sheets](https://cheatography.com/albelop/cheat-sheets/conventional-commits/)) to release versions accordingly.
+
+Format: `<type>[optional scope]: <description>`
+
+Example: `FIX: ensure Range headers adhere more closely to RFC 2616`
+
+### 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`.
+
+  **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.**
+
+- **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`.
+
+- **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`.
+
+- **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`.
+
+### 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
+
+## 🛠️ Built with
+
+Some technologies used in this project:
+
+- [NestJS](https://docs.nestjs.com) - Framework for building efficient and scalable NodeJS server-side applications
+
+## ⚙️ Back-end Architecture
+
+The architecture can be found at [this link](https://sites.google.com/dadosfera.ai/wikidoproduto/time/back-end).

build.docker-compose.dockerhub.yml

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

docker-compose.dockerhub.yml

@@ -0,0 +1,29 @@
+version: "3.8"
+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

docker-compose.yml

@@ -10,7 +10,7 @@ services:
       - .env
 
   node_exporter:
-    image: prom/node-exporter:v1.3.1
+    image: ${NODE_EXPORTER_URL}
     container_name: node_exporter
     restart: always
     volumes:

environment.d.ts

@@ -0,0 +1,18 @@
+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;
+    }
+  }
+}
+export {};

jest.config.ts

@@ -0,0 +1,18 @@
+import type { Config } from '@jest/types';
+const config: Config.InitialOptions = {
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  modulePaths: ['<rootDir>'],
+  roots: ['<rootDir>/src/', '<rootDir>/test/'],
+  testRegex: '.*\\.(test|spec)\\.[jt]s$',
+  transform: { '\\.[jt]s$': 'ts-jest' },
+  collectCoverageFrom: ['**/*.[jt]s'],
+  coverageDirectory: 'coverage',
+  coveragePathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '.*\\.module\\.[jt]s$',
+  ],
+  // moduleDirectories: ['node_modules'], // default is already 'node_modules'
+  // rootDir: '.', //No need
+  // testEnvironment: 'node', //Defaults to 'node'
+};
+export default config;

nest-cli.json

@@ -3,7 +3,11 @@
   "sourceRoot": "src",
   "compilerOptions": {
     "assets": [
-      "**/*.proto"
+      "**/*.proto",
+      {
+        "include": "i18n/**/*",
+        "watchAssets": true
+      }
     ],
     "plugins": [
       "@nestjs/swagger"

package.json

@@ -6,16 +6,19 @@
   "private": true,
   "license": "UNLICENSED",
   "engines": {
-    "node": "18.3.0"
+    "node": "18.10.0"
   },
   "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",
     "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: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:watch": "jest --watch",
@@ -25,31 +28,39 @@
   },
   "dependencies": {
     "@aws-sdk/client-secrets-manager": "^3.112.0",
+    "@dadosfera/dadosfera-logs": "^1.0.0-beta.4",
+    "@dadosfera/protospack-v2": "3.31.0",
     "@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",
-    "@victorradael/protospack": "2.5.0",
-    "@victorradael/protospack-v2": "1.1.1",
-    "axios": "^0.25.0",
+    "@nestjs/cli": "^9.4.2",
+    "@nestjs/common": "^9.4.0",
+    "@nestjs/config": "^2.3.1",
+    "@nestjs/core": "^9.4.0",
+    "@nestjs/mapped-types": "^1.2.2",
+    "@nestjs/microservices": "^9.4.0",
+    "@nestjs/passport": "^9.0.3",
+    "@nestjs/platform-express": "^9.4.0",
+    "@nestjs/schematics": "^9.1.0",
+    "@nestjs/swagger": "^6.3.0",
+    "@nestjs/testing": "^9.4.0",
+    "axios": "^0.27.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
     "cron-parser": "^4.4.0",
     "dotenv": "^14.3.2",
+    "elastic-apm-node": "^3.36.0",
     "helmet": "^5.1.0",
-    "jsonwebtoken": "^8.5.1",
+    "jsonwebtoken": "^9.0.0",
     "jwk-to-pem": "^2.0.5",
+    "mixpanel": "^0.17.0",
+    "ms": "^3.0.0-canary.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",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
     "rxjs": "^7.5.5",
@@ -59,9 +70,6 @@
     "multer": "1.4.5-lts.1"
   },
   "devDependencies": {
-    "@nestjs/cli": "^8.2.8",
-    "@nestjs/schematics": "^8.0.11",
-    "@nestjs/testing": "^8.4.7",
     "@types/express": "^4.17.13",
     "@types/jest": "27.0.2",
     "@types/jsonwebtoken": "^8.5.8",
@@ -87,22 +95,5 @@
     "ts-node": "^10.8.1",
     "tsconfig-paths": "^3.14.1",
     "typescript": "^4.6.3"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".*\\.spec\\.ts$",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "collectCoverageFrom": [
-      "**/*.(t|j)s"
-    ],
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
   }
 }

src/app.module.ts

@@ -1,86 +1,36 @@
 import { Module } from '@nestjs/common';
-import { ClientsModule } from '@nestjs/microservices';
-import { ConfigModule } from '@nestjs/config';
 
-import { InputsController } from './modules/inputs/inputs.controller';
-import { TransformationsController } from './modules/transformations/transformations.controller';
-import { OutputsController } from './modules/outputs/outputs.controllers';
-import { PipelinesController } from './modules/pipelines/pipelines.controller';
-import { AuthController } from './modules/auth/auth.controller';
-import { HealthController } from './modules/health/health.controller';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 
-import { InputsService } from './modules/inputs/inputs.service';
-import { TransformationsService } from './modules/transformations/transformations.service';
-import { OutputsService } from './modules/outputs/outputs.service';
-import { PipelinesService } from './modules/pipelines/pipelines.service';
-import { HealthService } from './modules/health/health.service';
-
-import { AuthClientService } from './clients/auth/client.service';
-import { InputsClientService } from './clients/inputs/client.service';
-import { TransformationsClientService } from './clients/transformations/client.service';
-import { OutputsClientService } from './clients/outputs/client.service';
-import { PipelinesClientService } from './clients/pipelines/client.service';
-import { PermissionsClientService } from './clients/permissions/client.service';
-
-import { OutputsClientConfiguration } from './clients/outputs/client.config';
-import { TransformationsClientConfiguration } from './clients/transformations/client.config';
-import { DucClient } from './clients/duc/client.config';
-import { InputsClientConfiguration } from './clients/inputs/client.config';
-import { PipelinesClientConfiguration } from './clients/pipelines/client.config';
-import { CatalogController } from './modules/catalog/catalog.controller';
-import { CatalogService } from './modules/catalog/catalog.service';
-import { OauthController } from './modules/oauth/oauth.controller';
-import { getOauthSecrets } from './utils/OauthSecrets';
-import { HubspotStrategy } from './modules/oauth/passport-strategies/hubspot-strategy';
-import { FacebookStrategy } from './modules/oauth/passport-strategies/facebook-strategy';
 import { AuthenticationGuard } from './authentication/authentication.guard';
-import { APP_GUARD } from '@nestjs/core';
-import { GoogleStrategy } from './modules/oauth/passport-strategies/google-strategy';
-import { MailChimpStrategy } from './modules/oauth/passport-strategies/mailchimp-strategy';
-import { SalesforceStrategy } from './modules/oauth/passport-strategies/salesforce-strategy';
-import { ConnectorClientConfiguration } from './clients/connector/client.config';
-import { ConnectorController } from './modules/connector/connector.controller';
-import { ConnectorClientService } from './clients/connector/client.service';
 
-const ducClient = new DucClient();
-const inputClient = new InputsClientConfiguration();
-const outputClient = new OutputsClientConfiguration();
-const pipelineClient = new PipelinesClientConfiguration();
-const transformationClient = new TransformationsClientConfiguration();
-const connectorClient = new ConnectorClientConfiguration();
+import { APP_GUARD } from '@nestjs/core';
+
+import { UsersModule } from './modules/users/users.module';
+import { RolesModule } from './modules/roles/roles.module';
+import { ConnectorModule } from './modules/connector/connector.module';
+import { AuthModule } from './modules/auth/auth.module';
+import { PermissionsModule } from './modules/permissions/permissions.module';
+import { TermsOfUseModule } from './modules/termsOfUse/termsOfUse.module';
+import { ConnectionModule } from './modules/connection/connection.module';
+import { ConnectionTestModule } from './modules/connection-test/connection-test.module';
+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';
+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';
 
 @Module({
-  controllers: [
-    InputsController,
-    TransformationsController,
-    OutputsController,
-    PipelinesController,
-    AuthController,
-    HealthController,
-    CatalogController,
-    OauthController,
-    ConnectorController,
-  ],
+  controllers: [],
   providers: [
-    { provide: 'OAUTH_SECRETS', useValue: getOauthSecrets() },
-    InputsService,
-    TransformationsService,
-    OutputsService,
-    PipelinesService,
-    ConnectorClientService,
-    HealthService,
-    InputsClientService,
-    TransformationsClientService,
-    OutputsClientService,
-    PipelinesClientService,
-    AuthClientService,
-    PermissionsClientService,
-    CatalogService,
-    HubspotStrategy,
-    FacebookStrategy,
-    GoogleStrategy,
-    MailChimpStrategy,
-    SalesforceStrategy,
+    DadosferaLogger,
     {
       provide: APP_GUARD,
       useClass: AuthenticationGuard,
@@ -90,33 +40,26 @@ const connectorClient = new ConnectorClientConfiguration();
     ConfigModule.forRoot({
       isGlobal: true,
     }),
-
-    ClientsModule.register([
-      {
-        name: 'INPUTS_PACKAGE',
-        ...inputClient.config(),
-      },
-      {
-        name: 'TRANSFORMATIONS_PACKAGE',
-        ...transformationClient.config(),
-      },
-      {
-        name: 'OUTPUTS_PACKAGE',
-        ...outputClient.config(),
-      },
-      {
-        name: 'DUC_PACKAGE',
-        ...ducClient.config(),
-      },
-      {
-        name: 'PIPELINES_PACKAGE',
-        ...pipelineClient.config(),
-      },
-      {
-        name: 'CONNECTOR_PACKAGE',
-        ...connectorClient.config(),
-      },
-    ]),
+    AuthModule,
+    ConnectionModule,
+    NetworkConfigModule,
+    InputsModule,
+    PipelinesV2Module,
+    CatalogModule,
+    ConnectorModule,
+    PermissionsModule,
+    TermsOfUseModule,
+    ConnectionTestModule,
+    PipelinesModule,
+    TransformationsModule,
+    UsersModule,
+    RolesModule,
+    OauthModule,
+    ProductboardModule,
+    MixpanelModule,
+    CustomersModule,
+    //Always leave HealthModule last, so it is on the bottom of swagger
+    HealthModule,
   ],
 })
 export class AppModule {}

src/authentication/authentication.decorator.ts

@@ -1,28 +0,0 @@
-import { SetMetadata, applyDecorators } from '@nestjs/common';
-import { Request } from 'express';
-import { Permission } from './permissions.enum';
-
-export const PERMISSIONS_KEY = '__PERMISSIONS__';
-export const MUST_BE_AUTHENTICATED_KEY = '__MUST_BE_AUTHENTICATED__';
-export const CUSTOM_AUTHENTICATION_FUNCTION_KEY =
-  '__CUSTOM_AUTHENTICATION_FUNCTION__';
-
-export type AuthenticationFunction = (req: Request, user: any) => boolean;
-
-export function RequirePermissions(...permissions: Permission[]) {
-  return applyDecorators(
-    SetMetadata(PERMISSIONS_KEY, permissions),
-    SetMetadata(MUST_BE_AUTHENTICATED_KEY, true),
-  );
-}
-
-export function AuthenticateCondition(func: AuthenticationFunction) {
-  return applyDecorators(
-    SetMetadata(CUSTOM_AUTHENTICATION_FUNCTION_KEY, func),
-    SetMetadata(MUST_BE_AUTHENTICATED_KEY, true),
-  );
-}
-
-export function Authenticated() {
-  return SetMetadata(MUST_BE_AUTHENTICATED_KEY, true);
-}

src/authentication/authentication.guard.spec.ts

@@ -0,0 +1,457 @@
+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 { Body, Controller, Get } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import {
+  AuthenticateCondition,
+  Authenticated,
+  RequireAllPermissions,
+  RequireSomePermission,
+} 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';
+
+const logger = {
+  info: (...args) => args,
+  error: (...args) => args,
+};
+@Controller('no-class-auth')
+class NoClassAuthController {
+  @Get('body')
+  async getBody(@Body() body) {
+    return { body };
+  }
+
+  @Get('authenticated')
+  @Authenticated()
+  async mustBeAuthenticated(@Body() body) {
+    return { body };
+  }
+
+  @Get('required-permission')
+  @RequireSomePermission(PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN)
+  async requiredPermission(@Body() body) {
+    return { body };
+  }
+
+  @Get('has-all-permissions')
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
+    PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE,
+  )
+  async hasAllPermissions(@Body() body) {
+    return { body };
+  }
+
+  @Get('has-some-permission')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN,
+    PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE,
+  )
+  async hasSomePermission(@Body() body) {
+    return { body };
+  }
+}
+
+@Controller('class-auth-condition')
+@AuthenticateCondition((req) => req.get('x-on-class') === 'ok')
+@RequireSomePermission(PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE)
+class ClassAuthConditionController {
+  @Get('body')
+  async getBody(@Body() body) {
+    return { body };
+  }
+
+  @Get('authenticated')
+  @Authenticated()
+  async mustBeAuthenticated(@Body() body) {
+    return { body };
+  }
+
+  @Get('required-permission')
+  @AuthenticateCondition((req) => req.get('x-on-route') === 'ok')
+  @RequireSomePermission(PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN)
+  async requiredPermission(@Body() body) {
+    return { body };
+  }
+}
+
+describe('authentication.guard', () => {
+  let app: INestApplication;
+  const jwtSecretA = {
+    kid: 'token-a-testing-shared-key',
+    pem: '$tr0ng-SH4Red-secr3t!!!~gl0ba1~]',
+  };
+  const jwtSecretB = {
+    kid: 'token-b',
+    pem: 'another-shared-token',
+  };
+  const fakeUserPayload = {
+    user_id: 'd50d33c7-6c2b-463c-861f-e21667e7c125',
+    username: 'super.admin',
+    customer_id: '9d18e8ae-24b9-41a3-9e8f-a25ce57555b11',
+    customer_name: 'dadosfera',
+    customer_tier: 'BASIC',
+  };
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        {
+          provide: AuthClientService,
+          useValue: {
+            getPublicKeys: async () => ({
+              keys: [jwtSecretA, jwtSecretB],
+            }),
+          },
+        },
+        {
+          provide: DadosferaLogger,
+          useValue: { logger },
+        },
+        {
+          provide: APP_GUARD,
+          useClass: AuthenticationGuard,
+        },
+      ],
+      controllers: [NoClassAuthController, ClassAuthConditionController],
+    }).compile();
+
+    app = moduleRef.createNestApplication();
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  function AssertBodyNoAuth(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.OK);
+    expect(res.body).toStrictEqual({ body: {} });
+  }
+
+  function AssertBodyWithAuth(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.OK);
+    expect(res.body).toStrictEqual({
+      body: {
+        info: {
+          customer: 'dadosfera',
+          customer_id: '9d18e8ae-24b9-41a3-9e8f-a25ce57555b11',
+          customer_tier: 'BASIC',
+          user_id: 'd50d33c7-6c2b-463c-861f-e21667e7c125',
+        },
+      },
+    });
+  }
+
+  function AssertUnauthorized(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.UNAUTHORIZED);
+    expect(res.body).toStrictEqual({
+      code: ErrorCodes.AUTH.UNAUTHORIZED,
+      error: 'Não autenticado',
+      message: 'É necessário estar logado para realizar essa operação',
+      statusCode: HttpStatus.UNAUTHORIZED,
+    });
+  }
+
+  function AssertForbidden(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.FORBIDDEN);
+    expect(res.body).toStrictEqual({
+      code: ErrorCodes.AUTH.FORBIDDEN,
+      error: 'Não autorizado',
+      message:
+        'Você não tem permissões suficientes para realizar essa operação',
+      statusCode: HttpStatus.FORBIDDEN,
+    });
+  }
+
+  function NoClassAuthTest(accessToken: string, tokenName: string[]) {
+    const route = '/no-class-auth';
+
+    describe(`${route}, ${tokenName?.length ? tokenName : 'none'} auth`, () => {
+      it('should GET /body with user data (if available)', async () => {
+        const res = await request(app.getHttpServer())
+          .get(`${route}/body`)
+          .set({ Authorization: accessToken });
+
+        if (tokenName?.length) {
+          AssertBodyWithAuth(res);
+        } else {
+          AssertBodyNoAuth(res);
+        }
+      });
+
+      it('should GET /authenticated if authenticated', async () => {
+        const res = await request(app.getHttpServer())
+          .get(`${route}/authenticated`)
+          .set({ Authorization: accessToken });
+
+        if (tokenName?.length) {
+          AssertBodyWithAuth(res);
+        } else {
+          AssertUnauthorized(res);
+        }
+      });
+
+      it('should GET /required-permission if authenticated', async () => {
+        const res = await request(app.getHttpServer())
+          .get(`${route}/required-permission`)
+          .set({ Authorization: accessToken });
+
+        // zendesk required
+        if (tokenName?.includes('zendesk')) {
+          AssertBodyWithAuth(res);
+        } else if (tokenName?.length) {
+          AssertForbidden(res);
+        } else {
+          AssertUnauthorized(res);
+        }
+      });
+
+      it('should GET /has-all-permissions if authenticated', async () => {
+        const res = await request(app.getHttpServer())
+          .get(`${route}/has-all-permissions`)
+          .set({ Authorization: accessToken });
+
+        // zendesk and metabase
+        if (tokenName?.includes('zendesk') && tokenName?.includes('metabase')) {
+          AssertBodyWithAuth(res);
+        } else if (tokenName?.length) {
+          AssertForbidden(res);
+        } else {
+          AssertUnauthorized(res);
+        }
+      });
+
+      it('should GET /has-some-permission if authenticated', async () => {
+        const res = await request(app.getHttpServer())
+          .get(`${route}/has-some-permission`)
+          .set({ Authorization: accessToken });
+
+        // zendesk or metabase
+        if (tokenName?.includes('zendesk') || tokenName?.includes('metabase')) {
+          AssertBodyWithAuth(res);
+        } else if (tokenName?.length) {
+          AssertForbidden(res);
+        } else {
+          AssertUnauthorized(res);
+        }
+      });
+    });
+  }
+
+  function ClassAuthConditionTest(accessToken: string, tokenName: string[]) {
+    const route = '/class-auth-condition';
+
+    describe(`${route}, ${tokenName?.length ? tokenName : 'none'} auth`, () => {
+      describe('GET /body', () => {
+        it('should GET /body if authenticated and with correct headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/body`)
+            .set({
+              'x-on-class': 'ok',
+              Authorization: accessToken,
+            });
+
+          // metabase required
+          if (tokenName?.includes('metabase')) {
+            AssertBodyWithAuth(res);
+          } else if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+
+        it('should not GET /body without correct headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/body`)
+            .set({ Authorization: accessToken });
+
+          if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+      });
+
+      describe('GET /authenticated', () => {
+        it('should GET /authenticated if authenticated and with correct headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/authenticated`)
+            .set({
+              'x-on-class': 'ok',
+              Authorization: accessToken,
+            });
+
+          // metabase required
+          if (tokenName?.includes('metabase')) {
+            AssertBodyWithAuth(res);
+          } else if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+
+        it('should not GET /authenticated without correct class headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/authenticated`)
+            .set({ Authorization: accessToken });
+
+          if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+      });
+
+      describe('GET /required-permission', () => {
+        it('should GET /required-permission if authenticated and with correct headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/required-permission`)
+            .set({
+              'x-on-class': 'ok',
+              'x-on-route': 'ok',
+              Authorization: accessToken,
+            });
+
+          // zendesk and metabase
+          if (
+            tokenName?.includes('zendesk') &&
+            tokenName?.includes('metabase')
+          ) {
+            AssertBodyWithAuth(res);
+          } else if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+
+        it('should not GET /required-permission without correct route headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/required-permission`)
+            .set({
+              'x-on-class': 'ok',
+              Authorization: accessToken,
+            });
+
+          if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+
+        it('should not GET /required-permission without correct class headers', async () => {
+          const res = await request(app.getHttpServer())
+            .get(`${route}/required-permission`)
+            .set({
+              'x-on-route': 'ok',
+              Authorization: accessToken,
+            });
+
+          if (tokenName?.length) {
+            AssertForbidden(res);
+          } else {
+            AssertUnauthorized(res);
+          }
+        });
+      });
+    });
+  }
+
+  describe('token validation', () => {
+    it('should accept token kid A', async () => {
+      const Authorization = CreateToken([], {
+        jwt: {
+          kid: jwtSecretA.kid,
+          pem: jwtSecretA.pem,
+        },
+      });
+
+      const res = await request(app.getHttpServer())
+        .get('/no-class-auth/authenticated')
+        .set({
+          Authorization,
+        });
+
+      AssertBodyWithAuth(res);
+    });
+
+    it('should accept token kid B', async () => {
+      const Authorization = CreateToken([], {
+        jwt: {
+          kid: jwtSecretB.kid,
+          pem: jwtSecretB.pem,
+        },
+      });
+
+      const res = await request(app.getHttpServer())
+        .get('/no-class-auth/authenticated')
+        .set({
+          Authorization,
+        });
+
+      AssertBodyWithAuth(res);
+    });
+
+    it('should not accept unknown kid', async () => {
+      const Authorization = CreateToken([], {
+        jwt: {
+          kid: 'unknown-key-id',
+          pem: jwtSecretA.pem,
+        },
+      });
+
+      const res = await request(app.getHttpServer())
+        .get('/no-class-auth/authenticated')
+        .set({
+          Authorization,
+        });
+
+      AssertUnauthorized(res);
+    });
+  });
+
+  function CreateToken(permissions, overrides?: { user?: any; jwt?: any }) {
+    const tokenPayload = {
+      ...fakeUserPayload,
+      permissions: permissions.map(({ seqid }) => seqid),
+      token_use: 'access',
+      ...overrides?.user,
+    };
+
+    return jwt.sign(tokenPayload, overrides?.jwt?.pem ?? jwtSecretA.pem, {
+      keyid: overrides?.jwt?.kid ?? jwtSecretA.kid,
+    });
+  }
+
+  NoClassAuthTest(null, null);
+  ClassAuthConditionTest(null, null);
+
+  const tokenZ = CreateToken([PERMISSIONS_GROUPS.ZENDESK.permissions.OPEN]);
+  NoClassAuthTest(tokenZ, ['zendesk']);
+  ClassAuthConditionTest(tokenZ, ['zendesk']);
+
+  const tokenM = CreateToken([PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE]);
+  NoClassAuthTest(tokenM, ['metabase']);
+  ClassAuthConditionTest(tokenM, ['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

@@ -3,20 +3,18 @@ import {
   CanActivate,
   OnApplicationBootstrap,
   ExecutionContext,
-  Logger,
+  Inject,
 } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import assert from 'assert';
 import jwt from 'jsonwebtoken';
-
-import { AuthClientService } from '../clients/auth/client.service';
-import { Permission } from './permissions.enum';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { AuthClientService } from '../modules/auth/auth.service';
 import {
   AuthenticationFunction,
-  PERMISSIONS_KEY,
-  CUSTOM_AUTHENTICATION_FUNCTION_KEY,
-  MUST_BE_AUTHENTICATED_KEY,
-} from './authentication.decorator';
+  AUTH_FUNCTION_KEY,
+} from '../decorators/authentication.decorator';
+import { RequestUser } from '../decorators/user.decorator';
 import ErrorBuilder from '../utils/ErrorBuilder';
 import ErrorCodes from '../utils/errorCodes';
 
@@ -24,22 +22,25 @@ import ErrorCodes from '../utils/errorCodes';
 export class AuthenticationGuard
   implements CanActivate, OnApplicationBootstrap
 {
-  private readonly logger = new Logger(AuthenticationGuard.name);
+  logger: DadosferaLogger;
 
   pems: Map<string, string>;
 
   constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
     private reflector: Reflector,
     private authClient: AuthClientService,
   ) {
     this.pems = new Map();
+    this.logger = dadosferaLogger.logger;
   }
 
   async onApplicationBootstrap() {
     return this.loadDucJWKS();
   }
 
-  async loadDucJWKS() {
+  private async loadDucJWKS() {
     const { keys } = await this.authClient.getPublicKeys();
 
     keys.forEach((key) => {
@@ -48,57 +49,38 @@ export class AuthenticationGuard
   }
 
   canActivate(ctx: ExecutionContext): boolean {
-    const requiredPermissions = this.reflector.getAllAndOverride<Permission[]>(
-      PERMISSIONS_KEY,
-      [ctx.getHandler(), ctx.getClass()],
-    );
-    const customAuthenticationFunction =
-      this.reflector.getAllAndOverride<AuthenticationFunction>(
-        CUSTOM_AUTHENTICATION_FUNCTION_KEY,
-        [ctx.getHandler(), ctx.getClass()],
-      );
-    const mustBeAuthenticated = this.reflector.getAllAndOverride<boolean>(
-      MUST_BE_AUTHENTICATED_KEY,
-      [ctx.getHandler(), ctx.getClass()],
-    );
+    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.verifyToken(request, mustBeAuthenticated);
+    const accessToken = this.validateToken(request, mustBeAuthenticated);
+
+    if (!mustBeAuthenticated) {
+      // no need to be authenticated
+      return true;
+    }
 
     if (!accessToken) {
       // couldn't load valid token
-
-      if (!mustBeAuthenticated) {
-        // no need to be authenticated
-        return true;
-      }
-
       throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
     }
 
-    if (
-      typeof customAuthenticationFunction === 'function' &&
-      !customAuthenticationFunction(request, request.user)
-    ) {
-      // custom authentication function forbidden this request
-      throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
-    }
-
-    if (
-      Array.isArray(requiredPermissions) &&
-      requiredPermissions.length > 0 &&
-      !this.matchPermissions(requiredPermissions, accessToken.permissions)
-    ) {
-      // couldn't match permissions
+    // every authentication function must return true to authenticate
+    if (!authFunctions.every((func) => func(request, accessToken))) {
       throw new ErrorBuilder(ErrorCodes.AUTH.FORBIDDEN);
     }
 
     return true;
   }
 
-  private verifyToken(request, mustBeAuthenticated: boolean) {
+  private validateToken(
+    request,
+    mustBeAuthenticated: boolean,
+  ): RequestUser | false {
     const accessToken = request.get('Authorization');
-    let accessTokenPayload;
+    let accessTokenPayload: RequestUser;
 
     // If the user isn't authenticated, an error will occurr anywhere here.
     // Fancy error avoidance isn't performed by purpose, such as avoiding to access null values.
@@ -113,7 +95,7 @@ export class AuthenticationGuard
       );*/
 
       assert(
-        accessTokenDecoded.payload.token_use === 'access',
+        accessTokenDecoded?.payload?.token_use === 'access',
         'should be an access token',
       );
 
@@ -125,7 +107,7 @@ export class AuthenticationGuard
     } catch (err) {
       // log errors if authentication is required
       if (mustBeAuthenticated) {
-        this.logger.log('Unable to verify duc access token\n' + err.stack);
+        this.logger.error('Unable to verify duc access token\n' + err?.stack);
       }
 
       return false;
@@ -139,6 +121,7 @@ export class AuthenticationGuard
       customer_id: accessTokenPayload.customer_id,
       customer_name: accessTokenPayload.customer_name,
       customer_tier: accessTokenPayload.customer_tier,
+      access_token: accessToken,
     };
     // TODO: for backwards compatibility. remove in the future
     request.body.info = {
@@ -150,13 +133,4 @@ export class AuthenticationGuard
 
     return accessTokenPayload;
   }
-
-  private matchPermissions(
-    requiredPermissions: Permission[],
-    userPermissions: number[],
-  ) {
-    return requiredPermissions.some((permission) =>
-      userPermissions.includes(permission.seqid),
-    );
-  }
 }

src/authentication/permissions.enum.ts

@@ -1,5 +1,6 @@
 import { Logger } from '@nestjs/common';
 import assert from 'assert';
+import { LanguageEnum } from 'src/utils/languages.enum';
 
 const logger = new Logger();
 
@@ -8,10 +9,24 @@ export enum PermissionUsages {
   INTERNAL = 'internal',
 }
 
-export interface Permission {
+export interface PermissionsObjectPermission {
   seqid: number;
   claim: string;
   usage: PermissionUsages;
+  name?: Record<LanguageEnum, string>;
+}
+export interface PermissionsObjectPermissionTranslated {
+  seqid: number;
+  claim: string;
+  usage: PermissionUsages;
+  name?: string;
+}
+export interface PermissionsObjectGroup {
+  title: {
+    'pt-br': string;
+    'en-us': string;
+  };
+  permissions: Record<string, PermissionsObjectPermission>;
 }
 
 /*
@@ -22,216 +37,603 @@ export interface Permission {
 /*export const Permissions: {
   [P in keyof any]: { [Q in keyof any]: Permission };
 } = {*/
-export const Permissions = {
+export const PERMISSIONS_GROUPS = {
   AUTH: {
-    CREATE: {
-      seqid: 18,
-      claim: 'POST /auth',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Autenticação',
+      'en-us': 'Authentication',
+      'es-es': 'Authentication',
+    },
+    permissions: {
+      CREATE: {
+        seqid: 18,
+        claim: 'POST /auth',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': '',
+          'en-us': '',
+          '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: {
-    CREATE: {
-      seqid: 23,
-      claim: 'POST /pipelines',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Coletar | Pipelines',
+      'en-us': 'Collect | Pipelines',
+      'es-es': 'Colecta | Pipelines',
     },
-    GET: {
-      seqid: 13,
-      claim: 'GET /pipelines',
-      usage: PermissionUsages.PUBLIC,
-    },
-    UPDATE: {
-      seqid: 29,
-      claim: 'PUT /pipelines',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 5,
-      claim: 'DELETE /pipelines',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 23,
+        claim: 'POST /pipelines',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Criar pipelines',
+          'en-us': 'Create pipelines',
+          'es-es': 'Crear pipelines',
+        },
+      },
+      GET: {
+        seqid: 13,
+        claim: 'GET /pipelines',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Buscar pipelines',
+          'en-us': 'Get pipelines',
+          'es-es': 'Obtener pipelines',
+        },
+      },
+      UPDATE: {
+        seqid: 29,
+        claim: 'PUT /pipelines',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Atualizar pipeline',
+          'en-us': 'Update pipeline',
+          'es-es': 'Actualizar pipeline',
+        },
+      },
+      DELETE: {
+        seqid: 5,
+        claim: 'DELETE /pipelines',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Excluir pipeline',
+          'en-us': 'Delete pipeline',
+          'es-es': 'Eliminar pipeline',
+        },
+      },
     },
   },
 
-  INPUT: {
-    CREATE: {
-      seqid: 21,
-      claim: 'POST /inputs',
-      usage: PermissionUsages.PUBLIC,
+  CONNECTION: {
+    title: {
+      'pt-br': 'Coletar | Fontes de dados',
+      'en-us': 'Collect | Sources',
+      'es-es': 'Colecta | Sources',
     },
-    GET: {
-      seqid: 9,
-      claim: 'GET /inputs',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 37,
+        claim: 'connection:create',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Cadastrar Fonte',
+          'en-us': 'Create Source',
+          'es-es': 'Crear Source',
+        },
+      },
+      DELETE: {
+        seqid: 38,
+        claim: 'connection:delete',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Excluir Fonte',
+          'en-us': 'Remove Source',
+          'es-es': 'Eliminar Source',
+        },
+      },
+      UPDATE: {
+        seqid: 39,
+        claim: 'connection:update',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Editar Fonte',
+          'en-us': 'Edit Source',
+          'es-es': 'Editar Source',
+        },
+      },
     },
-    UPDATE: {
-      seqid: 27,
-      claim: 'PUT /inputs',
-      usage: PermissionUsages.PUBLIC,
+  },
+
+  NETWORK_CONFIG: {
+    title: {
+      'pt-br': 'Coletar | Redes',
+      'en-us': 'Collect | Network',
+      'es-es': 'Colecta | Network',
     },
-    UPDATE_PARTIAL: {
-      seqid: 17,
-      claim: 'PATCH /inputs',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 3,
-      claim: 'DELETE /inputs',
-      usage: PermissionUsages.PUBLIC,
-    },
-    GET_ENTITIES: {
-      seqid: 10,
-      claim: 'GET /inputs/available-entities',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 35,
+        claim: 'network_config:create',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Cadastrar VPN',
+          'en-us': 'Create VPN',
+          'es-es': 'Crear VPN',
+        },
+      },
+      // DELETE: {
+      //   seqid: 36,
+      //   claim: 'network_config:delete',
+      //   usage: PermissionUsages.PUBLIC,
+      //   name: {
+      //     'pt-br': 'Excluir VPN',
+      //     'en-us': 'Remove VPN',
+      //     'es-es': 'Eliminar VPN',
+      //   },
+      // },
     },
   },
 
   OUTPUT: {
-    CREATE: {
-      seqid: 22,
-      claim: 'POST /outputs',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Output',
+      'en-us': 'Output',
+      'es-es': 'Output',
     },
-    GET: {
-      seqid: 12,
-      claim: 'GET /outputs',
-      usage: PermissionUsages.PUBLIC,
-    },
-    UPDATE: {
-      seqid: 28,
-      claim: 'PUT /outputs',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 4,
-      claim: 'DELETE /outputs',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 22,
+        claim: 'POST /outputs',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Criar outputs',
+          'en-us': 'Create outputs',
+          'es-es': 'Crear outputs',
+        },
+      },
+      GET: {
+        seqid: 12,
+        claim: 'GET /outputs',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Buscar outputs',
+          'en-us': 'Get outputs',
+          'es-es': 'Obtener outputs',
+        },
+      },
+      UPDATE: {
+        seqid: 28,
+        claim: 'PUT /outputs',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Editar outputs',
+          'en-us': 'Edit outputs',
+          'es-es': 'Editar outputs',
+        },
+      },
+      DELETE: {
+        seqid: 4,
+        claim: 'DELETE /outputs',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Excluir outputs',
+          'en-us': 'Remove outputs',
+          'es-es': 'Eliminar outputs',
+        },
+      },
     },
   },
 
   TRANSFORMATIONS: {
-    CREATE: {
-      seqid: 24,
-      claim: 'POST /transformations',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Micro-transformações',
+      'en-us': 'Micro-transformations',
+      'es-es': 'Micro-transformaciones',
     },
-    GET: {
-      seqid: 15,
-      claim: 'GET /transformations',
-      usage: PermissionUsages.PUBLIC,
-    },
-    UPDATE: {
-      seqid: 30,
-      claim: 'PUT /transformations',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 6,
-      claim: 'DELETE /transformations',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 24,
+        claim: 'POST /transformations',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Criar micro-transformações',
+          'en-us': 'Create micro-transformations',
+          'es-es': 'Crear micro-transformaciones',
+        },
+      },
+      GET: {
+        seqid: 15,
+        claim: 'GET /transformations',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Buscar micro-transformações',
+          'en-us': 'Get micro-transformations',
+          'es-es': 'Obtener micro-transformaciones',
+        },
+      },
+      UPDATE: {
+        seqid: 30,
+        claim: 'PUT /transformations',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Editar micro-transformações',
+          'en-us': 'Edit micro-transformations',
+          'es-es': 'Editar micro-transformaciones',
+        },
+      },
+      DELETE: {
+        seqid: 6,
+        claim: 'DELETE /transformations',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Excluir micro-transformações',
+          'en-us': 'Remove micro-transformations',
+          'es-es': 'Eliminar micro-transformaciones',
+        },
+      },
     },
   },
 
   CATALOG: {
-    CREATE: {
-      seqid: 19,
-      claim: 'POST /catalog',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Explorar | Catálogo',
+      'en-us': 'Explore | Catalog',
+      'es-es': 'Explorar | Catalogar',
     },
-    GET: {
-      seqid: 7,
-      claim: 'GET /catalog',
-      usage: PermissionUsages.PUBLIC,
-    },
-    UPDATE: {
-      seqid: 25,
-      claim: 'PUT /catalog',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 1,
-      claim: 'DELETE /catalog',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      GET: {
+        seqid: 7,
+        claim: 'GET /catalog',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar lista de Ativos e visualizar atributos',
+          'en-us': 'Access Assets list and its attributes',
+          'es-es': 'Acceda a la lista de Activos y vea los atributos',
+        },
+      },
+      CREATE: {
+        seqid: 19,
+        claim: 'catalog:create',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Criar Ativos',
+          'en-us': 'Create Assets',
+          'es-es': 'Crear Activos',
+        },
+      },
+      UPDATE: {
+        seqid: 25,
+        claim: 'catalog:edit',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Criar e editar atributos no catálogo',
+          'en-us': 'Create and edit attributes on the catalog',
+          'es-es': 'Crear y editar atributos en el catálogo',
+        },
+      },
+      DELETE: {
+        seqid: 1,
+        claim: 'catalog:delete',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Excluir Ativos do catálogo',
+          'en-us': 'Remove Assets from the catalog',
+          'es-es': 'Eliminar Activos del catálogo',
+        },
+      },
+      DATA_MANAGER: {
+        seqid: 42,
+        claim: 'catalog:data_manager',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br':
+            'Gerente do catálogo. Consegue vizualizar e editar todos os ativos.',
+          'en-us': 'Catalog manager. Able to view and edit all assets.',
+          'es-es': 'Gestor de catálogos. Puede ver y editar todos los activos.',
+        },
+      },
+      EMBED_ANALYTICS: {
+        seqid: 44,
+        claim: 'catalog:embed',
+        usage: PermissionUsages.INTERNAL,
+        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',
+        },
+      },
+      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',
+        },
+      },
     },
   },
 
   CONNECTORS: {
-    CREATE: {
-      seqid: 20,
-      claim: 'POST /connectors',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Conectores',
+      'en-us': 'Connectors',
+      'es-es': 'Conectores',
     },
-    GET: {
-      seqid: 8,
-      claim: 'GET /connectors',
-      usage: PermissionUsages.PUBLIC,
-    },
-    UPDATE: {
-      seqid: 26,
-      claim: 'PUT /connectors',
-      usage: PermissionUsages.PUBLIC,
-    },
-    DELETE: {
-      seqid: 2,
-      claim: 'DELETE /connectors',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      CREATE: {
+        seqid: 20,
+        claim: 'POST /connectors',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Criar conectores',
+          'en-us': 'Create connectors',
+          'es-es': 'Crear conectores',
+        },
+      },
+      GET: {
+        seqid: 8,
+        claim: 'GET /connectors',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Buscar conectores',
+          'en-us': 'Get connectors',
+          'es-es': 'Obtener conectores',
+        },
+      },
+      UPDATE: {
+        seqid: 26,
+        claim: 'PUT /connectors',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Editar conectores',
+          'en-us': 'Edit connectors',
+          'es-es': 'Editar conectores',
+        },
+      },
+      DELETE: {
+        seqid: 2,
+        claim: 'DELETE /connectors',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Excluir conectores',
+          'en-us': 'Remove connectors',
+          'es-es': 'Eliminar conectores',
+        },
+      },
     },
   },
 
   SNOWFLAKE: {
-    OPEN: {
-      seqid: 14,
-      claim: 'GET /snowflake',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Explorar | Consolidar',
+      'en-us': 'Explore | Data consolidation',
+      'es-es': 'Explorar | Consolidación de datos',
+    },
+    permissions: {
+      OPEN: {
+        seqid: 14,
+        claim: 'GET /snowflake',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar Snowflake',
+          'en-us': 'Access Snowflake',
+          'es-es': 'Acceso Snowflake',
+        },
+      },
     },
   },
 
   ZENDESK: {
-    OPEN: {
-      seqid: 16,
-      claim: 'GET /zendesk',
-      usage: PermissionUsages.PUBLIC,
+    title: {
+      'pt-br': 'Zendesk',
+      'en-us': 'Zendesk',
+      'es-es': 'Zendesk',
+    },
+    permissions: {
+      OPEN: {
+        seqid: 16,
+        claim: 'support-chat:access',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Acessar chat de suporte',
+          'en-us': 'Access support chat',
+          'es-es': 'Acceder al chat de soporte',
+        },
+      },
     },
   },
 
-  METABASE: {
-    OPEN: {
-      seqid: 11,
-      claim: 'GET /metabase',
-      usage: PermissionUsages.PUBLIC,
+  DATAVIZ: {
+    title: {
+      'pt-br': 'Analisar | Visualização',
+      'en-us': 'Analyze | Visualization',
+      'es-es': 'Analizar | Visualización',
+    },
+    permissions: {
+      METABASE: {
+        seqid: 11,
+        claim: 'GET /metabase',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar Metabase',
+          'en-us': 'Access Metabase',
+          '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',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar Módulo de Inteligência',
+          'en-us': 'Access Intelligence Module',
+          'es-s': 'Acceder Módulo de Inteligencia',
+        },
+      },
     },
   },
 
-  ORCHEST: {
-    INTELLIGENCE: {
-      seqid: 31,
-      claim: 'intelligence:open',
-      usage: PermissionUsages.PUBLIC,
+  MODULES: {
+    title: {
+      'pt-br': 'Módulos da Dadosfera',
+      'en-us': 'Dadosfera Modules',
+      'es-es': 'Módulos de la Dadosfera',
     },
-    APP_BUILDER: {
-      seqid: 32,
-      claim: 'app-builder:open',
-      usage: PermissionUsages.PUBLIC,
+    permissions: {
+      APP_BUILDER: {
+        seqid: 32,
+        claim: 'app-builder:open',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Acessar App Builder',
+          'en-us': 'Access App Builder',
+          'es-es': 'Acceder App Builder',
+        },
+      },
+      MACHINE_LEARNING: {
+        seqid: 33,
+        claim: 'machine-learning:open',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'Acessar Machine Learning',
+          'en-us': 'Access Machine Learning',
+          'es-es': 'Acceder Machine Learning',
+        },
+      },
     },
-    MACHINE_LEARNING: {
-      seqid: 33,
-      claim: 'machine-learning:open',
-      usage: PermissionUsages.PUBLIC,
+  },
+  USERS: {
+    title: {
+      'pt-br': 'Usuários',
+      'en-us': 'Users',
+      'es-es': 'Usuarios',
+    },
+    permissions: {
+      ADMIN: {
+        seqid: 34,
+        claim: 'users:admin',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Gestão de usuários e grupos',
+          'en-us': 'Manage user and roles',
+          'es-es': 'Administrar usuarios y roles',
+        },
+      },
+    },
+  },
+  PROCESS: {
+    title: {
+      'pt-br': 'Processar',
+      'en-us': 'Process',
+      'es-es': 'Procesar',
+    },
+    permissions: {
+      TRANSFORMATION: {
+        seqid: 43,
+        claim: 'process:open',
+        usage: PermissionUsages.PUBLIC,
+        name: {
+          'pt-br': 'Acessar Módulo de Transformação',
+          'en-us': 'Access Transformation Module',
+          'es-es': 'Acceder Módulo de transformación',
+        },
+      },
+    },
+  },
+  DADOSFERA: {
+    title: {
+      'pt-br': 'Usuários',
+      'en-us': 'Users',
+      'es-es': 'Usuarios',
+    },
+    permissions: {
+      CONNECTIONS_MIGRATION: {
+        seqid: 40,
+        claim: 'dadosfera:connections-migration',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'connections-migration',
+          'en-us': 'connections-migration',
+          'es-es': 'connections-migration',
+        },
+      },
+      SYNC_USER: {
+        seqid: 41,
+        claim: 'dadosfera:sync-user',
+        usage: PermissionUsages.INTERNAL,
+        name: {
+          'pt-br': 'sync-user',
+          'en-us': 'sync-user',
+          'es-es': 'sync-user',
+        },
+      },
     },
   },
 };
-
+export interface DadosferaModule {
+  name: string;
+  description: string;
+  key: string;
+  permissionSeqId: number;
+}
+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).flatMap((namespace) =>
-  Object.values(namespace).map(({ seqid }) => seqid),
+const seqids = Object.values(PERMISSIONS_GROUPS).flatMap((namespace) =>
+  Object.values(namespace.permissions).map(({ seqid }) => seqid),
 );
-const claims = Object.values(Permissions).flatMap((namespace) =>
-  Object.values(namespace).map(({ claim }) => claim),
+const claims = Object.values(PERMISSIONS_GROUPS).flatMap((namespace) =>
+  Object.values(namespace.permissions).map(({ claim }) => claim),
 );
-Object.values(Permissions).map((namespace) =>
-  Object.values(namespace).map(({ seqid, claim }) => {
+Object.values(PERMISSIONS_GROUPS).map((namespace) =>
+  Object.values(namespace.permissions).map(({ seqid, claim }) => {
     const seqidsCount = seqids.filter((x) => x === seqid).length;
     assert(seqidsCount === 1, `seqid ${seqid} count is not 1`);
 
@@ -241,4 +643,9 @@ Object.values(Permissions).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/authentication/user.decorator.ts

@@ -1,23 +0,0 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common';
-
-import ErrorBuilder from '../utils/ErrorBuilder';
-import ErrorCodes from '../utils/errorCodes';
-
-export interface RequestUser {
-  user_id: string;
-  username: string;
-  permissions: string;
-  customer_id: string;
-  customer_name: string;
-  customer_tier: string;
-}
-
-export const User = createParamDecorator((data: any, ctx: ExecutionContext) => {
-  const request = ctx.switchToHttp().getRequest();
-
-  if (!request.user && data?.required) {
-    throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
-  }
-
-  return request.user;
-});

src/clients/auth/client.service.ts

@@ -1,150 +0,0 @@
-import { Logger, OnModuleInit, Inject } from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-
-import { ProtoServices } from '@victorradael/protospack-v2/dist/lib/Duc';
-import { AuthProtoService as AuthServiceInterface } from '@victorradael/protospack-v2/dist/lib/Duc/interfaces/write-service';
-import {
-  AuthGetPublicKeysResponse,
-  AuthSignInRequest,
-  AuthSignInResponse,
-  AuthRefreshAccessTokenRequest,
-  AuthRefreshAccessTokenResponse,
-  AuthEnableTotpMfaRequest,
-  AuthEnableTotpMfaResponse,
-  AuthDisableTotpMfaRequest,
-  AuthDisableTotpMfaResponse,
-  AuthDismissTotpMfaRequest,
-  AuthDismissTotpMfaResponse,
-  AuthVerifyTotpMfaRequest,
-  AuthVerifyTotpMfaResponse,
-  AuthChangePasswordRequest,
-  AuthChangePasswordResponse,
-  AuthResetPasswordRequest,
-  AuthResetPasswordResponse,
-  AuthVerifyResetPasswordCodeRequest,
-  AuthVerifyResetPasswordCodeResponse,
-  AuthConfirmResetPasswordRequest,
-  AuthConfirmResetPasswordResponse,
-} from '@victorradael/protospack-v2/dist/lib/Duc/interfaces/messages';
-
-import grpcHandler from '../../utils/grpcHandler';
-
-export class AuthClientService implements OnModuleInit {
-  private readonly logger = new Logger(AuthClientService.name);
-
-  private authService: AuthServiceInterface;
-  constructor(@Inject('DUC_PACKAGE') private readonly grpcClient: ClientGrpc) {}
-
-  onModuleInit() {
-    this.authService = this.grpcClient.getService<AuthServiceInterface>(
-      ProtoServices.AuthProtoService,
-    );
-  }
-
-  async getPublicKeys() {
-    this.logger.log('GetPublicKeys');
-
-    return grpcHandler<AuthGetPublicKeysResponse>(
-      this.authService.AuthGetPublicKeys({}),
-    );
-  }
-
-  async signIn({ username, password, totp }: AuthSignInRequest) {
-    this.logger.log('SignIn');
-
-    return grpcHandler<AuthSignInResponse>(
-      this.authService.AuthSignIn({ username, password, totp }),
-    );
-  }
-
-  async refreshAccessToken({ refreshToken }: AuthRefreshAccessTokenRequest) {
-    this.logger.log('RefreshAccessToken');
-
-    return grpcHandler<AuthRefreshAccessTokenResponse>(
-      this.authService.AuthRefreshAccessToken({ refreshToken }),
-    );
-  }
-
-  async changePassword({
-    accessToken,
-    oldPassword,
-    newPassword,
-  }: AuthChangePasswordRequest) {
-    this.logger.log('ChangePassword');
-
-    return grpcHandler<AuthChangePasswordResponse>(
-      this.authService.AuthChangePassword({
-        accessToken,
-        oldPassword,
-        newPassword,
-      }),
-    );
-  }
-
-  async resetPassword({ username }: AuthResetPasswordRequest) {
-    this.logger.log('resetPassword');
-
-    return grpcHandler<AuthResetPasswordResponse>(
-      this.authService.AuthResetPassword({ username }),
-    );
-  }
-
-  async verifyResetPasswordCode({
-    username,
-    code,
-  }: AuthVerifyResetPasswordCodeRequest) {
-    this.logger.log('verifyResetPasswordCode');
-
-    return grpcHandler<AuthVerifyResetPasswordCodeResponse>(
-      this.authService.AuthVerifyResetPasswordCode({ username, code }),
-    );
-  }
-
-  async confirmResetPassword({
-    username,
-    code,
-    newPassword,
-  }: AuthConfirmResetPasswordRequest) {
-    this.logger.log('confirmResetPassword');
-
-    return grpcHandler<AuthConfirmResetPasswordResponse>(
-      this.authService.AuthConfirmResetPassword({
-        username,
-        code,
-        newPassword,
-      }),
-    );
-  }
-
-  async enableTotpMFA({ accessToken, password }: AuthEnableTotpMfaRequest) {
-    this.logger.log('enableTotpMFA');
-
-    return grpcHandler<AuthEnableTotpMfaResponse>(
-      this.authService.AuthEnableTotpMfa({ accessToken, password }),
-    );
-  }
-
-  async disableTotpMFA({ accessToken, password }: AuthDisableTotpMfaRequest) {
-    this.logger.log('disableTotpMFA');
-
-    return grpcHandler<AuthDisableTotpMfaResponse>(
-      this.authService.AuthDisableTotpMfa({ accessToken, password }),
-    );
-  }
-
-  async dismissTotpMFA({ accessToken }: AuthDismissTotpMfaRequest) {
-    this.logger.log('dismissTotpMFA');
-
-    return grpcHandler<AuthDismissTotpMfaResponse>(
-      this.authService.AuthDismissTotpMfa({ accessToken }),
-    );
-  }
-
-  async verifyTotp({ accessToken, totp }: AuthVerifyTotpMfaRequest) {
-    this.logger.log('disableTotpMFA');
-
-    return grpcHandler<AuthVerifyTotpMfaResponse>(
-      this.authService.AuthVerifyTotpMfa({ accessToken, totp }),
-    );
-  }
-}

src/clients/connector/client.config.ts

@@ -1,31 +0,0 @@
-import { credentials } from '@grpc/grpc-js';
-import { ClientOptions, Transport } from '@nestjs/microservices';
-import { ConnectorManager } from '@victorradael/protospack-v2';
-
-export class ConnectorClientConfiguration {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.INFACTORY_URL,
-        package: [
-          ConnectorManager.ProtoPackages.WritePackage,
-          ConnectorManager.ProtoPackages.ReadPackage,
-        ],
-        credentials:
-          process.env.LOCAL_ENV === 'local'
-            ? undefined
-            : credentials.createSsl(),
-        protoPath: [
-          ConnectorManager.ProtoPaths.WriteFilePath,
-          ConnectorManager.ProtoPaths.ReadFilePath,
-        ],
-        loader: {
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/connector/client.service.ts

@@ -1,266 +0,0 @@
-import {
-  OnModuleInit,
-  Inject,
-  HttpException,
-  HttpStatus,
-} from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-import { ConnectorManager } from '@victorradael/protospack-v2';
-import { from } from 'rxjs';
-
-export class ConnectorClientService implements OnModuleInit {
-  private connectorServiceRead: ConnectorManager.ReadService.ConnectorManagerReadServices;
-  private connectorServiceWrite: ConnectorManager.WriteService.ConnectorManagerWriteServices;
-  constructor(
-    @Inject('CONNECTOR_PACKAGE') private readonly grpcClient: ClientGrpc,
-  ) {}
-
-  onModuleInit() {
-    this.connectorServiceWrite =
-      this.grpcClient.getService<ConnectorManager.WriteService.ConnectorManagerWriteServices>(
-        ConnectorManager.ProtoServices.ConnectorManagerWriteServices,
-      );
-
-    this.connectorServiceRead =
-      this.grpcClient.getService<ConnectorManager.ReadService.ConnectorManagerReadServices>(
-        ConnectorManager.ProtoServices.ConnectorManagerReadServices,
-      );
-  }
-
-  async uploadConnector(uploadConnector) {
-    const connector: ConnectorManager.Entities.ConnectorCreateRequest = {
-      file: {
-        buffer: uploadConnector.file.buffer,
-        mimetypes: uploadConnector.file.mimetype,
-      },
-      connector: JSON.stringify(uploadConnector.connector),
-    };
-    const serviceBody: ConnectorManager.Messages.RegisterConnectorRequest = {
-      connector,
-    };
-
-    const observable = from(
-      this.connectorServiceWrite.RegisterConnector(serviceBody),
-    );
-
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      console.log(err.details);
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'Upload');
-
-    return result;
-  }
-
-  async uploadFile(uploadFile) {
-    const body: ConnectorManager.Messages.UploadFileRequest = {
-      file: {
-        buffer: uploadFile.file.buffer,
-        mimetypes: uploadFile.file.mimetype,
-      },
-      name: uploadFile.name,
-    };
-
-    const observable = from(this.connectorServiceWrite.UploadFile(body));
-
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      console.log(err.details);
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'Upload');
-
-    return result;
-  }
-
-  async getAllConnectors(body) {
-    const observable = from(
-      this.connectorServiceRead.GetAllConnectors({
-        search: body.search,
-        filters: JSON.stringify(body.filters),
-      }),
-    );
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'getAllConnectors');
-
-    return result;
-  }
-
-  async getConnectorDetails(plugin: string) {
-    const observable = from(
-      this.connectorServiceRead.GetConnectorDetails({
-        plugin,
-      }),
-    );
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'getAllConnectors');
-
-    return result;
-  }
-
-  async getConnector(plugin: string) {
-    const observable = from(
-      this.connectorServiceRead.GetConnector({
-        plugin,
-      }),
-    );
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'getAllConnectors');
-
-    return result;
-  }
-
-  async deleteConnector(plugin: string, version: string) {
-    const observable = from(
-      this.connectorServiceWrite.DeleteConnector({
-        version,
-        plugin,
-      }),
-    );
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'getAllConnectors');
-
-    return result;
-  }
-
-  async updateConnector({ plugin, changes }) {
-    const observable = from(
-      this.connectorServiceWrite.UpdateConnector({
-        plugin,
-        changes,
-      }),
-    );
-    const result = await new Promise((resolve, reject) => {
-      observable.subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    }).catch((err) => {
-      throw new HttpException(
-        err.details,
-        err.code === 6 ? HttpStatus.CONFLICT : 400,
-      );
-    });
-
-    console.log('ConnectorClientService', 'getAllConnectors');
-
-    return result;
-  }
-}

src/clients/duc/client.config.ts

@@ -1,28 +0,0 @@
-import { credentials } from '@grpc/grpc-js';
-import { ClientOptions, Transport } from '@nestjs/microservices';
-import {
-  ProtoPackages,
-  ProtoPaths,
-} from '@victorradael/protospack-v2/dist/lib/Duc';
-
-export class DucClient {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.DUC_URL,
-        package: ProtoPackages.WritePackage,
-        credentials: process.env.LOCAL_ENV
-          ? undefined
-          : credentials.createSsl(),
-        protoPath: ProtoPaths.WriteFilePath,
-        loader: {
-          keepCase: true,
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/inputs/client.config.ts

@@ -1,25 +0,0 @@
-import { credentials } from '@grpc/grpc-js';
-import { ClientOptions, Transport } from '@nestjs/microservices';
-
-import { InputPackages, InputProtoFilePath } from '@victorradael/protospack';
-
-export class InputsClientConfiguration {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.INFACTORY_URL,
-        package: InputPackages,
-        credentials: process.env.LOCAL_ENV
-          ? undefined
-          : credentials.createSsl(),
-        protoPath: InputProtoFilePath,
-        loader: {
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/inputs/client.service.ts

@@ -1,290 +0,0 @@
-import {
-  OnModuleInit,
-  Inject,
-  HttpException,
-  HttpStatus,
-  NotFoundException,
-  InternalServerErrorException,
-} from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-import {
-  DecodeGrpcStruct,
-  EncodeJsonToGrpcStruct,
-  InputCreateS3Request,
-  InputNewCreateRequest,
-  InputService,
-  TestConnectionGetColumnsRequest,
-  TestConnectionRequest,
-} from '@victorradael/protospack';
-import axios, { AxiosRequestConfig } from 'axios';
-import { lastValueFrom } from 'rxjs';
-import { InputModel } from 'src/modules/inputs/dtos/input.model';
-import {
-  objectCamelToSnake,
-  objectSnakeToCamel,
-} from 'src/utils/CaseConverter';
-import { mustache } from 'src/utils/mustache';
-import { OauthSecrets } from 'src/utils/OauthSecrets';
-import { URLSearchParams } from 'url';
-import { IIdRequest, UpdateInputRequest } from './interfaces';
-
-export class InputsClientService implements OnModuleInit {
-  private inputService: InputService;
-  constructor(
-    @Inject('INPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
-    @Inject('OAUTH_SECRETS') private readonly oauthSecrets: OauthSecrets,
-  ) {}
-
-  async onModuleInit() {
-    this.inputService =
-      this.grpcClient.getService<InputService>('InputService');
-  }
-
-  async newCreate(createInputDto: InputNewCreateRequest) {
-    console.log('InputClientService', 'Create');
-
-    const input = await lastValueFrom(
-      this.inputService.NewCreate(objectSnakeToCamel(createInputDto)),
-    );
-    objectCamelToSnake(input);
-    return input;
-  }
-
-  async createGeneric(createInputGeneric) {
-    console.log('InputClientService', 'Create');
-    const { info, ...data } = createInputGeneric;
-    // data.credentials = await this.getInputTokens(data);
-    if (data.options) delete data.options;
-    if (data.credentials.oauth_code) delete data.credentials.oauth_code;
-    const grpcPayload = {
-      input: EncodeJsonToGrpcStruct(data),
-      info,
-    };
-    objectSnakeToCamel(grpcPayload);
-
-    const structReturn = await lastValueFrom(
-      this.inputService.Create(grpcPayload),
-    ).catch((err: { details: string }) => {
-      if (err.details === 'Item Not found!') {
-        throw new NotFoundException('Input not found');
-      }
-      throw new InternalServerErrorException(err.details);
-    });
-    objectCamelToSnake(structReturn);
-    const inputCreated = DecodeGrpcStruct(structReturn.input);
-    return { input: inputCreated };
-  }
-
-  async createS3Inputs(createInputDto: InputCreateS3Request) {
-    console.log('InputClientService', 'Create');
-    objectSnakeToCamel(createInputDto);
-    const createInputResponse = await lastValueFrom(
-      this.inputService.CreateS3(createInputDto),
-    ).catch((e) => {
-      throw new HttpException(e.details, 500);
-    });
-    console.log('done');
-    objectCamelToSnake(createInputResponse);
-    return createInputResponse;
-  }
-
-  async findOne(data: IIdRequest) {
-    console.log('InputClientService', 'FindOne');
-    const findOneInputResponse = await lastValueFrom(
-      this.inputService.FindOne(objectSnakeToCamel(data)),
-    ).catch((e) => {
-      throw new HttpException(e.details, HttpStatus.INTERNAL_SERVER_ERROR);
-    });
-    objectCamelToSnake(findOneInputResponse);
-    return findOneInputResponse;
-  }
-
-  async findAll(data) {
-    console.log('InputClientService', 'FindAll');
-    const findAllInputResponse = await lastValueFrom(
-      this.inputService.FindAll(objectSnakeToCamel(data)),
-    ).catch((e) => {
-      throw new HttpException(e.details, HttpStatus.INTERNAL_SERVER_ERROR);
-    });
-    findAllInputResponse.inputs.forEach((input) => objectCamelToSnake(input));
-
-    return findAllInputResponse;
-  }
-
-  async update(updateInputDTO: UpdateInputRequest) {
-    console.log('InputClientService', 'Update');
-    const updateInputResponse = await new Promise((resolve, reject) => {
-      this.inputService.Update(objectSnakeToCamel(updateInputDTO)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return updateInputResponse;
-  }
-
-  async remove(idRequest: IIdRequest) {
-    console.log('InputClientService', 'Remove');
-
-    const removeInputResponse = await new Promise((resolve, reject) => {
-      this.inputService.Remove(objectSnakeToCamel(idRequest)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return removeInputResponse;
-  }
-
-  async testConnection(data: TestConnectionRequest) {
-    console.log('InputClientService', 'TestConnection');
-    const testConnectionResponse = await new Promise((resolve, reject) => {
-      this.inputService.NewTestConnection(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return testConnectionResponse;
-  }
-
-  async getColumns(data: TestConnectionGetColumnsRequest) {
-    console.log('InputClientService', 'TestConnection/Get-Columns');
-    const getColumnsResponse = await new Promise((resolve, reject) => {
-      this.inputService.GetColumns(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return getColumnsResponse;
-  }
-  async getAuthSecrets(plugin) {
-    switch (plugin) {
-      case 'hubspot':
-        return {
-          client_id: this.oauthSecrets.hubspot.client_id || '',
-          client_secret: this.oauthSecrets.hubspot.client_secret || '',
-        };
-    }
-    return {};
-  }
-  async getInputTokens(input: InputModel) {
-    const { credentials } = input;
-    let credentialsTokens = {};
-    switch (credentials.connection_type) {
-      case 'oauth':
-        credentialsTokens = await this.getOauthTokens(input);
-        break;
-    }
-    return { ...credentials, ...credentialsTokens };
-  }
-  async getOauthTokens(input: InputModel) {
-    const tokens: Record<string, any> = {};
-    const { options, credentials } = input;
-    const { oauth } = options;
-    const { get_tokens_url_params, get_tokens_set_response } = oauth;
-    const secrets = await this.getAuthSecrets(input.plugin);
-    const get_tokens_url_params_string = mustache(get_tokens_url_params, {
-      ...secrets,
-      ...credentials,
-    });
-    let get_tokens_url_params_obj: Record<string, any> = {};
-    try {
-      get_tokens_url_params_obj = JSON.parse(get_tokens_url_params_string);
-    } catch (error) {
-      throw new HttpException('Erro transformando get_tokens_url_params', 400);
-    }
-    let params = {};
-    switch (oauth.content_type) {
-      case 'application/x-www-form-urlencoded':
-        params = new URLSearchParams(get_tokens_url_params_obj);
-        params = params.toString();
-        break;
-      default:
-        break;
-    }
-    const axiosRequestConfig: AxiosRequestConfig = {
-      url: oauth.get_tokens_url,
-      method: oauth.get_tokens_method || 'POST',
-      data: params,
-      headers: { 'content-type': oauth.content_type || 'application/json' },
-    };
-
-    const { data } = await axios(axiosRequestConfig).catch((err) => {
-      console.log(err.response.data);
-      throw new HttpException(err.response.data.message, err.response.status);
-    });
-    for (const key in get_tokens_set_response) {
-      const responseKey = get_tokens_set_response[key];
-      tokens[key] = data[responseKey];
-    }
-    const { redirect_uri } = get_tokens_url_params_obj;
-    tokens.redirect_uri = redirect_uri;
-    return tokens;
-  }
-
-  async getAvailableEntities(data) {
-    console.log('InputClientService', 'GetAvailableEntities');
-    objectSnakeToCamel(data);
-    const response = await lastValueFrom(
-      this.inputService.GetAvailableEntities(data),
-    ).catch((err) => {
-      console.log(err);
-      if (err.details && err.details.includes('400'))
-        throw new HttpException('Plugin inválido', HttpStatus.BAD_REQUEST);
-      throw new HttpException(err.details, HttpStatus.INTERNAL_SERVER_ERROR);
-    });
-    objectCamelToSnake(response);
-
-    return response;
-  }
-}

src/clients/outputs/client.config.ts

@@ -1,24 +0,0 @@
-import { OutputPackages, OutputProtoFilePath } from '@victorradael/protospack';
-import { ClientOptions, Transport } from '@nestjs/microservices';
-import { credentials } from '@grpc/grpc-js';
-
-export class OutputsClientConfiguration {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.OTFACTORY_URL,
-        package: OutputPackages,
-        credentials: process.env.LOCAL_ENV
-          ? undefined
-          : credentials.createSsl(),
-        protoPath: OutputProtoFilePath,
-        loader: {
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/outputs/client.service.ts

@@ -1,160 +0,0 @@
-import { Controller, Inject, OnModuleInit } from '@nestjs/common';
-import { ClientGrpc, Payload } from '@nestjs/microservices';
-import {
-  OutputServicesNames,
-  OutputsServiceInterface,
-} from '@victorradael/protospack';
-import {
-  objectCamelToSnake,
-  objectSnakeToCamel,
-} from 'src/utils/CaseConverter';
-import {
-  ICreateOutputRequest,
-  IIdRequest,
-  IOutputUpdateRequest,
-} from './interfaces';
-
-@Controller('output')
-export class OutputsClientService implements OnModuleInit {
-  private outputService: OutputsServiceInterface;
-  constructor(
-    @Inject('OUTPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
-  ) {}
-
-  onModuleInit() {
-    this.outputService = this.grpcClient.getService<OutputsServiceInterface>(
-      OutputServicesNames.OutputService,
-    );
-  }
-
-  async create(@Payload() createOutputDto: ICreateOutputRequest) {
-    console.log('OutputClientService', 'Create');
-
-    const createOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.Create(objectSnakeToCamel(createOutputDto)).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    const convertedItem = objectCamelToSnake(createOutputResponse['output']);
-    createOutputResponse['output'] = convertedItem;
-    return createOutputResponse;
-  }
-
-  async findAll(data) {
-    console.log('OutputClientService', 'FindAll');
-
-    const findAllOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.FindAll(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    const convertedOutputs = findAllOutputResponse['outputs'].map((ot) => {
-      return objectCamelToSnake(ot);
-    });
-
-    return { outputs: convertedOutputs };
-  }
-
-  async findOne(data: IIdRequest) {
-    console.log('OutputClientService', 'FindOne');
-
-    const findOneOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.FindOne(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return objectCamelToSnake(findOneOutputResponse);
-  }
-
-  async update(updateOutPutDTO: IOutputUpdateRequest) {
-    console.log('OutputClientService', 'Update');
-
-    const updateOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.Update(objectSnakeToCamel(updateOutPutDTO)).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return objectCamelToSnake(updateOutputResponse);
-  }
-
-  async remove(data: IIdRequest) {
-    console.log('OutputClientService', 'Remove');
-
-    const removeOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.Remove(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return removeOutputResponse;
-  }
-}

src/clients/outputs/interfaces.d.ts

@@ -1,29 +0,0 @@
-export interface ICreateOutputRequest {
-  operation: string;
-  name: string;
-  plugin: string;
-  values: Values;
-}
-
-export interface Values {
-  prefix: string;
-}
-
-interface Info {
-  user_id: string;
-  customer_id: string;
-}
-
-export interface IIdRequest {
-  id: string;
-  info: Info;
-}
-
-export interface IOutputUpdateRequest {
-  id: string;
-  operation: string;
-  values: Values;
-  plugin: string;
-  name: string;
-  info: Info;
-}

src/clients/permissions/client.service.ts

@@ -1,33 +0,0 @@
-import { Logger, OnModuleInit, Inject } from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-
-import { ProtoServices } from '@victorradael/protospack-v2/dist/lib/Duc';
-import { PermissionsProtoService as PermissionsServiceInterface } from '@victorradael/protospack-v2/dist/lib/Duc/interfaces/write-service';
-import {
-  Empty,
-  InjectPermissionsRequest,
-} from '@victorradael/protospack-v2/dist/lib/Duc/interfaces/messages';
-
-import grpcHandler from '../../utils/grpcHandler';
-
-export class PermissionsClientService implements OnModuleInit {
-  private readonly logger = new Logger(PermissionsClientService.name);
-
-  private permissionsService: PermissionsServiceInterface;
-  constructor(@Inject('DUC_PACKAGE') private readonly grpcClient: ClientGrpc) {}
-
-  onModuleInit() {
-    this.permissionsService =
-      this.grpcClient.getService<PermissionsServiceInterface>(
-        ProtoServices.PermissionsProtoService,
-      );
-  }
-
-  async injectPermissions({ permissions }: InjectPermissionsRequest) {
-    this.logger.log('InjectPermissions');
-
-    return grpcHandler<Empty>(
-      this.permissionsService.InjectPermissions({ permissions }),
-    );
-  }
-}

src/clients/pipelines/client.config.ts

@@ -1,27 +0,0 @@
-import { ClientOptions, Transport } from '@nestjs/microservices';
-import {
-  PipelinePackages,
-  PipelineProtoFilePath,
-} from '@victorradael/protospack';
-import { credentials } from '@grpc/grpc-js';
-
-export class PipelinesClientConfiguration {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.PIFACTORY_URL,
-        package: PipelinePackages,
-        credentials: process.env.LOCAL_ENV
-          ? undefined
-          : credentials.createSsl(),
-        protoPath: PipelineProtoFilePath,
-        loader: {
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/pipelines/client.service.ts

@@ -1,244 +0,0 @@
-import {
-  BadRequestException,
-  Inject,
-  InternalServerErrorException,
-  OnModuleInit,
-} from '@nestjs/common';
-import { ClientGrpc, Payload } from '@nestjs/microservices';
-import {
-  PipelineServicesNames,
-  PipelinesServiceInterface,
-} from '@victorradael/protospack';
-import { lastValueFrom } from 'rxjs';
-import {
-  objectCamelToSnake,
-  objectSnakeToCamel,
-} from 'src/utils/CaseConverter';
-import {
-  ICreatePipelineDto,
-  IGetPipelineLogsRequest,
-  IIdRequest,
-  IUpdatePipelineRequest,
-} from './interfaces';
-
-export class PipelinesClientService implements OnModuleInit {
-  private pipelineService: PipelinesServiceInterface;
-  constructor(
-    @Inject('PIPELINES_PACKAGE') private readonly grpcClient: ClientGrpc,
-  ) {}
-
-  onModuleInit() {
-    this.pipelineService =
-      this.grpcClient.getService<PipelinesServiceInterface>(
-        PipelineServicesNames.PipelineService,
-      );
-  }
-
-  async create(@Payload() createPipelineDto: ICreatePipelineDto) {
-    console.log('PipelinesClientService', 'Create');
-    const createPipelineResponse = await lastValueFrom(
-      this.pipelineService.Create(objectSnakeToCamel(createPipelineDto)),
-    ).catch((error: { details: string }) => {
-      if (error.details.includes('INVALID_REQUEST')) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [errorType, message] = error.details.split('|');
-        throw new BadRequestException(message);
-      }
-      throw new InternalServerErrorException(error.details);
-    });
-
-    return createPipelineResponse;
-  }
-
-  async findAll(data: IIdRequest) {
-    console.log('PipelinesClientService', 'FindAll');
-
-    const findAllPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.FindAll(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(x.pipelines);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return findAllPipelineResponse;
-  }
-
-  async findOne(data: IIdRequest) {
-    console.log('PipelinesClientService', 'FindOne');
-
-    const findOnePipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.FindOne(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return findOnePipelineResponse;
-  }
-
-  async update(UpdatePipelineRequest: IUpdatePipelineRequest) {
-    console.log('PipelinesClientService', 'Update');
-
-    const updatePipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService
-        .Update(objectSnakeToCamel(UpdatePipelineRequest))
-        .subscribe({
-          next(x) {
-            resolve(x);
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return updatePipelineResponse;
-  }
-
-  async remove(data: IIdRequest) {
-    console.log('PipelinesClientService', 'Remove');
-
-    const removePipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.remove(objectSnakeToCamel(data)).subscribe({
-        next(x) {
-          resolve(objectCamelToSnake(x));
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return removePipelineResponse;
-  }
-
-  async getPipelineLogsMessages(data: IGetPipelineLogsRequest) {
-    console.log('PipelinesClientService', 'GetPipelineLogsMessages');
-
-    const logsPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.getPipelineLogs(data).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return logsPipelineResponse;
-  }
-
-  async getPipelineStatus(data) {
-    console.log('PipelinesClientService', 'GetPipelineStatus');
-
-    const statusPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService
-        .getPipelineStatus(objectSnakeToCamel(data))
-        .subscribe({
-          next(x) {
-            const statusArray = x.status.sort((a, b) => {
-              if (a.id < b.id) {
-                return 1;
-              } else {
-                return -1;
-              }
-            });
-            resolve({ status: statusArray });
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return statusPipelineResponse;
-  }
-
-  async runPipeline({ id, info }: IIdRequest) {
-    console.log('PipelinesClientService', 'RunPipeline');
-    const statusPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService
-        .triggerPipeline(objectSnakeToCamel({ id, info }))
-        .subscribe({
-          next(x) {
-            if (x.status == false) {
-              reject(
-                'This pipeline is not ready yet to execute, Try again later!',
-              );
-            }
-            resolve(x);
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-    })
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return statusPipelineResponse;
-  }
-}

src/clients/transformations/client.config.ts

@@ -1,25 +0,0 @@
-import { ClientOptions, Transport } from '@nestjs/microservices';
-import {
-  TransformationPackages,
-  TransformationProtoFilePath,
-} from '@victorradael/protospack';
-import { credentials } from '@grpc/grpc-js';
-
-export class TransformationsClientConfiguration {
-  config(): ClientOptions {
-    return {
-      transport: Transport.GRPC,
-      options: {
-        url: process.env.INFACTORY_URL,
-        package: TransformationPackages,
-        credentials: credentials.createSsl(),
-        protoPath: TransformationProtoFilePath,
-        loader: {
-          enums: String,
-          objects: true,
-          arrays: true,
-        },
-      },
-    };
-  }
-}

src/clients/transformations/client.service.ts

@@ -1,173 +0,0 @@
-import { Controller, Inject, OnModuleInit, Post } from '@nestjs/common';
-import { ClientGrpc } from '@nestjs/microservices';
-import { TransformationsServiceInterface } from '@victorradael/protospack';
-import {
-  objectCamelToSnake,
-  objectSnakeToCamel,
-} from 'src/utils/CaseConverter';
-import { ICreateTransformationsRequest, IIdRequest } from './interfaces';
-
-@Controller('transformation')
-export class TransformationsClientService implements OnModuleInit {
-  private transformationService: TransformationsServiceInterface;
-  constructor(
-    @Inject('TRANSFORMATIONS_PACKAGE') private readonly grpcClient: ClientGrpc,
-  ) {}
-
-  onModuleInit() {
-    this.transformationService =
-      this.grpcClient.getService<TransformationsServiceInterface>(
-        'TransformationService',
-      );
-  }
-
-  @Post()
-  async create(createTransformationsDto: ICreateTransformationsRequest) {
-    console.log('TransformationClientService', 'Create');
-
-    const createTransformationResponse = await new Promise(
-      (resolve, reject) => {
-        this.transformationService
-          .Create(objectSnakeToCamel(createTransformationsDto))
-          .subscribe({
-            next(x) {
-              resolve(x);
-            },
-            error(err) {
-              console.log('Observable Error');
-              reject(err);
-            },
-            complete() {
-              console.log('done');
-            },
-          });
-      },
-    )
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    const convertedTransforms = createTransformationResponse[
-      'transformations'
-    ].map((tr) => {
-      return objectCamelToSnake(tr);
-    });
-
-    return { transformations: convertedTransforms };
-  }
-
-  async findAll(data) {
-    console.log('TransformationClientService', 'FindAll');
-
-    const findAllTransformationResponse = await new Promise(
-      (resolve, reject) => {
-        this.transformationService.FindAll(objectSnakeToCamel(data)).subscribe({
-          next(x) {
-            resolve(x);
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-      },
-    )
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-    const convertedTransforms = findAllTransformationResponse[
-      'transformations'
-    ].map((tr) => {
-      return objectCamelToSnake(tr);
-    });
-    return { transformations: convertedTransforms };
-  }
-
-  async findOne(data: IIdRequest) {
-    console.log('TransformationClientService', 'FindOne');
-
-    const findOneTransformationResponse = await new Promise(
-      (resolve, reject) => {
-        this.transformationService.FindOne(objectSnakeToCamel(data)).subscribe({
-          next(x) {
-            resolve(x);
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-      },
-    )
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return objectCamelToSnake(findOneTransformationResponse);
-  }
-
-  async update(updateTransformationDTO) {
-    console.log('TransformationClientService', 'Update');
-
-    const updateTransformationResponse = await new Promise(
-      (resolve, reject) => {
-        this.transformationService
-          .Update(objectSnakeToCamel(updateTransformationDTO))
-          .subscribe({
-            next(x) {
-              resolve(x);
-            },
-            error(err) {
-              console.log('Observable Error');
-              reject(err);
-            },
-            complete() {
-              console.log('done');
-            },
-          });
-      },
-    )
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return objectCamelToSnake(updateTransformationResponse);
-  }
-
-  async remove(data: IIdRequest) {
-    console.log('TransformationClientService', 'Remove');
-
-    const removeTransformationResponse = await new Promise(
-      (resolve, reject) => {
-        this.transformationService.Remove(objectSnakeToCamel(data)).subscribe({
-          next(x) {
-            resolve(x);
-          },
-          error(err) {
-            console.log('Observable Error');
-            reject(err);
-          },
-          complete() {
-            console.log('done');
-          },
-        });
-      },
-    )
-      .then((res) => res)
-      .catch((err) => {
-        throw new Error(err);
-      });
-
-    return objectCamelToSnake(removeTransformationResponse);
-  }
-}

src/decorators/authentication.decorator.ts

@@ -0,0 +1,41 @@
+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 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

@@ -0,0 +1,179 @@
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+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';
+
+const logger = {
+  info: (...args) => args,
+  error: (...args) => args,
+};
+@Controller('user')
+class UserController {
+  @Get()
+  public getUser(@User() user) {
+    return { user };
+  }
+
+  @Get('options')
+  public getUserWithOptions(@User({}) user) {
+    return { user };
+  }
+
+  @Get('not-required')
+  public getUserNotRequired(@User({ required: false }) user) {
+    return { user };
+  }
+
+  @Get('required')
+  public getUserRequired(@User({ required: true }) user) {
+    return { user };
+  }
+}
+
+describe('user.decorator', () => {
+  let app: INestApplication;
+  const jwt_secret = {
+    kid: 'token-testing-shared-key',
+    pem: '$tr0ng-SH4Red-secr3t!!!~gl0ba1~]',
+  };
+  const fakeUserPayload = {
+    user_id: 'd50d33c7-6c2b-463c-861f-e21667e7c125',
+    username: 'super.admin',
+    permissions: [PERMISSIONS_GROUPS.DATAVIZ.permissions.METABASE].map(
+      ({ seqid }) => seqid,
+    ),
+    customer_id: '9d18e8ae-24b9-41a3-9e8f-a25ce57555b11',
+    customer_name: 'dadosfera',
+    customer_tier: 'BASIC',
+    access_token: '',
+  };
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        {
+          provide: AuthClientService,
+          useValue: {
+            getPublicKeys: async () => ({
+              keys: [jwt_secret],
+            }),
+          },
+        },
+        {
+          provide: DadosferaLogger,
+          useValue: { logger },
+        },
+        {
+          provide: APP_GUARD,
+          useClass: AuthenticationGuard,
+        },
+      ],
+      controllers: [UserController],
+    }).compile();
+
+    app = moduleRef.createNestApplication();
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  function AssertNoAuth(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.OK);
+    expect(res.body).toStrictEqual({});
+  }
+
+  function AssertWithAuth(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.OK);
+    expect(res.body).toStrictEqual({ user: fakeUserPayload });
+  }
+
+  function AssertRequiredNoAuth(res: request.Response) {
+    expect(res.statusCode).toBe(HttpStatus.UNAUTHORIZED);
+    expect(res.body).toStrictEqual({
+      code: ErrorCodes.AUTH.UNAUTHORIZED,
+      error: 'Não autenticado',
+      message: 'É necessário estar logado para realizar essa operação',
+      statusCode: HttpStatus.UNAUTHORIZED,
+    });
+  }
+
+  function UserTest(accessToken: string) {
+    describe(`with${accessToken ? '' : 'out'} token`, () => {
+      it('should GET /user', async () => {
+        const res = await request(app.getHttpServer())
+          .get('/user')
+          .set({ Authorization: accessToken });
+
+        if (accessToken) {
+          AssertWithAuth(res);
+        } else {
+          AssertNoAuth(res);
+        }
+      });
+
+      it('should GET /user/options', async () => {
+        const res = await request(app.getHttpServer())
+          .get('/user/options')
+          .set({ Authorization: accessToken });
+
+        if (accessToken) {
+          AssertWithAuth(res);
+        } else {
+          AssertNoAuth(res);
+        }
+      });
+
+      it('should GET /user/not-required', async () => {
+        const res = await request(app.getHttpServer())
+          .get('/user/not-required')
+          .set({ Authorization: accessToken });
+
+        if (accessToken) {
+          AssertWithAuth(res);
+        } else {
+          AssertNoAuth(res);
+        }
+      });
+
+      it('should GET /user/required if logged', async () => {
+        const res = await request(app.getHttpServer())
+          .get('/user/required')
+          .set({ Authorization: accessToken });
+
+        if (accessToken) {
+          AssertWithAuth(res);
+        } else {
+          AssertRequiredNoAuth(res);
+        }
+      });
+    });
+  }
+
+  function CreateToken(overrides?) {
+    const tokenPayload = {
+      ...fakeUserPayload,
+      token_use: 'access',
+      ...overrides?.user,
+    };
+
+    return jwt.sign(tokenPayload, jwt_secret.pem, {
+      keyid: jwt_secret.kid,
+      ...overrides?.jwt,
+    });
+  }
+
+  UserTest(null);
+
+  const token = CreateToken();
+  fakeUserPayload.access_token = token;
+  UserTest(token);
+});

src/decorators/user.decorator.ts

@@ -0,0 +1,24 @@
+import { createParamDecorator, type ExecutionContext } from '@nestjs/common';
+
+import ErrorBuilder from '../utils/ErrorBuilder';
+import ErrorCodes from '../utils/errorCodes';
+
+export interface RequestUser {
+  user_id: string;
+  username: string;
+  permissions: number[];
+  customer_id: string;
+  customer_name: string;
+  customer_tier: string;
+  access_token: string;
+}
+
+export const User: (options?: { required?: boolean }) => ParameterDecorator =
+  createParamDecorator((options: any, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+
+    if (!request.user && options?.required) {
+      throw new ErrorBuilder(ErrorCodes.AUTH.UNAUTHORIZED);
+    }
+    return request.user;
+  });

src/error/grpc-to-http-exception.filter.ts

@@ -0,0 +1,37 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+} from '@nestjs/common';
+import { Response } from 'express';
+
+import ErrorBuilder from '../utils/ErrorBuilder';
+
+/**
+ * ExceptionFilter to handle RpcException thrown by our microservices
+ *
+ * If it detects that the exception is already an **HttpException** or it is generated by our **ErrorBuilder**,
+ * it will return the exception without any treatment.
+ */
+@Catch(Error)
+export class GrpcToHttpExceptionFilter implements ExceptionFilter {
+  catch(exception: any, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+
+    if (exception instanceof HttpException) {
+      return response
+        .status(exception.getStatus())
+        .json(exception.getResponse());
+    }
+
+    const err =
+      exception.constructor.name === ErrorBuilder.name
+        ? exception
+        : new ErrorBuilder(exception.details);
+
+    const { statusCode } = err.response;
+    return response.status(statusCode).json(err.response);
+  }
+}

src/error/http-exception.filter.spec.ts

@@ -1,7 +0,0 @@
-import { HttpExceptionFilter } from './http-exception.filter';
-
-describe('HttpExceptionFilter', () => {
-  it('should be defined', () => {
-    expect(new HttpExceptionFilter()).toBeDefined();
-  });
-});

src/main.ts

@@ -1,13 +1,22 @@
+if (process.env.ENV !== 'local') require('elastic-apm-node/start');
 import { NestFactory } from '@nestjs/core';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import helmet from 'helmet';
-
-import documentEmpty from '../swagger_empty.json';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 
 import { AppModule } from './app.module';
-
+import { writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { INestApplication } from '@nestjs/common';
 async function bootstrap() {
+  DadosferaLogger.setupLogger({
+    serviceName: 'maestro',
+    serviceEnvironment: process.env.ENV,
+  });
+  const logger = new DadosferaLogger();
+
   const app = await NestFactory.create(AppModule, {
+    logger,
     cors: {
       origin: '*',
       methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
@@ -15,24 +24,60 @@ async function bootstrap() {
       optionsSuccessStatus: 204,
     },
   });
-
   app.use(helmet());
+  configureSwagger(app);
+  await app.listen(3333);
+  if (process.env.KILL_AFTER_START) await app.close();
+}
 
-  const config = new DocumentBuilder()
-    .setTitle('Maestro')
+function configureSwagger(app: INestApplication) {
+  let branchName = '';
+  try {
+    branchName = execSync('git rev-parse --abbrev-ref HEAD')
+      .toString()
+      .replace('\n', '')
+      .trim();
+  } catch (error) {
+    console.warn("Can't get branch name", error);
+  }
+  const swaggerTitle = branchName ? `Maestro - ${branchName}` : 'Maestro';
+
+  const swaggerConfig = new DocumentBuilder()
+    .setTitle(swaggerTitle)
     .setDescription('Documentation for Maestro gateway')
-    .setVersion('1.0')
-    .addBearerAuth()
-    .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);
 
-  if (process.env.ENV != 'stg' && process.env.ENV != 'prd')
-    SwaggerModule.setup('api', app, document);
+  const swaggerJsonFile =
+    process.env.INTERNAL_SWAGGER === 'true'
+      ? 'docsfera.json'
+      : 'docsfera.external.json';
 
-  const swaggerDoc = process.env.ENV === 'dev' ? document : documentEmpty;
-  SwaggerModule.setup('api', app, swaggerDoc);
+  if (process.env.ENV === 'local') SwaggerModule.setup('api', app, document);
 
-  await app.listen(3333);
+  writeFileSync(
+    swaggerJsonFile,
+    JSON.stringify(
+      {
+        service: '${DOCS_API_TOKEN}',
+        pageId: '${DOCS_PAGE_ID}',
+        blockId: '${DOCS_BLOCK_ID}',
+        schema: document,
+      },
+      null,
+      2,
+    ),
+  );
 }
 bootstrap();

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

@@ -1,17 +1,25 @@
 import {
-  Logger,
   Body,
   Controller,
   Headers,
   Post,
   HttpCode,
   HttpStatus,
-  OnApplicationBootstrap,
+  Inject,
+  UseFilters,
+  Get,
+  UseGuards,
+  Redirect,
+  Req,
+  Param,
 } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
 import {
-  AuthSignInRequest,
-  AuthRefreshAccessTokenRequest,
+  ApiHeaders,
+  ApiOkResponse,
+  ApiSecurity,
+  ApiTags,
+} from '@nestjs/swagger';
+import {
   AuthChangePasswordRequest,
   AuthResetPasswordRequest,
   AuthVerifyResetPasswordCodeRequest,
@@ -19,74 +27,112 @@ import {
   AuthEnableTotpMfaRequest,
   AuthDisableTotpMfaRequest,
   AuthVerifyTotpMfaRequest,
-} from '@victorradael/protospack-v2/dist/lib/Duc/interfaces/messages';
+} from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
 
-import { AuthClientService } from '../../clients/auth/client.service';
-import { PermissionsClientService } from '../../clients/permissions/client.service';
-import { Permissions } from '../../authentication/permissions.enum';
-
-import ErrorBuilder from '../../utils/ErrorBuilder';
-import { LoginDto } from './dtos/login';
+import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from 'src/decorators/authentication.decorator';
+import { AuthClientService } from './auth.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { GrpcToHttpExceptionFilter } from '../../error/grpc-to-http-exception.filter';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import {
+  AuthRefreshAccessTokenReq,
+  AuthRefreshAccessTokenRes,
+  AuthSignInReq,
+  AuthSignInRes,
+} from './dtos/login';
+import { PackTheMetadata } from 'src/utils/ PackTheMetadata';
+import { AuthGuard } from '@nestjs/passport';
+import { Request } from 'express';
+import ErrorCodes, { OauthErrors } from 'src/utils/errorCodes';
+import jwt from 'jsonwebtoken';
+import { LanguageEnum } from 'src/utils/languages.enum';
+import { Language } from 'src/decorators/language.decorator';
+import { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
 
 @ApiTags('Auth')
+@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
+@UseFilters(new GrpcToHttpExceptionFilter())
 @Controller('auth')
-export class AuthController implements OnApplicationBootstrap {
-  private readonly logger = new Logger(AuthController.name);
+export class AuthController {
+  logger: DadosferaLogger;
+  redirectUrl: string;
 
   constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
     private authClient: AuthClientService,
-    private permissionsClient: PermissionsClientService,
-  ) {}
+  ) {
+    this.logger = dadosferaLogger.logger;
 
-  // internally used to send permissions to duc on microservice startup
-  async onApplicationBootstrap() {
-    this.logger.log('sending permissions to DUC...');
-
-    const permissions = Object.values(Permissions).flatMap((namespace) =>
-      Object.values(namespace),
-    );
-
-    return this.permissionsClient
-      .injectPermissions({ permissions })
-      .catch((err: ErrorBuilder) => {
-        if (
-          err.code === 'No connection established' &&
-          process.env.LOCAL_ENV === 'true'
-        ) {
-          return this.logger.log(
-            "couldn't connect to DUC. suppresing in local env",
-          );
-        }
-
-        throw err;
-      });
+    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 }: AuthSignInRequest) {
-    this.logger.log(`/auth`, 'SignIn');
-
-    return this.authClient.signIn({ username, password, totp });
+  async signIn(
+    @Body() { username, password, totp }: AuthSignInReq,
+    @Language() language: LanguageEnum,
+  ): Promise<AuthSignInRes> {
+    this.logger.info('/auth - SignIn');
+    const metadata = PackTheMetadata({ language });
+    return this.authClient.signIn({ username, password, totp }, metadata);
   }
 
   @Post('refresh-access-token')
   @HttpCode(HttpStatus.OK)
+  @ApiOkResponse({ type: AuthRefreshAccessTokenRes })
   async refreshAccessToken(
-    @Body() { refreshToken }: AuthRefreshAccessTokenRequest,
+    @Body() body: AuthRefreshAccessTokenReq,
+    @Language() language: LanguageEnum,
   ) {
-    this.logger.log(`/auth`, 'RefreshAccessToken');
+    this.logger.info('/auth - RefreshAccessToken');
+    const { refreshToken, customerName: customer_name } = body;
 
-    return this.authClient.refreshAccessToken({ refreshToken });
+    const metadata = PackTheMetadata({
+      customer_name,
+      language,
+    });
+
+    return this.authClient.refreshAccessToken({ refreshToken }, metadata);
   }
 
+  @ApiInternalOnlyEndpoint()
+  @Post('/sso/snowflake')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.SNOWFLAKE.permissions.OPEN)
+  @HttpCode(HttpStatus.OK)
+  async snowflakeSignIn(
+    @User() user: RequestUser,
+    @Body('RelayState') relayState: string,
+  ) {
+    this.logger.info('/auth - snowflakeSignIn');
+
+    return this.authClient.snowflakeSignIn({
+      userId: user.user_id,
+      relayState,
+    });
+  }
+
+  @ApiInternalOnlyEndpoint()
   @Post('change-password')
   @HttpCode(HttpStatus.OK)
   async changePassword(
     @Body() body: AuthChangePasswordRequest,
     @Headers() headers,
   ) {
-    this.logger.log(`/auth`, 'change-password');
+    this.logger.info('/auth - change-password');
 
     const { oldPassword, newPassword } = body;
     const { authorization: accessToken } = headers;
@@ -98,32 +144,41 @@ export class AuthController implements OnApplicationBootstrap {
     });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('reset-password')
   @HttpCode(HttpStatus.OK)
-  async resetPassword(@Body() body: AuthResetPasswordRequest) {
-    this.logger.log(`/auth`, 'reset-password');
+  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 });
+    return this.authClient.resetPassword({ username }, metadata);
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('verify-reset-password-code')
   @HttpCode(HttpStatus.OK)
   async verifyResetPasswordCode(
     @Body() body: AuthVerifyResetPasswordCodeRequest,
   ) {
-    this.logger.log(`/auth`, 'verify-reset-password-code');
+    this.logger.info('/auth - verify-reset-password-code');
 
     const { username, code } = body;
 
     return this.authClient.verifyResetPasswordCode({ username, code });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('confirm-reset-password')
   @HttpCode(HttpStatus.OK)
   async confirmResetPassword(@Body() body: AuthConfirmResetPasswordRequest) {
-    this.logger.log(`/auth`, 'confirm-reset-password');
+    this.logger.info('/auth - confirm-reset-password');
 
     const { username, code, newPassword } = body;
 
@@ -134,13 +189,14 @@ export class AuthController implements OnApplicationBootstrap {
     });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('enable-totp')
   @HttpCode(HttpStatus.OK)
   async enableTotpMFA(
     @Body() body: AuthEnableTotpMfaRequest,
     @Headers() headers,
   ) {
-    this.logger.log(`/auth`, 'enable-totp');
+    this.logger.info('/auth - enable-totp');
 
     const { password } = body;
     const { authorization: accessToken } = headers;
@@ -148,13 +204,14 @@ export class AuthController implements OnApplicationBootstrap {
     return this.authClient.enableTotpMFA({ accessToken, password });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('disable-totp')
   @HttpCode(HttpStatus.OK)
   async disableTotpMFA(
     @Body() body: AuthDisableTotpMfaRequest,
     @Headers() headers,
   ) {
-    this.logger.log(`/auth`, 'disable-totp');
+    this.logger.info('/auth - disable-totp');
 
     const { password } = body;
     const { authorization: accessToken } = headers;
@@ -162,24 +219,129 @@ export class AuthController implements OnApplicationBootstrap {
     return this.authClient.disableTotpMFA({ accessToken, password });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('dismiss-totp')
   @HttpCode(HttpStatus.OK)
   async dismissTotpMFA(@Headers() headers) {
-    this.logger.log(`/auth`, 'disable-totp');
+    this.logger.info('/auth - disable-totp');
 
     const { authorization: accessToken } = headers;
 
     return this.authClient.dismissTotpMFA({ accessToken });
   }
 
+  @ApiInternalOnlyEndpoint()
   @Post('verify-totp')
   @HttpCode(HttpStatus.OK)
   async verifyTotp(@Body() body: AuthVerifyTotpMfaRequest, @Headers() headers) {
-    this.logger.log(`/auth`, 'enable-totp');
+    this.logger.info('/auth - enable-totp');
 
     const { totp } = body;
     const { authorization: accessToken } = headers;
 
     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 };
+  }
 }

src/modules/auth/auth.module.ts

@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common';
+import { ClientsModule } from '@nestjs/microservices';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+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';
+const client = new DucClient();
+
+@Module({
+  imports: [ClientsModule.register([client.providerOptions])],
+  controllers: [AuthController],
+  providers: [
+    AuthClientService,
+    DadosferaLogger,
+    GoogleLoginStrategy,
+    { provide: 'OAUTH_SECRETS', useValue: getOauthSecrets() },
+  ],
+  exports: [AuthClientService],
+})
+export class AuthModule {}

src/modules/auth/auth.service.ts

@@ -0,0 +1,169 @@
+import { OnModuleInit, Inject, Injectable } 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 {
+  AuthSnowflakeSignInRequest,
+  AuthSignInRequest,
+  AuthRefreshAccessTokenRequest,
+  AuthEnableTotpMfaRequest,
+  AuthDisableTotpMfaRequest,
+  AuthDismissTotpMfaRequest,
+  AuthVerifyTotpMfaRequest,
+  AuthChangePasswordRequest,
+  AuthResetPasswordRequest,
+  AuthVerifyResetPasswordCodeRequest,
+  AuthConfirmResetPasswordRequest,
+} from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
+import { DucClient } from '../duc/client.config';
+import { Metadata } from '@grpc/grpc-js';
+
+@Injectable()
+export class AuthClientService implements OnModuleInit {
+  logger: DadosferaLogger;
+
+  private authService: AuthServiceInterface;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    @Inject(DucClient.name) private readonly grpcClient: ClientGrpc,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.authService = this.grpcClient.getService<AuthServiceInterface>(
+      ProtoServices.AuthProtoService,
+    );
+  }
+
+  async getPublicKeys() {
+    this.logger.info('GetPublicKeys');
+
+    return lastValueFrom(this.authService.AuthGetPublicKeys({}));
+  }
+
+  async snowflakeSignIn(input: AuthSnowflakeSignInRequest) {
+    this.logger.info('snowflakeSignIn');
+
+    return lastValueFrom(this.authService.AuthSnowflakeSignIn(input));
+  }
+
+  async signIn(
+    { username, password, totp }: AuthSignInRequest,
+    metadata: Metadata,
+  ) {
+    this.logger.info('SignIn');
+
+    return lastValueFrom(
+      this.authService.AuthSignIn({ username, password, totp }, metadata),
+    );
+  }
+
+  async refreshAccessToken(
+    { refreshToken }: AuthRefreshAccessTokenRequest,
+    metadata: Metadata,
+  ) {
+    this.logger.info('RefreshAccessToken');
+
+    return lastValueFrom(
+      this.authService.AuthRefreshAccessToken({ refreshToken }, metadata),
+    );
+  }
+
+  async changePassword({
+    accessToken,
+    oldPassword,
+    newPassword,
+  }: AuthChangePasswordRequest) {
+    this.logger.info('ChangePassword');
+
+    return lastValueFrom(
+      this.authService.AuthChangePassword({
+        accessToken,
+        oldPassword,
+        newPassword,
+      }),
+    );
+  }
+
+  async resetPassword(
+    { username }: AuthResetPasswordRequest,
+    metadata: Metadata,
+  ) {
+    this.logger.info('resetPassword');
+
+    return lastValueFrom(
+      this.authService.AuthResetPassword({ username }, metadata),
+    );
+  }
+
+  async verifyResetPasswordCode({
+    username,
+    code,
+  }: AuthVerifyResetPasswordCodeRequest) {
+    this.logger.info('verifyResetPasswordCode');
+
+    return lastValueFrom(
+      this.authService.AuthVerifyResetPasswordCode({ username, code }),
+    );
+  }
+
+  async confirmResetPassword({
+    username,
+    code,
+    newPassword,
+  }: AuthConfirmResetPasswordRequest) {
+    this.logger.info('confirmResetPassword');
+
+    return lastValueFrom(
+      this.authService.AuthConfirmResetPassword({
+        username,
+        code,
+        newPassword,
+      }),
+    );
+  }
+
+  async enableTotpMFA({ accessToken, password }: AuthEnableTotpMfaRequest) {
+    this.logger.info('enableTotpMFA');
+
+    return lastValueFrom(
+      this.authService.AuthEnableTotpMfa({ accessToken, password }),
+    );
+  }
+
+  async disableTotpMFA({ accessToken, password }: AuthDisableTotpMfaRequest) {
+    this.logger.info('disableTotpMFA');
+
+    return lastValueFrom(
+      this.authService.AuthDisableTotpMfa({ accessToken, password }),
+    );
+  }
+
+  async dismissTotpMFA({ accessToken }: AuthDismissTotpMfaRequest) {
+    this.logger.info('dismissTotpMFA');
+
+    return lastValueFrom(this.authService.AuthDismissTotpMfa({ accessToken }));
+  }
+
+  async verifyTotp({ accessToken, totp }: AuthVerifyTotpMfaRequest) {
+    this.logger.info('disableTotpMFA');
+
+    return lastValueFrom(
+      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 }));
+  }
+}

src/modules/auth/dtos/login.ts

@@ -1,4 +1,9 @@
-import { ApiProperty } from '@nestjs/swagger';
+import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
+import {
+  AuthSignInRequest,
+  AuthSignInResponse,
+} from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 
 export class LoginDto {
   @ApiProperty()
@@ -10,3 +15,106 @@ export class LoginDto {
   @ApiProperty({ required: false })
   totp: string;
 }
+export class AuthTokens {
+  @ApiProperty()
+  accessToken: string;
+  @ApiProperty()
+  refreshToken: string;
+  @ApiPropertyOptional()
+  termsOfUseToken: string;
+  @ApiProperty({ deprecated: true })
+  idToken: string;
+}
+export enum MfaStatuses {
+  PENDING = 'pending',
+  NONE = 'none',
+  TOTP = 'totp',
+}
+
+export enum TouStatuses {
+  PENDING = 'pending',
+  REQUIRED = 'required',
+  OK = 'ok',
+}
+export class TermsOfUse {
+  @ApiProperty()
+  version: number;
+  @ApiProperty()
+  publicUrl: string;
+  @ApiProperty()
+  enforceDate: string;
+  @ApiProperty()
+  createdAt: string;
+}
+export class TermsOfUseStatus {
+  @ApiProperty({ enum: TouStatuses })
+  status: string;
+  @ApiPropertyOptional()
+  lastSigned?: TermsOfUse;
+  @ApiPropertyOptional()
+  next?: TermsOfUse;
+}
+export class AuthUser {
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  username: string;
+  @ApiProperty()
+  createdAt: string;
+}
+export class AuthCustomer {
+  @ApiProperty()
+  modules: string[];
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  tier: string;
+  @ApiProperty()
+  scheduleLimit: string;
+  @ApiProperty()
+  links: Link[];
+}
+
+export class AuthSignInReq implements AuthSignInRequest {
+  @ApiProperty()
+  username: string;
+  @ApiProperty()
+  password: string;
+  @ApiPropertyOptional({
+    description:
+      'TOTP code used to login when Multi-Factor Authentication is enabled',
+  })
+  totp: string;
+}
+
+export class AuthSignInRes implements AuthSignInResponse {
+  @ApiProperty()
+  permissions: string[];
+  @ApiProperty({ enum: MfaStatuses })
+  mfaStatus: string;
+  @ApiPropertyOptional()
+  customer?: AuthCustomer;
+  @ApiPropertyOptional()
+  user?: AuthUser;
+  @ApiPropertyOptional()
+  tokens?: AuthTokens;
+  @ApiPropertyOptional()
+  termsOfUse?: TermsOfUseStatus;
+}
+
+export class AuthRefreshAccessTokenReq {
+  @ApiProperty()
+  refreshToken: string;
+  @ApiProperty()
+  customerName: string;
+}
+export class AuthRefreshAccessTokenRes {
+  @ApiProperty()
+  permissions: string[];
+  @ApiProperty()
+  accessToken: string;
+}

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

@@ -0,0 +1,46 @@
+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'],
+    };
+    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

@@ -0,0 +1,37 @@
+import {
+  ClientsProviderAsyncOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import { credentials } from '@grpc/grpc-js';
+import { Catalog } from '@dadosfera/protospack-v2';
+
+const isLocalConnection = !!process.env.PIFACTORY_URL?.includes('0.0.0.0');
+
+export class CatalogClientConfiguration {
+  public name = 'CatalogClientConfiguration';
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.PIFACTORY_URL,
+      package: [
+        Catalog.ProtoPackages.ReadPackage,
+        Catalog.ProtoPackages.WritePackage,
+      ],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [
+        Catalog.ProtoPaths.ReadFilePath,
+        Catalog.ProtoPaths.WriteFilePath,
+      ],
+      loader: {
+        keepCase: true,
+        enums: String,
+        defaults: false,
+      },
+    },
+  };
+  providerOptions: ClientsProviderAsyncOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/catalog/catalog.controller.ts

@@ -1,324 +1,636 @@
 import {
+  BadRequestException,
   Body,
   Controller,
   Delete,
+  ForbiddenException,
   Get,
+  Headers,
+  Inject,
+  NotFoundException,
   Param,
   Post,
+  Put,
   Query,
+  UseFilters,
 } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { AuthenticateCondition } from '../../authentication/authentication.decorator';
-import { Permissions } from '../../authentication/permissions.enum';
+import {
+  ApiCreatedResponse,
+  ApiHeaders,
+  ApiOkResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import {
+  Authenticated,
+  RequireAllPermissions,
+  RequireSomePermission,
+} from '../../decorators/authentication.decorator';
+import { PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
 import { CatalogService } from './catalog.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { PackTheMetadata } from 'src/utils/ PackTheMetadata';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import {
+  GetDatasetCatalogTaskRes,
+  ICatalogAllRequest,
+  ICatalogAllResponse,
+  IColumnsMetadataResponse,
+  ICreateDataAsset,
+  IDeleteComment,
+  IDocsResponse,
+  IMakeAComment,
+  IOneDataAsset,
+  IPreviewResponse,
+  IUpdateDataRequest,
+  TriggerCatalogReq,
+  TriggerCatalogRes,
+} 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 { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
 
 @ApiTags('Catalog')
+@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }])
 @Controller('catalog')
-@AuthenticateCondition((req, user) => {
-  let action;
-
-  switch (req.method) {
-    case 'POST':
-      action = 'CREATE';
-      break;
-
-    case 'PUT':
-      action = 'UPDATE';
-      break;
-
-    default:
-      action = req.method;
-  }
-
-  return user.permissions.includes(Permissions.CATALOG[action].seqid);
-})
+@UseFilters(new GrpcToHttpExceptionFilter())
+@Authenticated()
 export class CatalogController {
-  constructor(private catalogService: CatalogService) {}
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private catalogService: CatalogService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
 
-  @Get('all')
-  async catalogAll(@Body() body) {
-    console.log(`/catalog`, 'ON CATALOG ALL ROUTE');
+  @Get()
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async searchCatalog(
+    @User() user: RequestUser,
+    @Query() query: ICatalogAllRequest,
+  ): Promise<ICatalogAllResponse> {
+    const { user_id, customer_name, customer_id, username, permissions } = user;
+    this.logger.info(`/catalog - searchCatalog`, {
+      user_id,
+      customer_name,
+    });
 
-    const res = await this.catalogService.catalogAll(body);
+    const is_data_manager = permissions.includes(
+      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+    );
+
+    const roles = await this.catalogService.getUserRolesIds(user_id);
+
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      username,
+      roles,
+      is_data_manager,
+    });
+
+    const res = await this.catalogService.searchDataAssets(
+      query,
+      metadata,
+      customer_id,
+    );
 
     return res;
   }
 
-  @Get('data_apps')
-  async dataAppsAll(@Body() body) {
-    console.log(`/catalog`, 'ON FIND ALL DATA APPS ROUTE');
+  @ApiInternalOnlyEndpoint()
+  @Get('data-asset')
+  async findByPipelineAndObject(@User() user: RequestUser, @Query() query) {
+    const { username, user_id, customer_id, customer_name, permissions } = user;
+    const { pipeline, object } = query;
+    this.logger.info(`/catalog - ON GET DATA ASSET BY PIPELINE AND OBJECT`, {
+      username,
+      customer_name,
+    });
 
-    const res = await this.catalogService.dataAppsAll(body);
-
-    return res;
-  }
-
-  @Delete('data_apps/:id')
-  async dataAppsOne(@Param() params, @Body() body) {
-    console.log(`/catalog`, 'ON FIND ONE DATA APP ROUTE');
-    const { id } = params;
-
-    const res = await this.catalogService.dataAppsOne(id, body);
-
-    return res;
-  }
-
-  @Get('dashboard-metabase')
-  async getAllDashboardMetabase(@Body() body) {
-    console.log(`/catalog`, 'ON GET ALL DASHBOARDS METABASE ROUTE');
-
-    const res = await this.catalogService.getAllDashboardMetabase(body);
-
-    return res;
-  }
-
-  @Get('dashboard-metabase/:id')
-  async getOneDashboardMetabase(@Body() body, @Param() params) {
-    const { id } = params;
-    console.log(`/catalog`, 'ON GET ONE DASHBOARD METABASE ROUTE');
-
-    const res = await this.catalogService.getOneDashboardMetabase(id, body);
-
-    return res;
-  }
-
-  @Get('table-metadata')
-  async getAllTableMetadata(@Body() body, @Query() query) {
-    console.log(`/catalog`, 'ON GET ALL TABLES METADATA ROUTE');
-
-    if (!query) {
-      const res = await this.catalogService.getAllTableMetadata(body);
-      return res;
-    } else {
-      const res = await this.catalogService.getOneTableMetadata(body, query);
-      return res;
+    if (!pipeline || !object) {
+      throw new BadRequestException('Query params not provided');
     }
+
+    const is_data_manager = permissions.includes(
+      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+    );
+    let has_permission = false;
+    const metadata = PackTheMetadata({
+      username,
+      user_id: undefined,
+      customer_id,
+      customer_name,
+    });
+
+    const user_roles = await this.catalogService.getUserRolesIds(user_id);
+
+    const { data_asset } =
+      await this.catalogService.getOneDataAssetByPipelineAndObject({
+        pipeline: query.pipeline,
+        object: query.object,
+        customer_id,
+        metadata,
+      });
+
+    if (data_asset?.owner === username) has_permission = true;
+
+    for (const role of user_roles) {
+      if (data_asset.p_roles.includes(role)) has_permission = true;
+    }
+
+    if (data_asset.p_users.includes(user_id)) has_permission = true;
+
+    if (is_data_manager || has_permission) {
+      delete data_asset.p_roles;
+      delete data_asset.p_users;
+      return { data_asset };
+    }
+
+    throw new ForbiddenException(
+      'You do not have permission to access this data asset.',
+    );
   }
 
-  @Delete('table-metadata/:id')
-  async deleteOneTableMetadata(@Param() params, @Body() body) {
-    const { id } = params;
-    console.log(`/catalog`, 'ON DELETE ONE TABLE METADATA ROUTE');
-
-    const res = await this.catalogService.deleteOneTableMetadata(id, body);
-
-    return res;
-  }
-
-  @Get('column-metadata')
-  async getOneColumnMetadata(@Body() body, @Query() params) {
-    console.log(`/catalog`, 'ON GET ONE COLUMN METADATA ROUTE');
-
-    const res = await this.catalogService.getOneColumnMetadata(body, params);
-
-    return res;
-  }
-
-  @Delete('column-metadata/:id')
-  async deleteOneColumnMetadata(@Param() params, @Body() body) {
-    console.log(`/catalog`, 'ON DELETE ONE COLUMN METADATA ROUTE');
-    const { id } = params;
-
-    const res = await this.catalogService.deleteOneColumnMetadata(id, body);
-
-    return res;
-  }
-
-  @Get('data-preview')
-  async getOneDataPreview(@Body() body, @Query() params) {
-    console.log(`/catalog`, 'ON GET ONE DATAPREVIEW ROUTE');
-
-    const res = await this.catalogService.getOneDataPreview(body, params);
-
-    return res;
-  }
-
-  @Get('data-status')
-  async getDataStatus(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA STATUS ROUTE');
-
-    const res = await this.catalogService.getDataStatus(body);
-
-    return res;
-  }
-
-  @Get('data-status')
-  async createDataStatus(@Body() body) {
-    console.log(`/catalog`, 'ON CREATE DATA STATUS ROUTE');
-
-    const res = await this.catalogService.createDataStatus(body);
-
-    return res;
-  }
-
-  @Get('data-description')
-  async getDataDescription(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA DESCRIPTION ROUTE');
-
-    const res = await this.catalogService.getDataDescription(body);
-
-    return res;
-  }
-
-  @Post('data-description')
-  async createDataDescription(@Body() body) {
-    console.log(`/catalog`, 'ON CREATE DATA DESCRIPTION ROUTE');
-
-    const res = await this.catalogService.createDataDescription(body);
-
-    return res;
-  }
-
-  @Get('data-docs')
-  async getDataDocs(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA DOCS ROUTE');
-
-    const res = await this.catalogService.getDataDocs(body);
-
-    return res;
-  }
-
-  @Post('data-docs')
-  async createDataDocs(@Body() body) {
-    console.log(`/catalog`, 'ON CREATE DATA DOCS ROUTE');
-
-    const res = await this.catalogService.createDataDocs(body);
-
-    return res;
-  }
-
-  @Get('data-rating')
-  async getDataRating(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA RATING ROUTE');
-
-    const res = await this.catalogService.getDataRating(body);
-
-    return res;
-  }
-
-  @Post('data-rating')
-  async createDataRating(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA RATING ROUTE');
-
-    const res = await this.catalogService.createDataRating(body);
-
-    return res;
-  }
-
-  @Get('summary-rating/:id')
-  async getSummaryRating() {
-    console.log(`/catalog`, 'ON GET SUMMARY RATING ROUTE');
-    //const { id } = params;
-
-    //
-
-    //const res = await this.catalogService.getSummaryRating(id, body);
-
-    return {
-      avg_rating: 0,
-      rating_count: 0,
-    };
-  }
-
-  @Get('data-comment')
-  async getDataComment(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA COMMENT ROUTE');
-
-    const res = await this.catalogService.getDataComment(body);
-
-    return res;
-  }
-
-  @Post('data-comment')
-  async createDataComment(@Body() body) {
-    console.log(`/catalog`, 'ON GET DATA COMMENT ROUTE');
-
-    const res = await this.catalogService.createDataComment(body);
-
-    return res;
-  }
-
-  @Get('data-review')
-  async getDataReview(@Body() body, @Query() params) {
-    console.log(`/catalog`, 'ON GET DATA REVIEW ROUTE');
-
-    const res = await this.catalogService.getDataReview(body, params);
-
-    return res;
-  }
-
-  @Post('tags')
-  async createTags(@Body() body) {
-    console.log(`/catalog`, 'ON CREATE TAG ROUTE');
-
-    const res = await this.catalogService.createTags(body);
-
-    return res;
-  }
-
+  @ApiInternalOnlyEndpoint()
   @Get('tags')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
   async findAllTags(@Body() body) {
-    console.log(`/catalog`, 'ON FIND ALL TAGS ROUTE');
+    this.logger.info(`/catalog - ON FIND ALL TAGS ROUTE`, {
+      user: body.info.user_id,
+      customer: body.info.customer,
+    });
 
-    const res = await this.catalogService.findAllTags(body);
+    const { user_id, customer, customer_id } = body.info;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name: customer,
+    });
+
+    const res = await this.catalogService.findAllTags(body, metadata);
 
     return res;
   }
 
-  @Delete('tags/:id')
-  async deleteTags(@Param() params, @Body() body) {
-    console.log(`/catalog`, 'ON DELETE TAG ROUTE');
-    const { id } = params;
+  @Get('data-asset/:id')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getDataAsset(
+    @User() user: RequestUser,
+    @Param('id') id: string,
+    @Query('shared') shared?: 'true',
+  ) {
+    const { username, user_id, customer_id, customer_name, permissions } = user;
 
-    const res = await this.catalogService.deleteTags(id, body);
+    this.logger.info(`GET /data-asset/${id}`, {
+      username,
+      customer_name,
+    });
+
+    const is_data_manager = permissions.includes(
+      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+    );
+    let has_permission = false;
+    const metadata = PackTheMetadata({
+      username,
+      user_id,
+      customer_id,
+      customer_name,
+    });
+
+    const user_roles = await this.catalogService.getUserRolesIds(user_id);
+
+    const { data_asset } = await this.catalogService.getOneDataAsset({
+      customer_id,
+      id,
+      metadata,
+    });
+    has_permission =
+      is_data_manager ||
+      data_asset?.owner === username ||
+      (user_roles as Array<any>).some((r) => data_asset.p_roles.includes(r)) ||
+      data_asset.p_users.includes(user_id);
+    if (
+      shared === 'true' &&
+      (data_asset.share_type === undefined || data_asset.share_type === 'none')
+    )
+      throw new NotFoundException();
+    if (!has_permission)
+      throw new ForbiddenException(
+        'You do not have permission to access this data asset.',
+      );
+    delete data_asset.p_roles;
+    delete data_asset.p_users;
+
+    return { data_asset };
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Get('data-asset/rls/:id')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getDataAssetRls(
+    @User() user: RequestUser,
+    @Headers() headers,
+    @Param('id') id: string,
+  ) {
+    const { username, user_id, customer_id, customer_name, permissions } = user;
+
+    this.logger.info(`/catalog - ON GET ONE DASHBOARD METABASE ROUTE`, {
+      username,
+      customer_name,
+    });
+
+    const is_data_manager = permissions.includes(
+      PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid,
+    );
+    let has_permission = false;
+    const metadata = PackTheMetadata({
+      username,
+      user_id,
+      customer_id,
+      customer_name,
+    });
+
+    const user_roles = await this.catalogService.getUserRolesIds(user_id);
+
+    const { data_asset } = await this.catalogService.getOneDataAsset({
+      customer_id,
+      id,
+      metadata,
+    });
+
+    if (data_asset?.owner === username) has_permission = true;
+
+    for (const role of user_roles) {
+      if (data_asset.p_roles.includes(role)) has_permission = true;
+    }
+
+    if (data_asset.p_users.includes(user_id)) has_permission = true;
+
+    if (is_data_manager || has_permission) {
+      delete data_asset.p_roles;
+      delete data_asset.p_users;
+      return { data_asset };
+    }
+
+    throw new ForbiddenException(
+      'You do not have permission to access this data asset.',
+    );
+  }
+
+  @Get('data-asset/:id/columns-metadata')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getDataAssetColumnsMetadata(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+  ): Promise<IColumnsMetadataResponse> {
+    const { customer_name, customer_id, user_id, username } = user;
+
+    this.logger.info(`/catalog - columns-metadata`, {
+      user_id,
+      customer_name,
+    });
+
+    const metadata = PackTheMetadata({
+      customer_name,
+      customer_id,
+      user_id,
+      username,
+      language,
+    });
+
+    const columns_metadata =
+      await this.catalogService.getDatasetColumnsMetadata(id, metadata);
+
+    return { columns_metadata };
+  }
+
+  @Get('data-asset/:id/preview')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getDataAssetPreview(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+  ): Promise<IPreviewResponse> {
+    const { customer_name, customer_id, user_id, username } = user;
+
+    this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });
+
+    const metadata = PackTheMetadata({
+      customer_name,
+      customer_id,
+      user_id,
+      username,
+      language,
+    });
+
+    const preview = await this.catalogService.getDatasetPreview(id, metadata);
+
+    return { preview };
+  }
+
+  @Get('data-asset/:id/docs')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.GET,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async getDataAssetDocs(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+  ): Promise<IDocsResponse> {
+    const { customer_name, customer_id, user_id, username } = user;
+
+    this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });
+
+    const metadata = PackTheMetadata({
+      customer_name,
+      customer_id,
+      user_id,
+      username,
+      language,
+    });
+
+    const docs = await this.catalogService.getDataDocs(id, metadata);
+
+    return { docs };
+  }
+
+  @Put('data-asset/:id')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async updateDataAsset(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') data_asset_id: string,
+    @Body() body: IUpdateDataRequest,
+  ): Promise<IOneDataAsset> {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+      language,
+    });
+
+    const result = await this.catalogService.updateOneDataAsset({
+      body,
+      data_asset_id,
+      customer_id,
+      metadata,
+    });
+
+    delete result.data_asset.p_roles;
+    delete result.data_asset.p_users;
+
+    return result;
+  }
+
+  @Post('data-asset/:id/docs')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async manageDataAssetDocs(
+    @User() user: RequestUser,
+    @Headers() headers,
+    @Param('id') table_id: string,
+    @Body('docs') docs: string,
+  ) {
+    const { user_id, customer_name } = user;
+
+    this.logger.info(`/catalog - ON GET DATA DOCS ROUTE`, {
+      user_id,
+      customer_name,
+    });
+
+    const res = await this.catalogService.createDataDocs({
+      table_id,
+      docs,
+      info: {
+        customer: customer_name,
+      },
+    });
 
     return res;
   }
 
-  @Post('table-tags')
-  async createTableTags(@Body() body) {
-    console.log(`/catalog`, 'ON CREATE TABLE TAG ROUTE');
+  @ApiInternalOnlyEndpoint()
+  @Put('data-asset/:id/manage-permissions')
+  async manageDataAssetPermissions(
+    @Param('id') id: string,
+    @User() user: RequestUser,
+    @Body() body,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.managePermissions(
+      { ...body, id },
+      metadata,
+    );
 
-    const res = await this.catalogService.createTableTags(body);
-
-    return res;
+    return { data_asset: JSON.parse(response.data_asset) };
   }
 
-  @Get('table-tags')
-  async getAllTableTags(@Body() body) {
-    console.log(`/catalog`, 'ON GET ALL TABLE TAGS ROUTE');
+  @ApiInternalOnlyEndpoint()
+  @Put('data-asset/:id/revoke-permissions')
+  async revokeDataAssetPermissions(
+    @Param('id') id: string,
+    @User() user: RequestUser,
+    @Body() body,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.revokePermissions(
+      { ...body, id },
+      metadata,
+    );
 
-    const res = await this.catalogService.findAllTableTags(body);
-
-    return res;
+    return { message: response.message };
   }
 
-  @Delete('table-tags/:id')
-  async deleteTableTags(@Param() params, @Body() body) {
-    console.log(`/catalog`, 'ON CREATE TABLE TAGS ROUTE');
-    const { id } = params;
+  @Post()
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.CREATE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async createDataAsset(
+    @User() user: RequestUser,
+    @Body() body: ICreateDataAsset,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const { data_asset } = await this.catalogService.createDataAsset(
+      body,
+      metadata,
+    );
 
-    const res = await this.catalogService.deleteTableTags(id, body);
-
-    return res;
+    return { data_asset: JSON.parse(data_asset) };
   }
 
-  @Get('table-rules')
-  async getTableRules(@Body() body) {
-    console.log(`/catalog`, 'ON GET TABLE RULES ROUTE');
+  @Post('data-asset/:id/comment')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async commentOnDataAsset(
+    @Param('id') id: string,
+    @User() user: RequestUser,
+    @Body() body: IMakeAComment,
+  ) {
+    const { message } = body;
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.commentOnDataAsset(
+      { data_asset_id: id, username, message },
+      metadata,
+    );
 
-    const res = await this.catalogService.getTableRules(body);
-
-    return res;
+    return response;
   }
 
-  @Delete('table-rules/:id')
-  async deleteTableRules(@Param() params, @Body() body) {
-    console.log(`/catalog`, 'ON DELETE TABLE RULES ROUTE');
-    const { id } = params;
+  @Delete('data-asset/:id')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.DELETE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async deleteDataAsset(@Param('id') id: string, @User() user: RequestUser) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.deleteDataAsset(
+      { id, type: undefined },
+      metadata,
+    );
 
-    const res = await this.catalogService.deleteTableRules(id, body);
+    return response;
+  }
 
-    return res;
+  @Delete('data-asset/:id/comment')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CATALOG.permissions.UPDATE,
+    PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER,
+  )
+  async deleteComment(
+    @Param('id') id: string,
+    @User() user: RequestUser,
+    @Body() body: IDeleteComment,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.deleteComment(
+      {
+        data_asset_id: id,
+        comment: { ...body.comment, created_at: undefined, message: undefined },
+      },
+      metadata,
+    );
+
+    return response;
+  }
+
+  @Post('dataset-catalog-task')
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.CATALOG.permissions.TRIGGER_CATALOG_TASK,
+  )
+  @ApiCreatedResponse({ type: TriggerCatalogRes })
+  async triggerCatalog(
+    @User() user: RequestUser,
+    @Body() body: TriggerCatalogReq,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const session = await this.catalogService.triggerCatalog(body, metadata);
+
+    return { session };
+  }
+
+  @Get('dataset-catalog-task/:session')
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.CATALOG.permissions.TRIGGER_CATALOG_TASK,
+  )
+  @ApiOkResponse({ type: GetDatasetCatalogTaskRes })
+  async getCatalogTask(
+    @User() user: RequestUser,
+    @Param('session') session: string,
+  ) {
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+    const response = await this.catalogService.getDatasetCatalogTask(
+      session,
+      metadata,
+    );
+
+    return response;
   }
 }

src/modules/catalog/catalog.module.ts

@@ -0,0 +1,26 @@
+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';
+
+const client = new CatalogClientConfiguration();
+
+@Module({
+  imports: [
+    ClientsModule.register([client.providerOptions]),
+    OldPipelineModule,
+    UsersModule,
+    RolesModule,
+  ],
+  controllers: [CatalogController],
+  providers: [CatalogService, DadosferaLogger],
+  exports: [CatalogService],
+})
+export class CatalogModule {}

src/modules/catalog/catalog.service.ts

@@ -1,6 +1,51 @@
+import DadosferaLogger from '@dadosfera/dadosfera-logs/dist';
+import {
+  WriteService,
+  ReadService,
+  ProtoServices,
+  Messages,
+} from '@dadosfera/protospack-v2/dist/lib/Catalog';
+import {
+  HttpException,
+  HttpStatus,
+  Inject,
+  OnModuleInit,
+} from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
 import axios from 'axios';
+import { lastValueFrom } from 'rxjs';
+import { CatalogClientConfiguration } from './catalog-client';
+import { UsersService } from '../users/users.service';
+import { RolesService } from '../roles/roles.service';
+import { Metadata } from '@grpc/grpc-js';
+import { IUpdateDataRequest, TriggerCatalogReq } from './dtos';
+
+class CatalogService implements OnModuleInit {
+  catalogReadService: ReadService.CatalogReadServices;
+  catalogWriteService: WriteService.CatalogWriteServices;
+  logger: any;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    @Inject(CatalogClientConfiguration.name)
+    private readonly grpcClient: ClientGrpc,
+    private readonly userService: UsersService,
+    private readonly roleService: RolesService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.catalogReadService =
+      this.grpcClient.getService<ReadService.CatalogReadServices>(
+        ProtoServices.CatalogReadServices,
+      );
+    this.catalogWriteService =
+      this.grpcClient.getService<WriteService.CatalogWriteServices>(
+        ProtoServices.CatalogWriteServices,
+      );
+  }
 
-class CatalogService {
   _getNimbusUrl(body) {
     const customer = body.info.customer.toLowerCase();
 
@@ -8,139 +53,228 @@ class CatalogService {
       return `https://nimbus-${customer}.dadosfera.ai`;
     }
 
-    return `https://nimbus-${customer}.${process.env.ENV}.dadosfera.ai`;
+    return `https://nimbus-${customer}.${process.env.ENV.replace(
+      'local',
+      'stg',
+    )}.dadosfera.ai`;
   }
 
-  async catalogAll(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/all/`);
+  async createDataAsset(data: Messages.CreateDataAssetRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
+    if (!data.embed) data.embed = undefined;
 
-    return data;
-  }
-
-  async dataAppsAll(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data_apps/`);
-    return data;
-  }
-
-  async dataAppsOne(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/data_apps/${id}/`,
+    return lastValueFrom(
+      this.catalogWriteService.CreateDataAsset(data, metadata),
     );
-
-    return data;
   }
 
-  async getAllDashboardMetabase(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/dashboard-metabase/`,
-    );
-    return data;
-  }
+  async managePermissions(data: Messages.ManagePermissionRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
 
-  async getOneDashboardMetabase(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/dashboard-metabase/${id}`,
-    );
-    console.log(data);
-
-    // const [, path] = data.iframe_url.split('.dadosfera');
-    // const host = `httpss://metabase-${body.info.customer.toLowerCase()}.dadosfera.ai`;
-    // data.iframe_url = host + path;
-
-    return data;
-  }
-
-  async getAllTableMetadata(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/table-metadata/`,
-    );
-    return data;
-  }
-
-  async getOneTableMetadata(body, params) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/table-metadata/`,
-      { params: params },
-    );
-    return data;
-  }
-
-  async deleteOneTableMetadata(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.delete(
-      `${nimbusUrl}/api/catalog/table-metadata/${id}`,
-    );
-    return data;
-  }
-
-  async getOneColumnMetadata(body, params) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/column-metadata/`,
-      { params: params },
-    );
-    return data;
-  }
-
-  async deleteOneColumnMetadata(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.delete(
-      `${nimbusUrl}/api/catalog/column-metadata/${id}/`,
-    );
-    return data;
-  }
-
-  async getOneDataPreview(body, params) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-preview/`, {
-      params: params,
+    return lastValueFrom(
+      this.catalogWriteService.ManagePermission(data, metadata),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 404,
+      );
     });
-    return data;
   }
 
-  async getDataStatus(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-status/`);
-    return data;
+  async revokePermissions(data: Messages.RevokePermissionRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
+
+    return lastValueFrom(
+      this.catalogWriteService.RevokePermission(data, metadata),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 404,
+      );
+    });
   }
 
-  async createDataStatus(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(
-      `${nimbusUrl}/api/catalog/data-status/`,
-      body,
+  async commentOnDataAsset(data: Messages.MakeACommentRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
+
+    return lastValueFrom(
+      this.catalogWriteService.MakeAComment(data, metadata),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 404,
+      );
+    });
+  }
+
+  async deleteComment(data: Messages.UpdateACommentRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
+
+    return lastValueFrom(
+      this.catalogWriteService.UpdateAComment(data, metadata),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 404,
+      );
+    });
+  }
+
+  async deleteDataAsset(data: Messages.DeleteDataAssetRequest, metadata) {
+    this.logger.info('CatalogService - Manage Data assets permissions');
+
+    return lastValueFrom(
+      this.catalogWriteService.DeleteDataAsset(data, metadata),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 404,
+      );
+    });
+  }
+
+  async getUserRolesIds(userId: string) {
+    const result = await this.userService.findOneById(userId).catch(() => null);
+
+    const roles_ids = result.user.roles.map((role) => role.id);
+
+    return roles_ids;
+  }
+
+  async searchDataAssets(
+    query: Record<string, any>,
+    metadata: Metadata,
+    customer_id: string,
+  ) {
+    this.logger.info('CatalogService - searchDataAssets');
+
+    const { search, page, size, sort_by, order, ...filters } = query;
+
+    const { data_assets, total } = await lastValueFrom(
+      this.catalogReadService.GetAllDataAssets(
+        {
+          search,
+          page,
+          size,
+          sort_by,
+          order,
+          filters: JSON.stringify(filters),
+        },
+        metadata,
+      ),
     );
-    return data;
-  }
 
-  async getDataDescription(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/data-description/`,
+    const result = JSON.parse(data_assets);
+
+    const response = await this.getAssetsUsersAndRoles(
+      result.data_assets,
+      customer_id,
     );
-    return data;
+
+    return { data_assets: response, total };
   }
 
-  async createDataDescription(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(
-      `${nimbusUrl}/api/catalog/data-description/`,
-      body,
+  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,
+      ),
     );
-    return data;
+    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(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-docs/`);
-    return data;
+  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 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);
+
+    return { data_asset: asset[0] };
+  }
+
+  async getDataDocs(id: string, metadata: Metadata) {
+    const { documentation } = await lastValueFrom(
+      this.catalogReadService.GetDatasetDoc({ id, type: undefined }, metadata),
+    );
+    console.log(documentation);
+    const docs = JSON.parse(documentation);
+    return docs;
+  }
+
+  async getDatasetPreview(id: string, metadata: Metadata) {
+    const { preview } = await lastValueFrom(
+      this.catalogReadService.GetDatasetPreview(
+        { id, type: undefined },
+        metadata,
+      ),
+    );
+    const result = JSON.parse(preview);
+    return result;
+  }
+
+  async getDatasetColumnsMetadata(id: string, metadata: Metadata) {
+    const { columns_metadata } = await lastValueFrom(
+      this.catalogReadService.GetDatasetColumnsMetadata(
+        { id, type: undefined },
+        metadata,
+      ),
+    );
+    const result = JSON.parse(columns_metadata);
+    return result;
   }
 
   async createDataDocs(body) {
@@ -152,111 +286,64 @@ class CatalogService {
     return data;
   }
 
-  async getDataRating(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-rating/`);
-    return data;
-  }
+  async findAllTags(data, metadata) {
+    this.logger.info('CatalogService - findAllCustomerTags');
 
-  async createDataRating(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(
-      `${nimbusUrl}/api/catalog/data-rating/`,
-      body,
+    const response = await lastValueFrom(
+      this.catalogReadService.GetCustomerTags(data, metadata),
+    )
+      .then((res) => {
+        this.logger.info('Done');
+        return res;
+      })
+      .catch((err) => {
+        this.logger.error(err.message);
+        throw new Error(err);
+      });
+
+    return response;
+  }
+  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;
-  }
+    return data_assets.map((data_asset) => {
+      const owner = customer_users.find(
+        (u) => u.id === data_asset.owner,
+      )?.username;
 
-  async getSummaryRating(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/summary-rating/${id}`,
-    );
-    return data;
-  }
-
-  async getDataComment(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-comment/`);
-    return data;
-  }
-
-  async createDataComment(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(
-      `${nimbusUrl}/api/catalog/data-comment/`,
-      body,
-    );
-    return data;
-  }
-
-  async getDataReview(body, params) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-review/`, {
-      params: params,
+      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, username: user.username });
+      }
+      return {
+        ...data_asset,
+        roles,
+        users,
+        owner,
+      } as typeof data_asset;
     });
-    return data;
   }
-
-  async createTags(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(`${nimbusUrl}/api/catalog/tags/`, body);
-    return data;
-  }
-
-  async findAllTags(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(`${nimbusUrl}/api/catalog/tags/`, body);
-    return data;
-  }
-
-  async findAllTableTags(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/table-tags/`,
-      body,
+  async triggerCatalog(data: TriggerCatalogReq, metadata: Metadata) {
+    const { session } = await lastValueFrom(
+      this.catalogWriteService.TriggerDatasetCataloging(data, metadata),
     );
-    return data;
+    return session;
   }
-
-  async deleteTags(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.delete(`${nimbusUrl}/api/catalog/tags/${id}`);
-    return data;
-  }
-
-  async createTableTags(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.post(
-      `${nimbusUrl}/api/catalog/table-tags/`,
-      body,
+  async getDatasetCatalogTask(session: string, metadata: Metadata) {
+    const res = await lastValueFrom(
+      this.catalogReadService.GetDatasetCatalogTask({ session }, metadata),
     );
-    return data;
-  }
-
-  async deleteTableTags(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.delete(
-      `${nimbusUrl}/api/catalog/table-tags/${id}`,
-    );
-    return data;
-  }
-
-  async getTableRules(body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.get(
-      `${nimbusUrl}/api/catalog/table-rules/`,
-      body,
-    );
-    return data;
-  }
-
-  async deleteTableRules(id, body) {
-    const nimbusUrl = this._getNimbusUrl(body);
-    const { data } = await axios.delete(
-      `${nimbusUrl}/api/catalog/table-rules/${id}`,
-    );
-    return data;
+    return res;
   }
 }
 

src/modules/catalog/dtos/index.ts

@@ -0,0 +1,314 @@
+import { ApiProperty, ApiPropertyOptional, PickType } from '@nestjs/swagger';
+import { CreateDataAssetRequest } from '@dadosfera/protospack-v2/dist/lib/Catalog/interfaces/messages';
+
+export enum DataAssetShareType {
+  none = 'none',
+  public = 'public',
+  private = 'private',
+}
+export enum OrderEnum {
+  asc = 'asc',
+  desc = 'desc',
+}
+export class EmbedObject {
+  @ApiProperty()
+  url: string;
+}
+export class IRole {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  id: string;
+}
+
+export class IUser {
+  @ApiProperty()
+  username: string;
+  @ApiProperty()
+  id: string;
+}
+
+export class IComment {
+  @ApiProperty()
+  id: number;
+  @ApiProperty()
+  message: string;
+  @ApiProperty()
+  created_at: string;
+  @ApiProperty()
+  username: string;
+}
+
+export class IDataAsset {
+  @ApiProperty()
+  id: number;
+  @ApiPropertyOptional()
+  database_name?: string;
+  @ApiPropertyOptional()
+  table_name?: string;
+  @ApiPropertyOptional()
+  num_columns?: number;
+  @ApiPropertyOptional()
+  location?: string;
+  @ApiPropertyOptional()
+  created_time?: string;
+  @ApiPropertyOptional()
+  table_type?: string;
+  @ApiPropertyOptional()
+  size_in_bytes?: number;
+  @ApiPropertyOptional()
+  num_files?: number;
+  @ApiPropertyOptional()
+  data_encrypted?: string;
+  @ApiPropertyOptional()
+  num_rows?: number;
+  @ApiProperty()
+  display_name: string;
+  @ApiProperty()
+  pipeline_id: string;
+  @ApiProperty()
+  user_id: string;
+  @ApiProperty()
+  description: string;
+  @ApiProperty()
+  data_asset_type: string;
+  @ApiProperty()
+  tags: string[];
+  @ApiProperty()
+  owner: string;
+  @ApiProperty({ type: [IRole] })
+  roles: IRole[];
+  @ApiProperty({ type: [IUser] })
+  users: IUser[];
+  @ApiPropertyOptional()
+  dashboard_id?: number;
+  @ApiPropertyOptional()
+  name?: string;
+  @ApiPropertyOptional()
+  parameters?: string[];
+  @ApiPropertyOptional()
+  embedding_params?: object;
+  @ApiProperty()
+  created_at: string;
+  @ApiPropertyOptional()
+  updated_at?: string;
+  @ApiProperty({ type: [IComment] })
+  comments: IComment[];
+  @ApiPropertyOptional()
+  embed?: EmbedObject;
+  @ApiPropertyOptional({ enum: DataAssetShareType })
+  share_type?: DataAssetShareType;
+}
+
+export class IOneDataAsset {
+  @ApiProperty()
+  data_asset: IDataAsset;
+}
+
+export class IMakeAComment {
+  @ApiProperty()
+  message: string;
+}
+
+export class CommentToDelete extends PickType(IComment, ['id', 'username']) {}
+export class IDeleteComment {
+  @ApiProperty()
+  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;
+}
+
+export class ICatalogAllResponse {
+  @ApiProperty({ type: [IDataAsset] })
+  data_assets: IDataAsset[];
+  @ApiProperty()
+  total: number;
+}
+
+export class IData {
+  @ApiProperty()
+  var: number;
+  @ApiProperty()
+  date: string;
+  @ApiProperty()
+  last: number;
+  @ApiProperty()
+  maximum: number;
+  @ApiProperty()
+  minimum: number;
+  @ApiProperty()
+  day_opening: number;
+}
+
+export class IUpdateDataRequest {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  description: string;
+  @ApiProperty()
+  tags: string[];
+  @ApiPropertyOptional()
+  embed: EmbedObject;
+  @ApiPropertyOptional({ enum: DataAssetShareType })
+  share_type?: DataAssetShareType;
+}
+export class ICreateDataAsset implements CreateDataAssetRequest {
+  @ApiProperty()
+  display_name: string;
+  @ApiProperty()
+  description: string;
+  @ApiProperty()
+  data_asset_type: string;
+  @ApiProperty()
+  external_url: string;
+  @ApiProperty()
+  location: string;
+  @ApiPropertyOptional()
+  embed: EmbedObject;
+}
+
+export class IPreview {
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  database_name: string;
+  @ApiProperty()
+  table_name: string;
+  @ApiProperty({ type: [IData] })
+  data: IData[];
+}
+
+export class IDocs {
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  docs: string;
+  @ApiProperty()
+  updated_at: string;
+  @ApiProperty()
+  table_id: string;
+}
+
+export class IColumnMetadata {
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  table_name: string;
+  @ApiProperty()
+  column_name: string;
+  @ApiProperty()
+  data_type: string;
+  @ApiProperty()
+  missing_count: string;
+  @ApiProperty()
+  min: string;
+  @ApiProperty()
+  max: string;
+  @ApiProperty()
+  count: string;
+  @ApiProperty()
+  histogram: string;
+  @ApiProperty()
+  mean: string;
+  @ApiProperty()
+  median: string;
+  @ApiProperty()
+  missing_rate: string;
+  @ApiProperty()
+  stddev: string;
+  @ApiProperty()
+  unique_count: string;
+  @ApiProperty()
+  unique_rate: string;
+  @ApiProperty()
+  analyzer_rules: string[];
+  @ApiProperty()
+  version: string;
+}
+
+export class IPreviewResponse {
+  @ApiProperty()
+  preview: IPreview;
+}
+
+export class IDocsResponse {
+  @ApiProperty()
+  docs: IDocs;
+}
+
+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;
+}

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

@@ -0,0 +1,31 @@
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientProviderOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import { ConnectionTest } from '@dadosfera/protospack-v2';
+
+const isLocalConnection = !!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: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [ConnectionTest.ProtoPaths.ReadFilePath],
+      loader: {
+        keepCase: true,
+        enums: String,
+        objects: true,
+        arrays: true,
+      },
+    },
+  };
+  providerOptions: ClientProviderOptions = {
+    name: 'ConnectionTestGrpcClient',
+    ...this.config,
+  };
+}

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

@@ -0,0 +1,124 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  UseFilters,
+  ValidationPipe,
+} from '@nestjs/common';
+import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
+import { User, RequestUser } from 'src/decorators/user.decorator';
+import { ConnectionTestService } from './connection-test.service';
+import {
+  ConnectionTestPingRes,
+  ConnectionTestPingReq,
+  ConnectionTestCredentialsReq,
+  ConnectionTestCredentialsRes,
+  ConnectionTestListSchemasReq,
+  ConnectionTestListSchemasRes,
+  ConnectionTestListTablesReq,
+  ConnectionTestListTablesRes,
+  GetTableMetadataRes,
+  GetTableMetadataReq,
+} from './dto/connection-test';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { Authenticated } from 'src/decorators/authentication.decorator';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
+
+@ApiInternalOnlyController()
+@ApiTags('Connection Test')
+@Controller('connection-test')
+@UseFilters(new GrpcToHttpExceptionFilter())
+@Authenticated()
+export class ConnectionTestController {
+  logger: any;
+  constructor(
+    private connectionTestService: ConnectionTestService,
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Post('ping')
+  @ApiOkResponse({ type: ConnectionTestPingRes })
+  @HttpCode(HttpStatus.OK)
+  async connectionTestPing(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: ConnectionTestPingReq,
+  ) {
+    this.logger.info('/connection-test/ping', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.connectionTestPing(body, user);
+  }
+
+  @Post('credentials')
+  @ApiOkResponse({ type: ConnectionTestCredentialsRes })
+  @HttpCode(HttpStatus.OK)
+  async connectionTestCredentials(
+    @User() user: RequestUser,
+    @Body() body: ConnectionTestCredentialsReq,
+  ) {
+    this.logger.info('/connection-test/credentials', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.connectionTestCredentials(body, user);
+  }
+
+  @Post('schemas')
+  @ApiOkResponse({ type: ConnectionTestListSchemasRes })
+  @HttpCode(HttpStatus.OK)
+  async connectionTestListSchemas(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: ConnectionTestListSchemasReq,
+  ) {
+    this.logger.info('/connection-test/schemas', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.connectionTestListSchemas(
+      body,
+      user.customer_name,
+    );
+  }
+
+  @Post('tables')
+  @ApiOkResponse({ type: ConnectionTestListTablesRes })
+  @HttpCode(HttpStatus.OK)
+  async connectionTestListTables(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: ConnectionTestListTablesReq,
+  ) {
+    this.logger.info('/connection-test/tables', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.connectionTestListTables(
+      body,
+      user.customer_name,
+    );
+  }
+
+  @Post('table-metadata')
+  @ApiOkResponse({ type: GetTableMetadataRes })
+  @HttpCode(HttpStatus.OK)
+  async getTableMetadata(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: GetTableMetadataReq,
+  ) {
+    this.logger.info('/connection-test/table-metadata', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.connectionTestService.getTableMetadata(
+      body,
+      user.customer_name,
+    );
+  }
+}

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

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { ConnectionTestController } from './connection-test.controller';
+import { ConnectionTestService } from './connection-test.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ClientsModule } from '@nestjs/microservices';
+import { ConnectionTestClientConfiguration } from './connection-test-client.config';
+import { ConnectionModule } from '../connection/connection.module';
+const client = new ConnectionTestClientConfiguration();
+@Module({
+  controllers: [ConnectionTestController],
+  providers: [ConnectionTestService, DadosferaLogger],
+  imports: [ClientsModule.register([client.providerOptions]), ConnectionModule],
+})
+export class ConnectionTestModule {}

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

@@ -0,0 +1,191 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ConnectionTest } from '@dadosfera/protospack-v2';
+import { lastValueFrom } from 'rxjs';
+import {
+  ConnectionTestCredentialsReq,
+  ConnectionTestCredentialsRes,
+  ConnectionTestListSchemasReq,
+  ConnectionTestListSchemasRes,
+  ConnectionTestListTablesReq,
+  ConnectionTestListTablesRes,
+  ConnectionTestPingReq,
+  ConnectionTestPingRes,
+  GetTableMetadataReq,
+  GetTableMetadataRes,
+} from './dto/connection-test';
+import { ConnectionClientService } from '../connection/client.service';
+import {
+  CreateConnectionDto,
+  DatabaseConnectionPropertiesDto,
+} from '../connection/dtos/connection';
+import { RequestUser } from 'src/decorators/user.decorator';
+import { PackTheMetadata } from 'src/utils/ PackTheMetadata';
+
+@Injectable()
+export class ConnectionTestService {
+  private connectionTestReadClient: ConnectionTest.ReadService.ConnectionTestReadServices;
+  constructor(
+    @Inject('ConnectionTestGrpcClient') private readonly grpcClient: ClientGrpc,
+    private connectionsService: ConnectionClientService,
+  ) {
+    this.connectionTestReadClient =
+      grpcClient.getService<ConnectionTest.ReadService.ConnectionTestReadServices>(
+        ConnectionTest.ProtoServices.ConnectionTestReadServices,
+      );
+  }
+
+  async connectionTestPing(
+    body: ConnectionTestPingReq,
+    user: RequestUser,
+  ): Promise<ConnectionTestPingRes> {
+    const {
+      host: endpoint,
+      plugin,
+      port,
+      network_config_id,
+      connection_id,
+    } = body;
+    const { user_id, customer_id, customer_name } = user;
+    const metadata = PackTheMetadata({
+      customer_name,
+      customer_id,
+      user_id,
+    });
+
+    if (connection_id) {
+      const con = await this.connectionsService.getConnectionDetails({
+        body,
+        metadata,
+      });
+      const conPayload = JSON.parse(con.connection.properties);
+      const { plugin, network_config_id } = con.connection;
+      const { host, port, endpoint } = conPayload;
+
+      return lastValueFrom(
+        this.connectionTestReadClient.ConnectionTestPing({
+          customer_name,
+          endpoint: endpoint || host,
+          network_config_id,
+          plugin,
+          port: port ? port.toString() : undefined,
+          connection_id,
+        }),
+      );
+    } else {
+      return lastValueFrom(
+        this.connectionTestReadClient.ConnectionTestPing({
+          customer_name,
+          endpoint,
+          network_config_id,
+          plugin,
+          port: port ? port.toString() : undefined,
+          connection_id,
+        }),
+      );
+    }
+  }
+  async connectionTestCredentials(
+    body: ConnectionTestCredentialsReq,
+    user: RequestUser,
+  ): Promise<ConnectionTestCredentialsRes> {
+    const { plugin, ...connectionBody } = body;
+    let { connection_id } = body;
+    const { customer_id, customer_name, user_id, username } = user;
+    const metadata = PackTheMetadata({
+      customer_id,
+      customer_name,
+      user_id,
+      username,
+    });
+
+    if (body.network_config_id == '') {
+      body.network_config_id = undefined;
+    }
+
+    /********* CREATE CONNECTION *********/
+    if (!connection_id) {
+      const properties: DatabaseConnectionPropertiesDto = {
+        ...connectionBody.properties,
+        plugin,
+        credentials_type: 'basic_auth',
+      };
+      const createConnectionBody: CreateConnectionDto = {
+        ...body,
+        properties,
+      };
+      const { connection } = await this.connectionsService.createConnection(
+        createConnectionBody,
+        metadata,
+      );
+      connection_id = connection.id;
+    }
+    /************************************/
+    const { operation_result } = await lastValueFrom(
+      this.connectionTestReadClient.ConnectionTestCredentials({
+        connection_id,
+        customer_name,
+        plugin,
+      }),
+    ).catch(async (e) => {
+      if (!body.connection_id) {
+        await this.connectionsService.deleteConnection({
+          body: { id: connection_id },
+          metadata,
+        });
+      }
+      throw e;
+    });
+    if (!operation_result && !body.connection_id) {
+      await this.connectionsService.deleteConnection({
+        body: { id: connection_id },
+        metadata,
+      });
+      connection_id = null;
+    }
+    return { operation_result, connection_id };
+  }
+  async connectionTestListSchemas(
+    body: ConnectionTestListSchemasReq,
+    customer_name: string,
+  ): Promise<ConnectionTestListSchemasRes> {
+    const { connection_id, plugin } = body;
+    return lastValueFrom(
+      this.connectionTestReadClient.ListSchemas({
+        connection_id,
+        customer_name,
+        plugin,
+      }),
+    );
+  }
+  async connectionTestListTables(
+    body: ConnectionTestListTablesReq,
+    customer_name: string,
+  ): Promise<ConnectionTestListTablesRes> {
+    const { connection_id, plugin, schema } = body;
+    return lastValueFrom(
+      this.connectionTestReadClient.ListTables({
+        connection_id,
+        customer_name,
+        plugin,
+        schema,
+      }),
+    );
+  }
+
+  async getTableMetadata(
+    body: GetTableMetadataReq,
+    customer_name: string,
+  ): Promise<GetTableMetadataRes> {
+    const { schema, plugin, table_list, connection_id } = body;
+    return lastValueFrom(
+      this.connectionTestReadClient.GetTableMetadata({
+        connection_id,
+        customer_name,
+        plugin,
+        schema,
+        table_list,
+      }),
+    );
+  }
+}

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

@@ -0,0 +1,133 @@
+import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
+import { IsString, IsOptional } from 'class-validator';
+import { DatabaseConnectionPropertiesDto } from 'src/modules/connection/dtos/connection';
+import { CreateConnectionDto } from 'src/modules/connection/dtos/connection';
+export class ColumnDto {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  type: string;
+}
+export class TableMetadataDto {
+  @ApiProperty()
+  table_name: string;
+  @ApiProperty({ type: [ColumnDto] })
+  columns: ColumnDto[];
+  @ApiProperty({ type: [ColumnDto] })
+  references: ColumnDto[];
+}
+
+export class ConnectionTestPingReq {
+  @ApiPropertyOptional()
+  @IsString()
+  @IsOptional()
+  plugin: string;
+
+  @ApiPropertyOptional()
+  @IsString()
+  @IsOptional()
+  host: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  port: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  network_config_id?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  connection_id: string;
+}
+
+export class ConnectionTestPingRes {
+  @ApiProperty()
+  operation_result: boolean;
+}
+
+export class ConnectionTestCredentialsProperties extends OmitType(
+  DatabaseConnectionPropertiesDto,
+  ['plugin', 'credentials_type'],
+) {}
+export class ConnectionTestCredentialsReq extends OmitType(
+  CreateConnectionDto,
+  ['properties'],
+) {
+  @ApiProperty()
+  properties: ConnectionTestCredentialsProperties;
+  @ApiPropertyOptional()
+  connection_id?: string;
+}
+
+export class ConnectionTestCredentialsRes {
+  @ApiProperty()
+  operation_result: boolean;
+  @ApiProperty()
+  connection_id: string;
+}
+
+export class ConnectionTestListSchemasReq {
+  @ApiProperty()
+  @IsString()
+  plugin: string;
+
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+}
+
+export class ConnectionTestListSchemasRes {
+  @ApiProperty()
+  operation_result: boolean;
+  @ApiProperty()
+  schema_list: string[];
+}
+
+export class ConnectionTestListTablesReq {
+  @ApiProperty()
+  @IsString()
+  plugin: string;
+
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+
+  @ApiProperty()
+  @IsString()
+  schema: string;
+}
+
+export class ConnectionTestListTablesRes {
+  @ApiProperty()
+  operation_result: boolean;
+  @ApiProperty()
+  table_list: string[];
+}
+
+export class GetTableMetadataReq {
+  @ApiProperty()
+  @IsString()
+  connection_id: string;
+
+  @ApiProperty()
+  @IsString()
+  plugin: string;
+
+  @ApiProperty()
+  @IsString()
+  schema: string;
+
+  @ApiProperty()
+  @IsString({ each: true })
+  table_list: string[];
+}
+
+export class GetTableMetadataRes {
+  @ApiProperty()
+  operation_result: boolean;
+  @ApiProperty({ type: [TableMetadataDto] })
+  tables_metadata: TableMetadataDto[];
+}

src/modules/connection/client.config.ts

@@ -0,0 +1,39 @@
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientsProviderAsyncOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import { ConnectionManager } from '@dadosfera/protospack-v2';
+
+const isLocalConnection = !!process.env.INFACTORY_URL?.includes('0.0.0.0');
+
+export class ConnectionClientConfiguration {
+  public name = 'ConnectionClientConfiguration';
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.INFACTORY_URL,
+      package: [
+        ConnectionManager.ProtoPackages.WritePackage,
+        ConnectionManager.ProtoPackages.ReadPackage,
+      ],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [
+        ConnectionManager.ProtoPaths.WriteFilePath,
+        ConnectionManager.ProtoPaths.ReadFilePath,
+      ],
+      loader: {
+        keepCase: true,
+        enums: String,
+        objects: true,
+        arrays: true,
+      },
+    },
+  };
+
+  providerOptions: ClientsProviderAsyncOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/connection/client.service.ts

@@ -0,0 +1,340 @@
+import { OnModuleInit, Inject } from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ConnectionManager } from '@dadosfera/protospack-v2';
+import { lastValueFrom } from 'rxjs';
+import {
+  ConnectionApiConnection,
+  ConnectionRes,
+  ConnectionsRes,
+  ConnectionToCatalogDto,
+  CreateConnectionDto,
+  UpdateConnectionDto,
+} from './dtos/connection';
+import { ConnectionClientConfiguration } from './client.config';
+import {
+  GetConnectionDetailsResponse,
+  INTERNAL_GetAllConnectionsResponse,
+} from '@dadosfera/protospack-v2/dist/lib/ConnectionManager/interfaces/messages';
+import { UsersService } from '../users/users.service';
+import { ConnectorClientService } from '../connector/client.service';
+import {
+  ConnectionsApiNetworkConfig,
+  NetworkConfigDto,
+} from '../network-config/dto/network-config';
+import DadosferaLogger from '@dadosfera/dadosfera-logs/dist';
+
+export class ConnectionClientService implements OnModuleInit {
+  private connectionServiceRead: ConnectionManager.ReadService.ConnectionManagerReadServices;
+  private connectionServiceWrite: ConnectionManager.WriteService.ConnectionManagerWriteServices;
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(ConnectionClientConfiguration.name)
+    private readonly grpcClient: ClientGrpc,
+    private usersService: UsersService,
+    private connectorService: ConnectorClientService,
+    private dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  onModuleInit() {
+    this.connectionServiceWrite =
+      this.grpcClient.getService<ConnectionManager.WriteService.ConnectionManagerWriteServices>(
+        ConnectionManager.ProtoServices.ConnectionManagerWriteServices,
+      );
+
+    this.connectionServiceRead =
+      this.grpcClient.getService<ConnectionManager.ReadService.ConnectionManagerReadServices>(
+        ConnectionManager.ProtoServices.ConnectionManagerReadServices,
+      );
+  }
+
+  async createConnection(
+    body: CreateConnectionDto,
+    metadata,
+  ): Promise<ConnectionRes> {
+    const {
+      connector_id,
+      description,
+      image_url,
+      name,
+      network_config_id,
+      properties,
+      type,
+      connector_name,
+      plugin,
+    } = body;
+
+    return lastValueFrom(
+      this.connectionServiceWrite.CreateConnection(
+        {
+          connector_id,
+          connector_name,
+          description,
+          image_url,
+          name,
+          network_config_id,
+          properties: JSON.stringify(properties),
+          type,
+          plugin,
+        },
+        metadata,
+      ),
+    );
+  }
+
+  async updateConnection(
+    id: string,
+    body: UpdateConnectionDto,
+    metadata,
+  ): Promise<ConnectionRes> {
+    const { description, name, network_config_id, properties } = body;
+
+    return lastValueFrom(
+      this.connectionServiceWrite.UpdateConnection(
+        {
+          id,
+          description,
+          name,
+          network_config_id,
+          properties: JSON.stringify(properties),
+        },
+        metadata,
+      ),
+    );
+  }
+
+  async deleteConnection({ body, metadata }): Promise<ConnectionRes> {
+    const { id } = body;
+
+    return lastValueFrom(
+      this.connectionServiceWrite.DeleteConnection(
+        {
+          id,
+        },
+        metadata,
+      ),
+    );
+  }
+
+  async getAllConnections({ body, metadata }): Promise<ConnectionsRes> {
+    const { search, filters, size, page } = body;
+
+    return lastValueFrom(
+      this.connectionServiceRead.GetAllConnection(
+        { search, filters: JSON.stringify(filters), size, page },
+        metadata,
+      ),
+    );
+  }
+
+  async getConnectionDetails({
+    body,
+    metadata,
+  }): Promise<GetConnectionDetailsResponse> {
+    const id = body.connection_id || body.id;
+
+    return lastValueFrom(
+      this.connectionServiceRead.GetConnectionDetails({ id }, metadata),
+    );
+  }
+
+  async INTERNAL_getAllConnections({
+    customer_name,
+  }: {
+    customer_name: string;
+  }): Promise<INTERNAL_GetAllConnectionsResponse> {
+    return lastValueFrom(
+      this.connectionServiceRead.INTERNAL_GetAllConnections({ customer_name }),
+    );
+  }
+
+  async catalogExistingConnection(data: {
+    connection?: ConnectionToCatalogDto;
+    networkConfig?: NetworkConfigDto;
+  }) {
+    return lastValueFrom(
+      this.connectionServiceRead.INTERNAL_CatalogExistingConnection({
+        data_str: JSON.stringify(data),
+      }),
+    );
+  }
+
+  async synchronizeConnections(apply: boolean) {
+    const connectors = await this.connectorService
+      .getAllConnectors({
+        search: undefined,
+        filters: undefined,
+        language: 'pt-br',
+        page: 1,
+        size: 500,
+      })
+      .then(({ connectors: connectorsStr }) =>
+        JSON.parse(connectorsStr).map((c) => c),
+      );
+    const { customers } = await this.usersService.findAllCustomers();
+
+    const customer_connections: {
+      customer_name: string;
+      customer_id: string;
+      productConnections: Record<string, any>[];
+      platformConnections: ConnectionApiConnection[];
+      productNetworkConfigs: Record<string, any>[];
+      platformNetworkConfigs: ConnectionsApiNetworkConfig[];
+    }[] = [];
+    for (const customer of customers) {
+      const { name: customer_name, id: customer_id } = customer;
+
+      const customer_connection = await this.INTERNAL_getAllConnections({
+        customer_name,
+      }).then((res) => ({
+        customer_name,
+        customer_id,
+        platformConnections: res.platformConnections
+          ? JSON.parse(res.platformConnections)
+          : [],
+        productConnections: res.productConnections
+          ? JSON.parse(res.productConnections)
+          : [],
+        productNetworkConfigs: res.productNetworkConfigs
+          ? JSON.parse(res.productNetworkConfigs)
+          : [],
+        platformNetworkConfigs: res.platformNetworkConfigs
+          ? JSON.parse(res.platformNetworkConfigs)
+          : [],
+      }));
+      customer_connections.push(customer_connection);
+    }
+    this.logger.info(
+      'DEBUG_ConnectionsMigrations - ' + JSON.stringify(customer_connections),
+    );
+
+    const migrations: {
+      customer_name: string;
+      status: any[];
+      productConnectionsMissing: ConnectionApiConnection[];
+      productNetworkConfigsMissing: ConnectionsApiNetworkConfig[];
+    }[] = [];
+    for (const customer_connection of customer_connections) {
+      const productConnectionsMissing: ConnectionApiConnection[] = [];
+      const productNetworkConfigsMissing: ConnectionsApiNetworkConfig[] = [];
+      const status: any[] = [];
+      let updatePromises: Promise<any>[] = [];
+
+      this.logger.info(
+        'DEBUG_ConnectionsMigrations - customer_connections ' +
+          JSON.stringify(customer_connection),
+      );
+      const {
+        customer_name,
+        productConnections,
+        platformConnections,
+        productNetworkConfigs,
+        platformNetworkConfigs,
+        customer_id,
+      } = customer_connection;
+
+      platformConnections?.forEach((plc) => {
+        const productConnection = productConnections.find(
+          (prc) => prc.id === plc.config_id,
+        );
+        if (!productConnection) productConnectionsMissing.push(plc);
+      });
+      platformNetworkConfigs?.forEach((platNetConfig) => {
+        const productNetworkConfig = productNetworkConfigs.find(
+          (prodNetConfig) => prodNetConfig.id === platNetConfig.config_id,
+        );
+        if (!productNetworkConfig)
+          productNetworkConfigsMissing.push(platNetConfig);
+      });
+      if (apply) {
+        for (const network_config of productNetworkConfigsMissing) {
+          const networkConfigToCatalog = {
+            id: network_config.config_id,
+            created_at: network_config.created_at,
+            updated_at: network_config.updated_at,
+            customer_name: customer_name,
+            customer_id: customer_id,
+            user_id: '',
+            network_type_id: '',
+            network_type_name: network_config.type,
+            type: network_config.type,
+            plugin: network_config.plugin,
+            name: network_config.name,
+            description: network_config.description,
+            properties: undefined,
+            keywords: undefined,
+            tags: undefined,
+          };
+
+          updatePromises.push(
+            this.catalogExistingConnection({
+              networkConfig: networkConfigToCatalog,
+            }),
+          );
+        }
+
+        this.logger.info(
+          'DEBUG_ConnectionsMigrations - Creating missing network configs for customer' +
+            customer_name +
+            ' - ' +
+            JSON.stringify(customer_connection),
+        );
+        const updateStatuses = await Promise.all(updatePromises);
+        status.push(...updateStatuses);
+        updatePromises = [];
+        for (const connection of productConnectionsMissing) {
+          const connector = connectors.find(
+            (c) => c._source.plugin === connection.plugin,
+          );
+          const connectionToCatalog = {
+            id: connection.config_id,
+            created_at: connection.created_at,
+            updated_at: new Date().toISOString(),
+            customer_id: customer_id,
+            user_id: '',
+            plugin: connection.plugin,
+            name: connection.name,
+            description: connection.description,
+            image_url: connector._source.image,
+            network_config_id: connection.network_config_id,
+            type: connection.type,
+            connector_id: connector._id,
+            connector_name: connector._source.name,
+            in_use: 1,
+            username: '',
+            customer_name,
+          };
+
+          updatePromises.push(
+            this.catalogExistingConnection({ connection: connectionToCatalog }),
+          );
+        }
+        this.logger.info(
+          'DEBUG_ConnectionsMigrations - Creating missing connections for customer' +
+            ' - ' +
+            customer_name +
+            JSON.stringify(customer_connection),
+        );
+        const updateStatuses_2 = await Promise.all(updatePromises);
+        status.push(...updateStatuses_2);
+      }
+
+      this.logger.info(
+        'DEBUG_ConnectionsMigrations - migrations for customer ' +
+          customer_name +
+          ' - ' +
+          JSON.stringify(customer_connection),
+      );
+      migrations.push({
+        customer_name,
+        status,
+        productConnectionsMissing,
+        productNetworkConfigsMissing,
+      });
+    }
+
+    return { migrations };
+  }
+}

src/modules/connection/connection.controller.ts

@@ -0,0 +1,212 @@
+import {
+  Body,
+  Controller,
+  Post,
+  Inject,
+  Put,
+  Param,
+  Delete,
+  Get,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiExcludeEndpoint, ApiTags } from '@nestjs/swagger';
+import { ConnectionClientService } from './client.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from 'src/decorators/authentication.decorator';
+import { 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,
+  UpdateConnectionDto,
+} from './dtos/connection';
+import { CreateConnectionDto } from './dtos/connection';
+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')
+@Authenticated()
+@Controller('connections')
+export class ConnectionController {
+  logger: any;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private clientService: ConnectionClientService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @ApiInternalOnlyEndpoint()
+  @Get('connections-migration')
+  @ApiExcludeEndpoint()
+  @RequireAllPermissions(
+    PERMISSIONS_GROUPS.DADOSFERA.permissions.CONNECTIONS_MIGRATION,
+  )
+  async synchronizeConnections(@Query('apply') apply: string) {
+    return this.clientService.synchronizeConnections(apply === 'true');
+  }
+
+  @Post()
+  @RequireAllPermissions(connectionPermissions.CREATE)
+  async createConnection(
+    @User() user: RequestUser,
+    @Body(new ValidationPipe()) body: CreateConnectionDto,
+  ): Promise<ConnectionRes> {
+    this.logger.info('/connections - Create Connection');
+
+    const { user_id, customer_id, customer_name, username } = user;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      username,
+    });
+
+    const response: any = await this.clientService.createConnection(
+      body,
+      metadata,
+    );
+
+    return response;
+  }
+
+  @Put('/:id')
+  @RequireAllPermissions(connectionPermissions.CREATE)
+  async updateConnection(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+    @Body(new ValidationPipe()) body: UpdateConnectionDto,
+  ): Promise<ConnectionRes> {
+    this.logger.info('/connections - Update Connection');
+
+    const { user_id, customer_id, customer_name, username } = user;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      language,
+      username,
+    });
+
+    const response: any = await this.clientService.updateConnection(
+      id,
+      body,
+      metadata,
+    );
+
+    return response;
+  }
+
+  @Delete('/:id')
+  @RequireAllPermissions(connectionPermissions.DELETE)
+  async deleteConnection(
+    @User() user: RequestUser,
+    @Param('id') id: string,
+  ): Promise<ConnectionRes> {
+    this.logger.info('/connections - Delete Connection');
+
+    const { user_id, customer_id, customer_name, username } = user;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      username,
+    });
+
+    const response: any = await this.clientService.deleteConnection({
+      body: { id },
+      metadata,
+    });
+
+    return response;
+  }
+
+  @Get()
+  async getAllConnections(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Query() queries,
+  ): Promise<ConnectionsRes> {
+    this.logger.info('/connections - Get All Connection');
+
+    const { user_id, customer_id, customer_name, username } = user;
+    const { search, size, page, ...filters } = queries;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      language,
+      username,
+    });
+
+    const response = await this.clientService.getAllConnections({
+      body: { search, size, page, filters },
+      metadata,
+    });
+
+    return response;
+  }
+
+  @Get('/:id')
+  async getConnectionDetails(
+    @Language() language: LanguageEnum,
+    @User() user: RequestUser,
+    @Param('id') id: string,
+    @Query() queries,
+  ): Promise<ConnectionDetailsRes> {
+    this.logger.info('/connections - Get Connection Details');
+
+    console.log(queries);
+
+    const { details, sensitive } = queries;
+
+    const { user_id, customer_id, customer_name, username } = user;
+    const metadata = PackTheMetadata({
+      user_id,
+      customer_id,
+      customer_name,
+      username,
+      details,
+      language,
+      sensitive,
+    });
+
+    const response: any = await this.clientService.getConnectionDetails({
+      body: { id },
+      metadata,
+    });
+
+    if (details === 'true') {
+      const properties = JSON.parse(response.connection.properties);
+
+      Object.assign(response.connection, {
+        pipelines: JSON.parse(response.connection.pipelines),
+        connection_controls: properties.connection_controls,
+        config_controls: properties.config_controls,
+        connection_steps: properties.connection_steps,
+      });
+
+      delete response.connection.properties;
+    } else {
+      Object.assign(response.connection, {
+        properties: JSON.parse(response.connection.properties),
+        pipelines: JSON.parse(response.connection.pipelines),
+      });
+    }
+
+    return response;
+  }
+}

src/modules/connection/connection.module.ts

@@ -0,0 +1,22 @@
+import { Module } from '@nestjs/common';
+import { ClientsModule } from '@nestjs/microservices';
+import { ConnectionClientService } from './client.service';
+import { ConnectionClientConfiguration } from './client.config';
+import { ConnectionController } from './connection.controller';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { UsersModule } from '../users/users.module';
+import { ConnectorModule } from '../connector/connector.module';
+
+const client = new ConnectionClientConfiguration();
+
+@Module({
+  imports: [
+    ClientsModule.register([client.providerOptions]),
+    UsersModule,
+    ConnectorModule,
+  ],
+  controllers: [ConnectionController],
+  providers: [ConnectionClientService, DadosferaLogger],
+  exports: [ConnectionClientService],
+})
+export class ConnectionModule {}

src/modules/connection/dtos/connection.ts

@@ -0,0 +1,189 @@
+import {
+  ApiProperty,
+  ApiPropertyOptional,
+  OmitType,
+  PickType,
+} from '@nestjs/swagger';
+import {
+  Connection,
+  ConnectionToCatalog,
+} from '@dadosfera/protospack-v2/dist/lib/ConnectionManager/interfaces/entities';
+import {
+  GetAllConnectionResponse,
+  GetConnectionDetailsResponse,
+  GetConnectionResponse,
+} from '@dadosfera/protospack-v2/dist/lib/ConnectionManager/interfaces/messages';
+export type ConnectionTypes = 'database' | 'file' | 'application';
+export type ConnectionCredentialsType =
+  | 'basic_auth'
+  | 'iam_user'
+  | 'role_name'
+  | 'oauth'
+  | 'api_key'
+  | 'service_account'
+  | 'headers_authF';
+export interface ConnectionApiConnection {
+  config_id: string;
+  plugin: string;
+  secret_id: string;
+  created_at: string;
+  network_config_id: null;
+  type: ConnectionTypes;
+  credentials_type: ConnectionCredentialsType;
+  credentials: Record<string, any>;
+  sensitive_fields: string[];
+  name: string;
+  customer_name: string;
+  description: string;
+  updated_at: string;
+}
+export class ConnectionDto implements Connection {
+  // ---Automatically generated information will not be sent by the frontend--- //
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  customer_id: string;
+
+  @ApiProperty()
+  customer_name: string;
+
+  @ApiProperty()
+  user_id: string;
+
+  @ApiProperty()
+  updated_at: string;
+
+  @ApiProperty()
+  created_at: string;
+
+  @ApiProperty()
+  pipelines: string;
+
+  // ---Information sent by the frontend--- //
+
+  @ApiProperty()
+  name: string;
+
+  @ApiProperty()
+  description: string;
+
+  @ApiProperty()
+  type: string;
+
+  @ApiPropertyOptional()
+  network_config_id: string | null;
+
+  @ApiProperty()
+  properties: DatabaseConnectionPropertiesDto | any;
+
+  // ---Information sent by the frontend (Heirs of Connector)--- //
+
+  @ApiProperty()
+  connector_id: string;
+
+  @ApiProperty()
+  connector_name: string;
+
+  @ApiProperty()
+  plugin: string;
+
+  @ApiProperty()
+  image_url: string;
+}
+
+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;
+  // ---Information extracted from token--- //
+  user_id: string;
+  username: string;
+  customer_name: string;
+
+  // ---Information sent by the frontend--- //
+  @ApiProperty()
+  name: string;
+
+  @ApiProperty()
+  description: string;
+
+  @ApiProperty()
+  type: string;
+
+  @ApiPropertyOptional()
+  network_config_id: string | null;
+
+  // ---Information sent by the frontend (Heirs of Connector)--- //
+  @ApiProperty()
+  connector_id: string;
+
+  @ApiProperty()
+  connector_name: string;
+
+  @ApiProperty()
+  plugin: string;
+
+  @ApiProperty()
+  image_url: string;
+}
+
+export class CreateConnectionDto extends OmitType(ConnectionDto, [
+  'id',
+  'customer_id',
+  'customer_name',
+  'user_id',
+  'created_at',
+  'updated_at',
+  'pipelines',
+]) {}
+
+export class UpdateConnectionDto extends PickType(ConnectionDto, [
+  'name',
+  'description',
+  'network_config_id',
+  'properties',
+]) {}
+
+export class ConnectionsRes implements GetAllConnectionResponse {
+  @ApiProperty({ type: [ConnectionToCatalogDto] })
+  connections: ConnectionToCatalogDto[];
+
+  @ApiProperty()
+  message: string;
+}
+
+export class ConnectionRes implements GetConnectionResponse {
+  @ApiProperty()
+  connection?: ConnectionToCatalogDto;
+
+  @ApiProperty()
+  message: string;
+}
+
+export class ConnectionDetailsRes implements GetConnectionDetailsResponse {
+  @ApiProperty()
+  connection?: ConnectionDto;
+
+  @ApiProperty()
+  message: string;
+}
+
+export class DatabaseConnectionPropertiesDto {
+  @ApiProperty()
+  credentials_type: 'basic_auth';
+  @ApiProperty()
+  plugin: string;
+  @ApiProperty()
+  host: string;
+  @ApiProperty()
+  port: string;
+  @ApiProperty()
+  username: string;
+  @ApiProperty()
+  password: string;
+  @ApiProperty()
+  database: string;
+}

src/modules/connector/client.config.ts

@@ -0,0 +1,38 @@
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientsProviderAsyncOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import { ConnectorManager } from '@dadosfera/protospack-v2';
+
+const isLocalConnection = !!process.env.INFACTORY_URL?.includes('0.0.0.0');
+
+export class ConnectorClientConfiguration {
+  public name = 'ConnectorClientConfiguration';
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.INFACTORY_URL,
+      package: [
+        ConnectorManager.ProtoPackages.WritePackage,
+        ConnectorManager.ProtoPackages.ReadPackage,
+      ],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [
+        ConnectorManager.ProtoPaths.WriteFilePath,
+        ConnectorManager.ProtoPaths.ReadFilePath,
+      ],
+      loader: {
+        keepCase: true,
+        enums: String,
+        objects: true,
+        arrays: true,
+      },
+    },
+  };
+  providerOptions: ClientsProviderAsyncOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/connector/client.service.ts

@@ -0,0 +1,204 @@
+import { Metadata } from '@grpc/grpc-js';
+import {
+  OnModuleInit,
+  Inject,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ConnectorManager } from '@dadosfera/protospack-v2';
+import { lastValueFrom } from 'rxjs';
+import { ConnectorClientConfiguration } from './client.config';
+
+export class ConnectorClientService implements OnModuleInit {
+  private connectorServiceRead: ConnectorManager.ReadService.ConnectorManagerReadServices;
+  private connectorServiceWrite: ConnectorManager.WriteService.ConnectorManagerWriteServices;
+  constructor(
+    @Inject(ConnectorClientConfiguration.name)
+    private readonly grpcClient: ClientGrpc,
+  ) {}
+
+  onModuleInit() {
+    this.connectorServiceWrite =
+      this.grpcClient.getService<ConnectorManager.WriteService.ConnectorManagerWriteServices>(
+        ConnectorManager.ProtoServices.ConnectorManagerWriteServices,
+      );
+
+    this.connectorServiceRead =
+      this.grpcClient.getService<ConnectorManager.ReadService.ConnectorManagerReadServices>(
+        ConnectorManager.ProtoServices.ConnectorManagerReadServices,
+      );
+  }
+
+  async uploadConnector(uploadConnector) {
+    const connector: ConnectorManager.Entities.ConnectorCreateRequest = {
+      file: {
+        buffer: uploadConnector.file.buffer,
+        mimetypes: uploadConnector.file.mimetype,
+      },
+      connector: JSON.stringify(uploadConnector.connector),
+    };
+    const serviceBody: ConnectorManager.Messages.RegisterConnectorRequest = {
+      connector,
+    };
+
+    return lastValueFrom(
+      this.connectorServiceWrite.RegisterConnector(serviceBody),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+  }
+
+  async uploadFile(uploadFile) {
+    const body: ConnectorManager.Messages.UploadFileRequest = {
+      file: {
+        buffer: uploadFile.file.buffer,
+        mimetypes: uploadFile.file.mimetype,
+      },
+      name: uploadFile.name,
+    };
+
+    return lastValueFrom(this.connectorServiceWrite.UploadFile(body)).catch(
+      (err) => {
+        throw new HttpException(
+          err.details,
+          err.code === 6 ? HttpStatus.CONFLICT : 400,
+        );
+      },
+    );
+  }
+
+  async uploadConnectorsFile(uploadFile: Express.Multer.File) {
+    const res = await lastValueFrom(
+      this.connectorServiceWrite.RegisterMultipleConnectorsWithoutImage({
+        connectors: uploadFile.buffer,
+      }),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+    const responseParsed = JSON.parse(res.message);
+    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 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: connectorErrors,
+      created: connectorCreated,
+      updated: connectorUpdated,
+      noop: connectorNoop,
+    };
+  }
+
+  async getAllConnectors(body) {
+    const meta = new Metadata();
+    meta.add('Language', body.language);
+    return lastValueFrom(
+      this.connectorServiceRead.GetAllConnectors(
+        {
+          search: body.search,
+          filters: JSON.stringify(body.filters),
+          language: body.language,
+          page: body.page,
+          size: body.size,
+        },
+        meta,
+      ),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+  }
+
+  async getConnectorDetails(connectorId: string, language: string) {
+    const meta = new Metadata();
+    meta.add('Language', language);
+    return lastValueFrom(
+      this.connectorServiceRead.GetConnectorDetails(
+        {
+          plugin: connectorId,
+        },
+        meta,
+      ),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+  }
+
+  async getConnector(plugin: string, language: string) {
+    const meta = new Metadata();
+    meta.add('Language', language);
+    return lastValueFrom(
+      this.connectorServiceRead.GetConnector(
+        {
+          plugin,
+        },
+        meta,
+      ),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+  }
+
+  async getConnectorsTags() {
+    return lastValueFrom(this.connectorServiceRead.GetConnectorsTags({})).catch(
+      (err) => {
+        throw new HttpException(
+          err.details,
+          err.code === 6 ? HttpStatus.CONFLICT : 400,
+        );
+      },
+    );
+  }
+
+  async deleteConnector(plugin: string, version: string) {
+    return lastValueFrom(
+      this.connectorServiceWrite.DeleteConnector({
+        version,
+        plugin,
+      }),
+    );
+  }
+
+  async updateConnector({ plugin, changes }) {
+    return lastValueFrom(
+      this.connectorServiceWrite.UpdateConnector({
+        plugin,
+        changes,
+      }),
+    ).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+  }
+}

src/modules/connector/connector.controller.ts

@@ -10,32 +10,51 @@ import {
   Query,
   UploadedFile,
   UseInterceptors,
+  Inject,
+  UploadedFiles,
 } from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import { ApiBearerAuth, ApiConsumes, ApiTags } from '@nestjs/swagger';
-import { ConnectorClientService } from 'src/clients/connector/client.service';
+import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
+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';
-import { UploadFileDto } from './dtos/upload-file';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import {
+  Authenticated,
+  RequireAllPermissions,
+  RequireSomePermission,
+} from 'src/decorators/authentication.decorator';
+import { 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 {
-  constructor(private connectorClientService: ConnectorClientService) {}
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private connectorClientService: ConnectorClientService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
 
   @Post()
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.CREATE)
   @ApiConsumes('multipart/form-data')
   @UseInterceptors(FileInterceptor('file'))
   async uploadConnector(
     @UploadedFile() file,
     @Body() body: CreateConnectorDto,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
+    this.logger.info('/upload - Upload Connector Route');
 
     const response = await this.connectorClientService.uploadConnector({
       file,
@@ -45,32 +64,58 @@ export class ConnectorController {
     return response;
   }
 
-  @Post('/upload')
+  @Post('/uploads')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.CREATE)
   @ApiConsumes('multipart/form-data')
-  @UseInterceptors(FileInterceptor('file'))
-  async uploadFile(@UploadedFile() file, @Body() { name }: UploadFileDto) {
-    console.log(`/upload`, 'Upload Connector Route');
-
-    const response = await this.connectorClientService.uploadFile({
-      file,
-      name,
+  @UseInterceptors(FilesInterceptor('files'))
+  async uploadFile(@UploadedFiles() files) {
+    this.logger.info('/upload - Upload Connector Route');
+    const promises = files.map(async (file) => {
+      return await this.connectorClientService.uploadFile({
+        file,
+        name: file.originalname.split('.')[0],
+      });
     });
 
+    const response = await Promise.all(promises);
     return response;
   }
 
-  @Get()
-  async getAllConnectors(@Query() queries: GetAllDto) {
-    console.log(`/upload`, 'Upload Connector Route');
+  @Post('/multiple-connectors-upload')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.CREATE)
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadConnectorsFile(@UploadedFile() file: Express.Multer.File) {
+    this.logger.info(`/upload`, 'Upload Connector Route');
 
-    const { search, ...filters } = queries;
+    return await this.connectorClientService.uploadConnectorsFile(file);
+  }
+
+  @Get()
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CONNECTORS.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
+  )
+  async getAllConnectors(
+    @Language() language: LanguageEnum,
+    @Query() queries: GetAllDto,
+  ) {
+    this.logger.info('/GET - getAllConnectors Route');
+
+    const { search, size, page, ...filters } = queries;
 
     const response: any = await this.connectorClientService.getAllConnectors({
       filters: filters || {},
       search: search || '',
+      language: language || 'pt-br',
+      size: size || 10,
+      page: page || 1,
     });
 
-    const connectors = JSON.parse(response.connectors).connectors;
+    const connectors = JSON.parse(response.connectors);
 
     return {
       message: response.message,
@@ -78,17 +123,38 @@ export class ConnectorController {
     };
   }
 
+  @Get('/tags')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CONNECTORS.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
+  )
+  async getConnectorsTags() {
+    return await this.connectorClientService.getConnectorsTags();
+  }
+
   @Get('/:plugin')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CONNECTORS.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
+  )
   async getConnector(
+    @Language() language: LanguageEnum,
     @Param('plugin') plugin: string,
     @Query('version') version: string,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
+    this.logger.info('/GET/:plugin - getConnector Route');
 
     const pluginId = `${plugin}-${version}`;
 
     const response: any = await this.connectorClientService.getConnector(
       pluginId,
+      language,
     );
 
     return {
@@ -98,16 +164,24 @@ export class ConnectorController {
   }
 
   @Get('/:plugin/details')
+  @RequireSomePermission(
+    PERMISSIONS_GROUPS.CONNECTORS.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.GET,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE,
+    PERMISSIONS_GROUPS.PIPELINE.permissions.DELETE,
+  )
   async getConnectorDetails(
+    @Language() language: LanguageEnum,
     @Param('plugin') plugin: string,
     @Query('version') version: string,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
-
+    this.logger.info('/upload - Upload Connector Route');
     const pluginId = `${plugin}-${version}`;
 
     const response: any = await this.connectorClientService.getConnectorDetails(
       pluginId,
+      language || 'pt-br',
     );
 
     return {
@@ -117,12 +191,13 @@ export class ConnectorController {
   }
 
   @Put('/:plugin')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
   @ApiConsumes('multipart/form-data')
   async updateConnector(
     @Param('plugin') plugin: string,
     @Body() body: UpdateDto,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
+    this.logger.info('/upload - Upload Connector Route');
 
     const changes = body;
 
@@ -138,11 +213,12 @@ export class ConnectorController {
   }
 
   @Put('/:plugin/add-tag')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
   async addTagOnConnector(
     @Param('plugin') plugin: string,
     @Body() body: AddTagDto,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
+    this.logger.info('/upload - Upload Connector Route');
 
     const { tags } = body;
 
@@ -164,11 +240,12 @@ export class ConnectorController {
   }
 
   @Put('/:plugin/remove-tag')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.UPDATE)
   async removeTagOnConnector(
     @Param('plugin') plugin: string,
     @Body() body: RemoveTagDto,
   ) {
-    console.log(`/upload`, 'Upload Connector Route');
+    this.logger.info('/upload - Upload Connector Route');
 
     const { tags } = body;
     const remove = tags;
@@ -191,20 +268,18 @@ export class ConnectorController {
   }
 
   @Delete('/:plugin')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.CONNECTORS.permissions.DELETE)
   async deleteConnector(
     @Param('plugin') plugin: string,
-    @Body() { version }: DeleteConnectorDto,
+    @Query('version') version: string,
   ) {
-    console.log(`/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/connector/connector.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { ClientsModule } from '@nestjs/microservices';
+import { ConnectorClientService } from './client.service';
+import { ConnectorClientConfiguration } from './client.config';
+import { ConnectorController } from './connector.controller';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+const client = new ConnectorClientConfiguration();
+
+@Module({
+  controllers: [ConnectorController],
+  providers: [ConnectorClientService, DadosferaLogger],
+  imports: [ClientsModule.register([client.providerOptions])],
+  exports: [ConnectorClientService],
+})
+export class ConnectorModule {}

src/modules/connector/dtos/create-multiple-connector.ts

@@ -0,0 +1,6 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UploadConnectorsFileDto {
+  @ApiProperty({ format: 'binary' })
+  file: string;
+}

src/modules/connector/dtos/get-all.ts

@@ -4,6 +4,15 @@ export class GetAllDto {
   @ApiProperty()
   search: string;
 
+  @ApiProperty()
+  language: string;
+
+  @ApiProperty()
+  size: string;
+
+  @ApiProperty()
+  page: string;
+
   @ApiProperty()
   filters: any;
 }

src/modules/customers/customers.controller.ts

@@ -0,0 +1,74 @@
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { IdResponse } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Put,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from 'src/decorators/authentication.decorator';
+import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { CustomersService } from './customers.service';
+import { CustomerDto, CustomerLinksResponse } from './dtos/customers';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import type { StringValue } from 'ms';
+
+@ApiInternalOnlyController()
+@ApiTags('Customers')
+@Controller('customers')
+@Authenticated()
+@UseFilters(GrpcToHttpExceptionFilter)
+export class CustomersController {
+  logger: DadosferaLogger;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private customersService: CustomersService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Get(':id/links')
+  async getCustomerLinks(@Param('id') id): Promise<CustomerLinksResponse> {
+    this.logger.info('getCustomerLinks', { id });
+    const links = await this.customersService.getLinks(id);
+    return { links };
+  }
+
+  @Put(':id/links')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.USERS.permissions.ADMIN)
+  setCustomerLinks(
+    @Body() body: CustomerDto,
+    @Param('id') id,
+  ): Promise<IdResponse> {
+    const { links } = body;
+    this.logger.info('setCustomerLinks', { id, links });
+    return this.customersService.setLinks(id, links);
+  }
+
+  @Get('token')
+  @RequireAllPermissions(PERMISSIONS_GROUPS.AUTH.permissions.GENERATE_TOKEN)
+  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);
+  }
+}

src/modules/customers/customers.module.ts

@@ -0,0 +1,16 @@
+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';
+
+const client = new DucClient();
+
+@Module({
+  imports: [ClientsModule.register([client.providerOptions])],
+  controllers: [CustomersController],
+  providers: [CustomersService, DadosferaLogger],
+  exports: [CustomersService],
+})
+export class CustomersModule {}

src/modules/customers/customers.service.ts

@@ -0,0 +1,123 @@
+import {
+  OnModuleInit,
+  Inject,
+  Injectable,
+  HttpException,
+  HttpStatus,
+  InternalServerErrorException,
+} from '@nestjs/common';
+
+import { firstValueFrom, lastValueFrom } from 'rxjs';
+import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
+import { DucClient } from '../duc/client.config';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
+import { CustomerUpdateRequest } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
+import { CustomersProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
+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';
+
+// This function will accept any string, which may result in a bug.
+@Injectable()
+export class CustomersService implements OnModuleInit {
+  private customerService: CustomersProtoService;
+
+  constructor(
+    @Inject(DucClient.name) private readonly grpcClient: ClientGrpc,
+  ) {}
+
+  onModuleInit() {
+    this.customerService = this.grpcClient.getService<CustomersProtoService>(
+      ProtoServices.CustomersProtoService,
+    );
+  }
+
+  async getLinks(customerId: string) {
+    try {
+      const result = await lastValueFrom(
+        this.customerService.CustomerFindOneById({ id: customerId }),
+      );
+      return result.customer?.links || [];
+    } catch (err) {
+      if (err.details === ErrorCodes.CUSTOMER.NOT_FOUND)
+        throw new HttpException(err.details, HttpStatus.NOT_FOUND);
+      throw err;
+    }
+  }
+
+  async setLinks(customerId: string, links: Link[]) {
+    if (!customerId || !links) {
+      throw new HttpException(null, HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      return await firstValueFrom(
+        this.customerService.CustomerUpdate({
+          id: customerId,
+          links,
+        } as CustomerUpdateRequest),
+      );
+    } 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;
+  }
+}

src/modules/customers/dtos/customers.ts

@@ -0,0 +1,12 @@
+import { Link } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CustomerDto {
+  @ApiProperty()
+  links: Link[];
+}
+
+export class CustomerLinksResponse {
+  @ApiProperty()
+  links: Link[];
+}

src/modules/duc/client.config.ts

@@ -0,0 +1,37 @@
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientsProviderAsyncOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import {
+  ProtoPackages,
+  ProtoPaths,
+} from '@dadosfera/protospack-v2/dist/lib/Duc';
+
+const isLocalConnection = !!process.env.DUC_URL?.includes('0.0.0.0');
+
+export class DucClient {
+  public name = 'DucClient';
+
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.DUC_URL,
+      package: [ProtoPackages.WritePackage, ProtoPackages.ReadPackage],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [ProtoPaths.WriteFilePath, ProtoPaths.ReadFilePath],
+      loader: {
+        keepCase: true,
+        enums: String,
+        objects: true,
+        arrays: true,
+      },
+    },
+  };
+
+  providerOptions: ClientsProviderAsyncOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/health/health.controller.ts

@@ -1,15 +1,22 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, Inject } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { HealthService } from './health.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 
 @ApiTags('Health')
 @Controller('health')
 export class HealthController {
-  constructor(private readonly healthService: HealthService) {}
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private readonly healthService: HealthService,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
 
   @Get()
   check() {
-    console.log(`/health`, 'check');
     return this.healthService.check();
   }
 }

src/modules/health/health.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+import { HealthController } from './health.controller';
+import { HealthService } from './health.service';
+
+@Module({
+  controllers: [HealthController],
+  providers: [HealthService, DadosferaLogger],
+})
+export class HealthModule {}

src/modules/health/health.service.spec.ts

@@ -1,5 +0,0 @@
-describe('PipelinesGrpcServerService', () => {
-  it('should be defined', () => {
-    expect(2 + 2).toBe(4);
-  });
-});

src/modules/health/health.service.ts

@@ -1,9 +1,16 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
 
 @Injectable()
 export class HealthService {
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
   check() {
-    console.log('HEALTH');
     return { message: 'Ok' };
   }
 }

src/modules/inputs/dtos/input.model.ts

@@ -1,134 +1,45 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { Method } from 'axios';
+import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
 
-export class InputModel {
-  category: string;
-  plugin: string;
-  name: string;
-  cron?: string;
-  credentials?: {
-    connection_type: string;
-    oauth: string;
-    oauth_code: string;
-    start_date: string;
-  };
-  options?: {
-    oauth?: {
-      get_tokens_url: string;
-      get_tokens_method?: Method;
-      get_tokens_url_params: string;
-      get_tokens_set_response: Record<string, string>;
-      content_type: string;
-    };
-  };
-}
-
-class GoogleAnalyticsClientSecrets {
-  @ApiProperty()
-  type: string;
-  @ApiProperty()
-  project_id: string;
-  @ApiProperty()
-  private_key_id: string;
-  @ApiProperty()
-  private_key: string;
-  @ApiProperty()
-  client_email: string;
-  @ApiProperty()
-  client_id: string;
-  @ApiProperty()
-  auth_uri: string;
-  @ApiProperty()
-  token_uri: string;
-  @ApiProperty()
-  auth_provider_x509_cert_url: string;
-  @ApiProperty()
-  client_x509_cert_url: string;
-}
-class OauthObject {
-  @ApiPropertyOptional()
-  get_tokens_url: string;
-  @ApiPropertyOptional()
-  get_tokens_url_params: string;
-  @ApiPropertyOptional()
-  get_tokens_set_response: Record<string, any>;
-  @ApiPropertyOptional()
-  content_type: string;
-}
-class InputOptions {
-  @ApiPropertyOptional()
-  oauth: OauthObject;
-  @ApiPropertyOptional()
-  skip_select_columns: true;
-  @ApiPropertyOptional()
-  skip_select_entities: false;
-  @ApiPropertyOptional()
-  skip_transformation: true;
-}
-
-class CredentialsJdbc {
-  @ApiPropertyOptional()
-  jdbc_user: string;
-  @ApiPropertyOptional()
-  jdbc_password: string;
-  @ApiPropertyOptional()
-  database: string;
-  @ApiPropertyOptional()
-  endpoint: string;
-  @ApiPropertyOptional()
-  port: string;
-  @ApiPropertyOptional()
-  engine: string;
-  @ApiPropertyOptional()
-  schema: string;
-}
-class FileFormatParams {
-  @ApiPropertyOptional()
-  file_format: string;
-  @ApiPropertyOptional()
-  encoding: string;
-}
-
-class Credentials extends CredentialsJdbc {
-  @ApiProperty()
-  connection_type: string;
-
-  @ApiPropertyOptional()
-  client_aws_access_key_id: string;
-  @ApiPropertyOptional()
-  client_aws_secret_access_key: string;
-  @ApiPropertyOptional()
-  client_bucket: string;
-  @ApiPropertyOptional()
-  file_to_extract: string;
-  @ApiPropertyOptional()
-  file_format_params: FileFormatParams;
-
-  @ApiPropertyOptional()
-  view_id: string;
-  @ApiPropertyOptional()
-  client_secrets: GoogleAnalyticsClientSecrets;
-  @ApiPropertyOptional()
-  start_date: string;
-  @ApiPropertyOptional()
-  end_date: string;
-
-  @ApiPropertyOptional()
-  oauth_code: string;
-}
-class Column {
+export class Column {
   @ApiProperty()
   name: string;
   @ApiProperty()
   type: string;
 }
-class TableColumns {
+export class TableColumns {
   @ApiProperty()
   name: string;
   @ApiProperty()
-  columns: Column[];
+  columns: string[];
   @ApiProperty()
   references: Column[];
+  @ApiProperty()
+  type: string;
+}
+export class AvailableEntity {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  replication_methods: string[];
+}
+
+export class Input {
+  @ApiProperty()
+  id: string;
+  @ApiProperty({ type: [TableColumns] })
+  tables: TableColumns[];
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  description: string;
+  @ApiProperty()
+  plugin: string;
+  @ApiPropertyOptional()
+  type?: string;
+  @ApiProperty()
+  created_at: string;
+  @ApiProperty()
+  updated_at: string;
 }
 export class GetAvailableEntitiesReq {
   @ApiProperty()
@@ -136,71 +47,12 @@ export class GetAvailableEntitiesReq {
 }
 
 export class GetAvailableEntitiesRes {
-  @ApiProperty()
-  entities: string[];
+  @ApiProperty({ type: [AvailableEntity] })
+  entities: AvailableEntity[];
 }
 
-export class TestConnectionGetColumnsReq {
-  @ApiProperty()
-  plugin: string;
-  @ApiProperty()
-  tables: string[];
-  @ApiPropertyOptional()
-  credentials: CredentialsJdbc;
-  @ApiPropertyOptional()
-  id: string;
-}
-export class TestConnectionGetColumnsRes {
-  @ApiProperty()
-  tables: TableColumns[];
-}
-
-export class TestConnectionReq {
-  @ApiProperty()
-  plugin: string;
-  @ApiProperty()
-  credentials: CredentialsJdbc;
-}
-export class TestConnectionRes {
-  @ApiProperty()
-  connection_state: boolean;
-  @ApiProperty()
-  total_entities: number;
-  @ApiProperty()
-  database_tables: string[];
-}
-export class CreateInputReq {
-  @ApiPropertyOptional()
-  id: string;
-  @ApiProperty()
-  plugin: string;
-  @ApiProperty()
-  category: string;
-  @ApiProperty()
-  credentials: Credentials;
-  @ApiProperty()
-  name: string;
-  @ApiPropertyOptional()
-  options: InputOptions;
-}
-
-export class Input {
-  @ApiProperty()
-  id: string;
-  @ApiProperty()
-  category: string;
-  @ApiProperty()
-  plugin: string;
-  @ApiProperty()
-  name: string;
-  @ApiProperty()
-  cron: string;
-  @ApiProperty()
-  credentials: Credentials;
-  @ApiProperty()
-  client_id: string;
-  @ApiProperty()
-  created_at: string;
-  @ApiProperty()
-  updated_at: string;
-}
+export class CreateInputReq extends OmitType(Input, [
+  'id',
+  'created_at',
+  'updated_at',
+]) {}

src/modules/inputs/dtos/old_interfaces.ts

@@ -1,3 +1,5 @@
+import { Info } from 'protospack/dist/lib/interfaces';
+
 interface Values {
   jdbc_user: string;
   jdbc_password: string;
@@ -9,30 +11,6 @@ interface Values {
   schema: string;
 }
 
-interface Cron {
-  hours: string[];
-  hour_interval: boolean;
-  hour_resourse: boolean;
-  hour_resourse_value: number;
-  month_day: string[];
-  month_day_interval: boolean;
-  month_day_resourse: boolean;
-  month_day_resourse_value: number;
-  month: string[];
-  month_interval: boolean;
-  month_resourse: boolean;
-  month_resourse_value: number;
-  week_days: string[];
-  week_days_interval: boolean;
-  week_days_resourse: boolean;
-  week_days_resourse_value: number;
-}
-
-export interface Info {
-  costumer_id: string;
-  user_id: string;
-}
-
 export interface ICreateInputRequest {
   cron: string;
   name: string;
@@ -54,6 +32,7 @@ export interface UpdateInputRequest {
   values: Values;
   operation: string;
   info: Info;
+  tables: any[];
 }
 
 export interface ITestConnectionRequest {

src/modules/inputs/inputs-client.config.ts

@@ -0,0 +1,36 @@
+import { Input } from '@dadosfera/protospack-v2';
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientProviderOptions,
+  Transport,
+  type GrpcOptions,
+} from '@nestjs/microservices';
+
+const isLocalConnection = !!process.env.INFACTORY_URL?.includes('0.0.0.0');
+export class InputsGrpcClient {
+  public readonly name = 'InputsGrpcClient';
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.INFACTORY_URL,
+      package: [
+        Input.ProtoPackages.WritePackage,
+        Input.ProtoPackages.ReadPackage,
+      ],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [
+        Input.ProtoPaths.WriteFilePath,
+        Input.ProtoPaths.ReadFilePath,
+      ],
+      loader: {
+        keepCase: true,
+        enums: String,
+        defaults: false,
+      },
+    },
+  };
+  providerOptions: ClientProviderOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/inputs/inputs.controller.ts

@@ -3,156 +3,162 @@ import {
   Controller,
   Delete,
   Get,
+  Inject,
   Param,
   Patch,
   Post,
+  UseFilters,
 } from '@nestjs/common';
 import { InputsService } from './inputs.service';
-import { InputsClientService } from 'src/clients/inputs/client.service';
-import { UpdateInputRequest } from 'src/clients/inputs/interfaces';
-import { Permissions } from '../../authentication/permissions.enum';
-import { AuthenticateCondition } from 'src/authentication/authentication.decorator';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { PERMISSIONS_GROUPS } from '../../authentication/permissions.enum';
+import { AuthenticateCondition } from 'src/decorators/authentication.decorator';
 import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
 import {
   CreateInputReq,
   GetAvailableEntitiesReq,
   GetAvailableEntitiesRes,
   Input,
-  TestConnectionGetColumnsReq,
-  TestConnectionGetColumnsRes,
-  TestConnectionReq,
-  TestConnectionRes,
 } from './dtos/input.model';
+import { UpdateInputRequest } from './dtos/old_interfaces';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import { Info } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/entities';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
+import { ApiInternalOnlyEndpoint } from 'src/decorators/swagger.decorator';
 
-@ApiTags('inputs')
+@ApiTags('Inputs')
 @Controller('inputs')
 @AuthenticateCondition((req, user) => {
-  let action;
-
   switch (req.method) {
     case 'POST':
-      action = 'CREATE';
-      break;
-
     case 'PUT':
-      action = 'UPDATE';
-      break;
-
     case 'PATCH':
-      action = 'UPDATE_PARTIAL';
-      break;
+      return (
+        user.permissions.includes(
+          PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE.seqid,
+        ) ||
+        user.permissions.includes(
+          PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE.seqid,
+        )
+      );
 
     default:
-      action = req.method;
+      return (
+        user.permissions.includes(
+          PERMISSIONS_GROUPS.PIPELINE.permissions.CREATE.seqid,
+        ) ||
+        user.permissions.includes(
+          PERMISSIONS_GROUPS.PIPELINE.permissions.UPDATE.seqid,
+        ) ||
+        user.permissions.includes(
+          PERMISSIONS_GROUPS.PIPELINE.permissions.GET.seqid,
+        )
+      );
   }
-
-  if (
-    `${req.method} ${req.route.path}` ===
-    'GET /inputs/available-entities/:plugin'
-  ) {
-    action = 'GET_ENTITIES';
-  }
-
-  return user.permissions.includes(Permissions.INPUT[action].seqid);
 })
+@UseFilters(new GrpcToHttpExceptionFilter())
 export class InputsController {
-  inputService: InputsService;
-  constructor(private inputsClientService: InputsClientService) {
-    this.inputService = new InputsService(this.inputsClientService);
+  logger: DadosferaLogger;
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    private inputService: InputsService,
+  ) {
+    this.logger = dadosferaLogger.logger;
   }
 
+  @ApiInternalOnlyEndpoint()
   @Get('available-entities/:plugin')
   @ApiOkResponse({ type: GetAvailableEntitiesRes })
   async getAvailableEntities(
-    @Body() body,
     @Param() params: GetAvailableEntitiesReq,
+    @User() user: RequestUser,
   ) {
-    const { info } = body;
     const { plugin } = params;
-    return await this.inputService.getAvailableEntities({ info, plugin });
-  }
-
-  @Post('/test-connection')
-  @ApiOkResponse({ type: TestConnectionRes })
-  async testConnection(@Body() data: TestConnectionReq) {
-    console.log(`/test-connection`, 'ON TEST CONNECTION ROUTE');
-
-    const response = await this.inputService.testConnection(data);
-
-    return response;
-  }
-
-  @Post('/test-connection/get-columns')
-  @ApiOkResponse({ type: TestConnectionGetColumnsRes })
-  async getColumns(@Body() data: TestConnectionGetColumnsReq) {
-    console.log(
-      `/test-connection/get-columns`,
-      'ON TEST CONNECTION GET COLUMNS ROUTE',
-    );
-
-    const response = await this.inputService.getColumns(data);
-
-    return response;
+    const availableEntities = await this.inputService.getAvailableEntities({
+      info: {
+        customer: user.customer_name,
+        customer_id: user.customer_id,
+        user_id: user.user_id,
+      },
+      plugin,
+    });
+    return availableEntities;
   }
 
   @Post()
   @ApiOkResponse({ type: Input })
-  async create(@Body() createInputDto: CreateInputReq) {
-    console.log(`/input`, 'ON CREATE ROUTE');
+  async create(@Body() body: CreateInputReq, @User() user: RequestUser) {
+    const info: Info = {
+      user_id: user.user_id,
+      customer: user.customer_name,
+      customer_id: user.customer_id,
+    };
+    this.logger.info(`/input - ON CREATE ROUTE`, {
+      user: info.user_id,
+      customer: info.customer,
+    });
 
-    const response = await this.inputService.create(createInputDto);
-
-    return response;
-  }
-
-  @Post(':id')
-  @ApiOkResponse({ type: Input })
-  async reCreate(@Param('id') id: string, @Body() input: CreateInputReq) {
-    if (!input.id) input.id = id;
-    console.log(`POST /${input.id}`, 'ON RECREATE ROUTE');
-
-    const response = await this.inputService.reCreate(input);
+    const response = await this.inputService.create({ body, info });
 
     return response;
   }
 
+  @ApiInternalOnlyEndpoint()
   @Get()
-  async findAll(@Body() body) {
-    console.log(`/input`, 'ON FIND ALL ROUTE');
-
-    const response = await this.inputService.findAll(body);
+  async findAll(@User() user: RequestUser) {
+    const { user_id, customer_id, customer_name: customer } = user;
+    this.logger.info(`/input - ON FIND ALL ROUTE`, {
+      user: user.user_id,
+      customer,
+    });
+    const info: Info = {
+      customer,
+      customer_id,
+      user_id,
+    };
+    const response = await this.inputService.findAll(info);
 
     return response;
   }
 
   @Get('/:id')
-  async findOne(@Body() body, @Param() params) {
-    const { id } = params;
-    console.log(`/input/${id}`, 'ON FIND ONE ROUTE');
+  async findOne(@Body() body, @Param('id') id: string) {
+    this.logger.info(`/input/${id} - ON FIND ONE ROUTE`, {
+      user: body.info.user_id,
+      customer: body.info.customer,
+    });
 
     const response = await this.inputService.findOne({ id, ...body });
 
     return response;
   }
 
+  @ApiInternalOnlyEndpoint()
   @Patch(':id')
   async update(@Body() updateInputDto: UpdateInputRequest, @Param() params) {
     const { id } = params;
     const { info } = updateInputDto;
+    this.logger.info(`/input/${id} - ON UPDATE ROUTE`, {
+      user: info.user_id,
+      customer: info.customer_id,
+    });
     delete updateInputDto.info;
 
-    console.log(`/input/${id}`, 'ON UPDATE ROUTE');
-
     const response = await this.inputService.update(id, updateInputDto, info);
 
     return response;
   }
 
+  @ApiInternalOnlyEndpoint()
   @Delete(':id')
   async delete(@Body() data, @Param() params) {
     const { id } = params;
 
-    console.log(`/input/${id}`, 'ON DELETE ROUTE');
+    this.logger.info(`/input/${id} - ON DELETE ROUTE`, {
+      user: data.info.user_id,
+      customer: data.info.customer,
+    });
 
     const response = await this.inputService.remove({ id, ...data });
 

src/modules/inputs/inputs.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { ClientsModule } from '@nestjs/microservices';
+import { InputsGrpcClient } from './inputs-client.config';
+import { InputsController } from './inputs.controller';
+import { InputsService } from './inputs.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+
+const client = new InputsGrpcClient();
+
+@Module({
+  controllers: [InputsController],
+  providers: [InputsService, DadosferaLogger],
+  imports: [ClientsModule.register([client.providerOptions])],
+  exports: [InputsService],
+})
+export class InputsModule {}

src/modules/inputs/inputs.service.spec.ts

@@ -1,5 +0,0 @@
-describe('PipelinesGrpcServerService', () => {
-  it('should be defined', () => {
-    expect(2 + 2).toBe(4);
-  });
-});

src/modules/inputs/inputs.service.ts

@@ -1,20 +1,131 @@
-import { Body, HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { Timeout } from '@nestjs/schedule';
-import { DecodeGrpcStruct } from '@victorradael/protospack';
+import {
+  ForbiddenException,
+  HttpException,
+  HttpStatus,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
 import CronParser, { CronExpression } from 'cron-parser';
-import { InputsClientService } from 'src/clients/inputs/client.service';
-import { IIdRequest, Info } from 'src/clients/inputs/interfaces';
+import { ClientGrpc } from '@nestjs/microservices';
+import DadosferaLogger from '@dadosfera/dadosfera-logs/dist';
+import { lastValueFrom } from 'rxjs';
+import { objectCamelToSnake } from 'src/utils/CaseConverter';
+import { IIdRequest, UpdateInputRequest } from './dtos/old_interfaces';
+import { Input } from '@dadosfera/protospack-v2';
+import {
+  GetAvailableEntitiesRequest,
+  InputCreateGenericRequest,
+  InputCreateS3Request,
+  InputNewCreateRequest,
+  TestConnectionRequest,
+} from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/messages';
+import { Info } from '@dadosfera/protospack-v2/dist/lib/Input/interfaces/entities';
+import { CreateInputReq } from './dtos/input.model';
 
 @Injectable()
+
+//TODO refactor this class to remove OLD_inputClient
 export class InputsService {
-  constructor(private inputClient: InputsClientService) {}
+  logger: DadosferaLogger;
+  inputWriteService: Input.WriteService.InputWriteService;
+  inputReadService: Input.ReadService.InputReadService;
+
+  constructor(
+    @Inject(DadosferaLogger)
+    dadosferaLogger: DadosferaLogger,
+    @Inject('InputsGrpcClient') private readonly grpcClient: ClientGrpc,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  async onModuleInit() {
+    this.inputWriteService =
+      this.grpcClient.getService<Input.WriteService.InputWriteService>(
+        Input.ProtoServices.InputWriteService,
+      );
+    this.inputReadService =
+      this.grpcClient.getService<Input.ReadService.InputReadService>(
+        Input.ProtoServices.InputReadService,
+      );
+  }
+
+  OLD_inputClient = {
+    newCreate: async (createInputDto: InputNewCreateRequest) => {
+      this.logger.info('InputClientService - Create');
+
+      const input = await lastValueFrom(
+        this.inputWriteService.InputNewCreate(createInputDto),
+      );
+      objectCamelToSnake(input);
+      return input;
+    },
+    createS3Inputs: async (createInputDto: InputCreateS3Request) => {
+      this.logger.info('InputClientService - Create');
+      createInputDto;
+      const createInputResponse = await lastValueFrom(
+        this.inputWriteService.InputCreateS3(createInputDto),
+      ).catch((e) => {
+        throw new HttpException(e.details, 500);
+      });
+      this.logger.info('Done');
+      objectCamelToSnake(createInputResponse);
+      return createInputResponse;
+    },
+    update: async (updateInputDTO: UpdateInputRequest) => {
+      this.logger.info('InputClientService - Update');
+      const updateInputResponse = await lastValueFrom(
+        this.inputWriteService.InputUpdate(updateInputDTO),
+      );
+
+      return updateInputResponse;
+    },
+    testConnection: async (data: TestConnectionRequest) => {
+      this.logger.info('InputClientService - TestConnection');
+      const testConnectionResponse = await lastValueFrom(
+        this.inputReadService.NewTestConnection(data),
+      );
+
+      return testConnectionResponse;
+    },
+    getAvailableEntities: async (data) => {
+      this.logger.info('InputClientService - GetAvailableEntities');
+      data;
+      const response = await lastValueFrom(
+        this.inputReadService.GetAvailableEntities(data),
+      ).catch((err) => {
+        this.logger.info(err.details);
+        if (err.details && err.details.includes('400'))
+          throw new HttpException('Plugin inválido', HttpStatus.BAD_REQUEST);
+        throw new HttpException(err.details, HttpStatus.INTERNAL_SERVER_ERROR);
+      });
+      objectCamelToSnake(response);
+
+      return response;
+    },
+  };
+
   secondsInADay = 60 * 60 * 24;
   secondsInAnHour = 60 * 60;
 
   adjustInputPayload(payload) {
-    if (payload?.input_generic) return DecodeGrpcStruct(payload.input_generic);
-    if (!payload.input_s3 && !payload.input_jdbc) return payload;
-    return payload?.input_s3 || payload?.input_jdbc;
+    if (payload) {
+      if (payload.input_generic) {
+        const { credentials } = payload.input_generic;
+        return {
+          ...payload.input_generic,
+          credentials: credentials && JSON.parse(credentials),
+        };
+      }
+      if (payload.input_s3) return payload.input_s3;
+      if (payload.input_jdbc) return payload.input_jdbc;
+
+      const { credentials } = payload;
+      return {
+        ...payload,
+        credentials: credentials && JSON.parse(credentials),
+      };
+    }
+    return payload;
   }
   getDifferenceInSeconds(date1: Date, date2: Date) {
     const diffInMs = Math.abs(date2.getTime() - date1.getTime());
@@ -37,86 +148,61 @@ export class InputsService {
     const afterNextDate = interval.next().toDate();
     const secondsApart = this.getDifferenceInSeconds(nextDate, afterNextDate);
     if (customer_tier === 'BASIC' && secondsApart < this.secondsInADay) {
-      throw new HttpException(
+      throw new ForbiddenException(
         'Intervalo de tempo não pode ser inferior a um dia.',
-        HttpStatus.FORBIDDEN,
       );
     } else if (secondsApart < this.secondsInAnHour) {
-      throw new HttpException(
+      throw new ForbiddenException(
         'Intervalo de tempo não pode ser inferior a uma hora.',
-        HttpStatus.FORBIDDEN,
       );
     }
   }
-  async create(@Body() data) {
-    this.validateCron(data);
-    let response;
-    switch (data.plugin.toLowerCase()) {
-      case 'csv':
-      case 'json':
-      case 'parquet':
-        const { info, ...input } = data;
-        const inputPayload = this.generateInputS3Payload(input);
-        response = await this.inputClient.createS3Inputs({
-          input: inputPayload,
-          info,
-        });
-        break;
-      case 'oracle':
-      case 'mysql':
-      case 'postgresql':
-      case 'sqlserver':
-        response = await this.inputClient.newCreate(data);
-        break;
-      default:
-        response = await this.inputClient.createGeneric(data);
-        break;
-    }
-    const adjustedInput = this.adjustInputPayload(response.input);
-    return { ...response, input: adjustedInput };
+  async create(data: { body: CreateInputReq; info: Info }) {
+    // this.validateCron(data);
+    const { body, info } = data;
+
+    const inputCreateGenericRequest: InputCreateGenericRequest = {
+      input: {
+        ...body,
+      },
+      info,
+    };
+
+    const { input } = await lastValueFrom(
+      this.inputWriteService.InputCreate(inputCreateGenericRequest),
+    );
+    const adjustedInput = this.adjustInputPayload(input);
+    return { input: adjustedInput };
   }
-  async reCreate(data) {
-    const { info, cron } = data;
-    if (cron) this.validateCron({ info, cron });
-    const response = await this.inputClient.createGeneric(data);
-    const adjustedInput = this.adjustInputPayload(response.input);
-    return { ...response, input: adjustedInput };
+
+  async getAvailableEntities(data: GetAvailableEntitiesRequest) {
+    return lastValueFrom(this.inputReadService.GetAvailableEntities(data));
   }
-  async getAvailableEntities(data): Promise<{ entities: string[] }> {
-    return await this.inputClient.getAvailableEntities(data);
-  }
-  async findAll(body) {
-    try {
-      const findAllInputResponse: any = await this.inputClient.findAll(body);
-      if (findAllInputResponse?.inputs?.length) {
-        findAllInputResponse.inputs = findAllInputResponse.inputs.map((input) =>
-          this.adjustInputPayload(input),
-        );
-      }
-      return findAllInputResponse;
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
+
+  async findAll(info: Info) {
+    const { inputs } = await lastValueFrom(
+      this.inputReadService.InputFindAll({ info }),
+    );
+    if (!inputs) return { inputs: [] };
+
+    const inputsReturn = inputs.map((i) => this.adjustInputPayload(i));
+    return { inputs: inputsReturn };
   }
 
   async findOne(idRequest: IIdRequest) {
-    try {
-      const findOneInputResponse: any = await this.inputClient.findOne(
-        idRequest,
-      );
-      findOneInputResponse.input = this.adjustInputPayload(
-        findOneInputResponse.input,
-      );
-      return findOneInputResponse;
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
+    const findOneInputResponse: any = await lastValueFrom(
+      this.inputReadService.InputFindOne(idRequest),
+    );
+    findOneInputResponse.input = this.adjustInputPayload(
+      findOneInputResponse.input,
+    );
+    return findOneInputResponse;
   }
 
   async update(id: string, data, info: Info) {
     this.validateCron({ ...data, info });
     try {
-      const updateInputResponse: any = await this.inputClient.update({
+      const updateInputResponse: any = await this.OLD_inputClient.update({
         id,
         info,
         ...data,
@@ -132,21 +218,13 @@ export class InputsService {
   }
 
   async remove(idRequest: IIdRequest) {
-    try {
-      const removeInputResponse = await this.inputClient.remove(idRequest);
-
-      return removeInputResponse;
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
+    return lastValueFrom(this.inputWriteService.InputRemove(idRequest));
   }
 
-  @Timeout(60000 * 10) // Timeout set for 10 minutes
   async testConnection(data) {
     try {
-      const testConnectionInputResponse = await this.inputClient.testConnection(
-        data,
-      );
+      const testConnectionInputResponse =
+        await this.OLD_inputClient.testConnection(data);
 
       return testConnectionInputResponse;
     } catch (err) {
@@ -154,17 +232,6 @@ export class InputsService {
     }
   }
 
-  async getColumns(data) {
-    try {
-      const testConnectionGetColumnsResponse =
-        await this.inputClient.getColumns(data);
-
-      return testConnectionGetColumnsResponse;
-    } catch (err) {
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
-  }
-
   generateInputS3Payload(payload) {
     const { credentials, plugin, cron } = payload;
     if (!credentials) return payload;

src/modules/mixpanel/mixpanel.controller.ts

@@ -0,0 +1,93 @@
+import { Body, Controller, Inject, Param, Post } from '@nestjs/common';
+import { init } from 'mixpanel';
+import { Authenticated } from 'src/decorators/authentication.decorator';
+import { ApiInternalOnlyController } from 'src/decorators/swagger.decorator';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+
+@ApiInternalOnlyController()
+@Authenticated()
+@Controller('trackEvent')
+export class MixpanelController {
+  constructor(
+    @Inject('MIXPANEL_TOKEN')
+    private readonly mixpanelToken: string,
+  ) {}
+  @Post(':id')
+  async trackEvent(@Param('id') id, @Body() body, @User() user: RequestUser) {
+    delete body.info;
+    const mixpanel = init(this.mixpanelToken);
+
+    const separator = user.username.includes('-') ? '-' : '.';
+    const removeValues = [
+      '.dadosferatech.dadosfera',
+      '.demo.dadosfera',
+      '.dadosferademo',
+      '.dadosferarh.dadosfera',
+      '.dadosferatech.dadosfera2',
+      '.dadosferatech.dadosfera',
+      '.dadosfera.fin',
+      '.dadosferafin.dadosfera',
+      '.praxio.dadosfera',
+      '.dadosfera.tech',
+      '.treinamentos@dadosfera.ai',
+      '.dadosfera2',
+      '.treinamentosfera',
+      '.dadosfera',
+    ];
+
+    let username = user.username;
+
+    removeValues.forEach((value) => {
+      username = username.replace(value, '');
+    });
+
+    username = username.split('@')?.[0];
+    username = username.split('+')?.[0];
+
+    let firstName = username
+      .substring(0, username.indexOf(separator))
+      .replace('dadosfera', '');
+    let lastName = username
+      .substring(username.lastIndexOf(separator) + 1)
+      .replace('dadosfera', '');
+
+    if (!firstName) {
+      firstName = lastName;
+      lastName = '';
+    }
+
+    firstName = this.capitalize(firstName);
+    lastName = this.capitalize(lastName);
+
+    await mixpanel.people.set(user.username, {
+      $first_name: firstName,
+      $last_name: lastName,
+      $name: this.getFullName(firstName, lastName),
+      $email: user.username.includes('@')
+        ? user.username
+        : user.username + '@dadosfera.ai',
+      customer_name: user.customer_name,
+    });
+
+    await mixpanel.track(id, {
+      distinct_id: user.username,
+      customer: user.customer_name,
+      env: process.env.ENV,
+      ...body,
+    });
+
+    return { id, body, user: user.username };
+  }
+
+  capitalize(sentence: string): string {
+    if (!sentence) {
+      return '';
+    }
+
+    return sentence[0].toUpperCase() + sentence.substring(1);
+  }
+
+  getFullName(firstName: string, lastName: string) {
+    return `${firstName}${lastName ? ' ' + lastName : ''}`;
+  }
+}

src/modules/mixpanel/mixpanel.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { getSecretFromSecretsManager } from 'src/utils/SecretManager';
+import { MixpanelController } from './mixpanel.controller';
+
+@Module({
+  controllers: [MixpanelController],
+  providers: [
+    {
+      provide: 'MIXPANEL_TOKEN',
+      useValue: getSecretFromSecretsManager(
+        `${process.env.ENV}/root/mixpanel_token`,
+      ),
+    },
+  ],
+})
+export class MixpanelModule {}

src/modules/network-config/dto/network-config.ts

@@ -0,0 +1,172 @@
+import {
+  NetworkConfigEntity,
+  NetworkConfigToCatalog,
+} from '@dadosfera/protospack-v2/dist/lib/NetworkConfig/interfaces/entities';
+import {
+  ApiProperty,
+  ApiPropertyOptional,
+  OmitType,
+  PickType,
+} from '@nestjs/swagger';
+
+export enum NetworkConfigTypesEnum {
+  vpn = 'vpn',
+}
+export enum NetworkConfigPluginsEnum {
+  openvpn = 'openvpn',
+}
+export interface ConnectionsApiNetworkConfig {
+  config_id: string;
+  created_at: string;
+  credentials: {
+    CERTIFICATE_FILE: string;
+    OVPN_CREDENTIALS: string;
+    TLS_AUTH_FILE: string;
+    OVPN_FILE: string;
+  };
+  customer_name: string;
+  description: string;
+  name: string;
+  plugin: string;
+  secret_id: string;
+  sensitive_fields: string[];
+  type: string;
+  updated_at: string;
+}
+export class NetworkConfigDto implements NetworkConfigEntity {
+  @ApiProperty()
+  id: string;
+  @ApiProperty()
+  created_at: string;
+  @ApiProperty()
+  updated_at: string;
+  @ApiProperty()
+  customer_name: string;
+  @ApiProperty()
+  customer_id: string;
+  @ApiProperty()
+  properties: any;
+  @ApiProperty()
+  user_id: string;
+  @ApiProperty()
+  keywords: string;
+  @ApiProperty()
+  tags: string;
+
+  @ApiProperty()
+  network_type_id: string;
+  @ApiProperty()
+  network_type_name: string;
+  @ApiProperty({ enum: NetworkConfigTypesEnum })
+  type: string;
+  @ApiProperty({ enum: NetworkConfigPluginsEnum })
+  plugin: string;
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  description: string;
+}
+
+export class CreateNetworkConfigReq extends PickType(NetworkConfigDto, [
+  'network_type_id',
+  'network_type_name',
+  'name',
+  'description',
+]) {
+  @ApiProperty({ format: 'binary' })
+  ovpn_file: string;
+}
+
+export class NetworkConfigOpenVpnProperties {
+  @ApiProperty({ enum: NetworkConfigPluginsEnum })
+  plugin: NetworkConfigPluginsEnum;
+  @ApiProperty()
+  OVPN_FILE: string;
+  @ApiPropertyOptional()
+  CERTIFICATE_FILE?: string;
+  @ApiPropertyOptional()
+  OVPN_CREDENTIALS?: string;
+  @ApiPropertyOptional()
+  TLS_AUTH_FILE?: string;
+}
+
+export class NetworkConfigToCatalogDto implements NetworkConfigToCatalog {
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  customer_id: string;
+
+  @ApiProperty()
+  plugin: string;
+
+  @ApiProperty()
+  type: string;
+
+  @ApiProperty()
+  name: string;
+
+  @ApiProperty()
+  description: string;
+
+  @ApiProperty()
+  created_at: string;
+
+  @ApiProperty()
+  updated_at: string;
+
+  @ApiProperty()
+  network_type_id: string;
+
+  @ApiProperty()
+  network_type_name: string;
+}
+export class FindAllNetworkConfigsRes {
+  @ApiProperty({ type: [NetworkConfigToCatalogDto] })
+  network_configs: NetworkConfigToCatalogDto[];
+
+  @ApiProperty()
+  message: string;
+}
+
+export class FindNetworkConfigByidRes {
+  @ApiProperty()
+  network_config: NetworkConfigToCatalogDto;
+}
+
+export class FindNetworkConfigByidDetails extends PickType(NetworkConfigDto, [
+  'id',
+  'name',
+  'description',
+  'type',
+  'network_type_id',
+  'customer_name',
+]) {
+  @ApiProperty()
+  properties: NetworkConfigOpenVpnProperties | string;
+}
+export class FindNetworkConfigByidDetailsRes {
+  @ApiProperty()
+  network_config: FindNetworkConfigByidDetails;
+}
+
+export class CreateNetworkConfigRes {
+  @ApiProperty()
+  network_config: NetworkConfigToCatalogDto;
+}
+
+export class UpdateNetworkConfigReq {
+  @ApiProperty()
+  name: string;
+  @ApiProperty()
+  description: string;
+}
+export class UpdateNetworkConfigRes {
+  @ApiProperty()
+  network_config: NetworkConfigToCatalogDto;
+}
+
+export class DeleteNetworkConfigRes {
+  @ApiProperty()
+  message: string;
+}

src/modules/network-config/network-config-client.config.ts

@@ -0,0 +1,39 @@
+import { credentials } from '@grpc/grpc-js';
+import {
+  ClientProviderOptions,
+  GrpcOptions,
+  Transport,
+} from '@nestjs/microservices';
+import { NetworkConfig } from '@dadosfera/protospack-v2';
+
+const isLocalConnection = !!process.env.INFACTORY_URL?.includes('0.0.0.0');
+
+export class NetworkConfigGrpcClient {
+  public name = 'NetworkConfigGrpcClient';
+
+  private config: GrpcOptions = {
+    transport: Transport.GRPC,
+    options: {
+      url: process.env.INFACTORY_URL,
+      package: [
+        NetworkConfig.ProtoPackages.ReadPackage,
+        NetworkConfig.ProtoPackages.WritePackage,
+      ],
+      credentials: isLocalConnection ? undefined : credentials.createSsl(),
+      protoPath: [
+        NetworkConfig.ProtoPaths.ReadFilePath,
+        NetworkConfig.ProtoPaths.WriteFilePath,
+      ],
+      loader: {
+        keepCase: true,
+        enums: String,
+        objects: true,
+        arrays: true,
+      },
+    },
+  };
+  providerOptions: ClientProviderOptions = {
+    name: this.name,
+    ...this.config,
+  };
+}

src/modules/network-config/network-config.controller.ts

@@ -0,0 +1,151 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Post,
+  Query,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { NetworkConfigService } from './network-config.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ApiConsumes, ApiOkResponse, ApiTags } from '@nestjs/swagger';
+import { RequestUser, User } from 'src/decorators/user.decorator';
+import {
+  CreateNetworkConfigReq,
+  CreateNetworkConfigRes,
+  FindAllNetworkConfigsRes,
+} from './dto/network-config';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum';
+import {
+  Authenticated,
+  RequireAllPermissions,
+} from 'src/decorators/authentication.decorator';
+import { Language } from 'src/decorators/language.decorator';
+import { LanguageEnum } from 'src/utils/languages.enum';
+
+const networkConfigPermissions = PERMISSIONS_GROUPS.NETWORK_CONFIG.permissions;
+@ApiTags('Network Config')
+@Authenticated()
+@Controller('network-config')
+export class NetworkConfigController {
+  logger: any;
+  constructor(
+    private networkConfigService: NetworkConfigService,
+    @Inject(DadosferaLogger) dadosferaLogger: DadosferaLogger,
+  ) {
+    this.logger = dadosferaLogger.logger;
+  }
+
+  @Get()
+  @ApiOkResponse({ type: FindAllNetworkConfigsRes })
+  async findAllNetworkConfigs(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Query() queries,
+  ) {
+    this.logger.info('GET /network-config', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+
+    const { user_id, customer_id, customer_name } = user;
+    const { search, size, page, ...filters } = queries;
+
+    return this.networkConfigService.findAllNetworkConfigs({
+      body: { search, size, page, filters },
+      info: { user_id, customer_id, customer_name, language },
+    });
+  }
+
+  @Get(':id')
+  @ApiOkResponse({ type: FindAllNetworkConfigsRes })
+  async findNetworkConfigById(
+    @User() user: RequestUser,
+    @Param('id') id: string,
+  ) {
+    this.logger.info('GET /network-config/:id', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    return this.networkConfigService.findNetworkConfigById(id);
+  }
+
+  @Get(':id/details')
+  @ApiOkResponse({ type: FindAllNetworkConfigsRes })
+  async findNetworkConfigByIdDetails(
+    @User() user: RequestUser,
+    @Language() language: LanguageEnum,
+    @Param('id') id: string,
+  ) {
+    this.logger.info('GET /network-config/:id', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+
+    return this.networkConfigService.findNetworkConfigByIdDetails(id, {
+      customer_name: user.customer_name,
+      customer_id: user.customer_id,
+      language,
+    });
+  }
+
+  @Post()
+  @ApiOkResponse({ type: CreateNetworkConfigRes })
+  @RequireAllPermissions(networkConfigPermissions.CREATE)
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(FileInterceptor('ovpn_file'))
+  async createNetworkConfigs(
+    @User() user: RequestUser,
+    @UploadedFile() file: Express.Multer.File,
+    @Body() body: CreateNetworkConfigReq,
+  ) {
+    this.logger.info('POST /network-config', {
+      user: user.user_id,
+      customer: user.customer_name,
+    });
+    const { customer_id, customer_name, user_id } = user;
+    return this.networkConfigService.createNetworkConfig(body, file, {
+      customer_name,
+      customer_id,
+      user_id,
+    });
+  }
+
+  // @Patch(':id')
+  // @ApiOkResponse({ type: UpdateNetworkConfigRes })
+  // @RequireAllPermissions(networkConfigPermissions.CREATE)
+  // async updateNetworkConfig(
+  //   @User() user: RequestUser,
+  //   @Param('id') network_config_id: string,
+  //   @Body() body: UpdateNetworkConfigReq,
+  // ) {
+  //   this.logger.info('PATCH /network-config/:id', {
+  //     user: user.user_id,
+  //     customer: user.customer_name,
+  //   });
+  //   return this.networkConfigService.updateNetworkConfig(
+  //     body,
+  //     network_config_id,
+  //   );
+  // }
+
+  // @Delete(':id')
+  // @ApiOkResponse({ type: DeleteNetworkConfigRes })
+  // async deleteNetworkConfig(
+  //   @User() user: RequestUser,
+  //   @Param('id') network_config_id: string,
+  // ) {
+  //   this.logger.info('DELETE /network-config', {
+  //     user: user.user_id,
+  //     customer: user.customer_name,
+  //   });
+  //   return this.networkConfigService.deleteNetworkConfig(network_config_id, {
+  //     customer_name: user.customer_name,
+  //     customer_id: user.customer_id,
+  //   });
+  // }
+}

src/modules/network-config/network-config.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { NetworkConfigController } from './network-config.controller';
+import { NetworkConfigService } from './network-config.service';
+import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
+import { ClientsModule } from '@nestjs/microservices';
+import { NetworkConfigGrpcClient } from './network-config-client.config';
+const client = new NetworkConfigGrpcClient();
+
+@Module({
+  controllers: [NetworkConfigController],
+  providers: [NetworkConfigService, DadosferaLogger],
+  imports: [ClientsModule.register([client.providerOptions])],
+})
+export class NetworkConfigModule {}