feat: changed line length to 120

backend/src/services/secret-folder/secret-folder-dal.ts

@@ -1,12 +1,7 @@
 import { Knex } from "knex";
 
 import { TDbClient } from "@app/db";
-import {
-  TableName,
-  TProjectEnvironments,
-  TSecretFolders,
-  TSecretFoldersUpdate
-} from "@app/db/schemas";
+import { TableName, TProjectEnvironments, TSecretFolders, TSecretFoldersUpdate } from "@app/db/schemas";
 import { BadRequestError, DatabaseError } from "@app/lib/errors";
 import { groupBy, removeTrailingSlash } from "@app/lib/fn";
 import { ormify, selectAllTableCols } from "@app/lib/knex";
@@ -16,14 +11,10 @@ export const validateFolderName = (folderName: string) => {
   return validNameRegex.test(folderName);
 };
 
-const sqlFindMultipleFolderByEnvPathQuery = (
-  db: Knex,
-  query: Array<{ envId: string; secretPath: string }>
-) => {
+const sqlFindMultipleFolderByEnvPathQuery = (db: Knex, query: Array<{ envId: string; secretPath: string }>) => {
   // this is removing an trailing slash like /folder1/folder2/ -> /folder1/folder2
   const formatedQuery = query.map(({ envId, secretPath }) => {
-    const formatedPath =
-      secretPath.at(-1) === "/" && secretPath.length > 1 ? secretPath.slice(0, -1) : secretPath;
+    const formatedPath = secretPath.at(-1) === "/" && secretPath.length > 1 ? secretPath.slice(0, -1) : secretPath;
     const segments = formatedPath.split("/").filter(Boolean);
     if (segments.some((segment) => !validateFolderName(segment))) {
       throw new BadRequestError({ message: "Invalid folder name" });
@@ -73,9 +64,9 @@ const sqlFindMultipleFolderByEnvPathQuery = (
               .where((wb) =>
                 formatedQuery.map(({ secretPath }) =>
                   wb.orWhereRaw(
-                    `depth = array_position(ARRAY[${secretPath
-                      .map(() => "?")
-                      .join(",")}]::varchar[], ${TableName.SecretFolder}.name,depth)`,
+                    `depth = array_position(ARRAY[${secretPath.map(() => "?").join(",")}]::varchar[], ${
+                      TableName.SecretFolder
+                    }.name,depth)`,
                     [...secretPath]
                   )
                 )
@@ -92,15 +83,9 @@ const sqlFindMultipleFolderByEnvPathQuery = (
     .from<TSecretFolders & { depth: number; path: string }>("parent");
 };
 
-const sqlFindFolderByPathQuery = (
-  db: Knex,
-  projectId: string,
-  environment: string,
-  secretPath: string
-) => {
+const sqlFindFolderByPathQuery = (db: Knex, projectId: string, environment: string, secretPath: string) => {
   // this is removing an trailing slash like /folder1/folder2/ -> /folder1/folder2
-  const formatedPath =
-    secretPath.at(-1) === "/" && secretPath.length > 1 ? secretPath.slice(0, -1) : secretPath;
+  const formatedPath = secretPath.at(-1) === "/" && secretPath.length > 1 ? secretPath.slice(0, -1) : secretPath;
   // next goal to sanitize saw the raw sql query is safe
   // for this we ensure folder name contains only string and - nothing else
   const pathSegments = formatedPath.split("/").filter(Boolean);
@@ -121,11 +106,7 @@ const sqlFindFolderByPathQuery = (
           path: db.raw("'/'")
         })
         .from(TableName.SecretFolder)
-        .join(
-          TableName.Environment,
-          `${TableName.SecretFolder}.envId`,
-          `${TableName.Environment}.id`
-        )
+        .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
         .where({
           projectId,
           parentId: null
@@ -156,11 +137,7 @@ const sqlFindFolderByPathQuery = (
         );
     })
     .from<TSecretFolders & { depth: number; path: string }>("parent")
-    .leftJoin<TProjectEnvironments>(
-      TableName.Environment,
-      `${TableName.Environment}.id`,
-      "parent.envId"
-    )
+    .leftJoin<TProjectEnvironments>(TableName.Environment, `${TableName.Environment}.id`, "parent.envId")
     .select<
       TSecretFolders & {
         depth: number;
@@ -192,16 +169,10 @@ const sqlFindSecretPathByFolderId = (db: Knex, projectId: string, folderIds: str
           // this is for root condition
           //  if the given folder id is root folder id then intial path is set as / instead of /root
           //  if not root folder the path here will be /<folder name>
-          path: db.raw(
-            `CONCAT('/', (CASE WHEN "parentId" is NULL THEN '' ELSE ${TableName.SecretFolder}.name END))`
-          ),
+          path: db.raw(`CONCAT('/', (CASE WHEN "parentId" is NULL THEN '' ELSE ${TableName.SecretFolder}.name END))`),
           child: db.raw("NULL::uuid")
         })
-        .join(
-          TableName.Environment,
-          `${TableName.SecretFolder}.envId`,
-          `${TableName.Environment}.id`
-        )
+        .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
         .where({ projectId })
         .whereIn(`${TableName.SecretFolder}.id`, folderIds)
         .union(
@@ -234,19 +205,9 @@ export const ROOT_FOLDER_NAME = "root";
 export const secretFolderDALFactory = (db: TDbClient) => {
   const secretFolderOrm = ormify(db, TableName.SecretFolder);
 
-  const findBySecretPath = async (
-    projectId: string,
-    environment: string,
-    path: string,
-    tx?: Knex
-  ) => {
+  const findBySecretPath = async (projectId: string, environment: string, path: string, tx?: Knex) => {
     try {
-      const folder = await sqlFindFolderByPathQuery(
-        tx || db,
-        projectId,
-        environment,
-        removeTrailingSlash(path)
-      )
+      const folder = await sqlFindFolderByPathQuery(tx || db, projectId, environment, removeTrailingSlash(path))
         .orderBy("depth", "desc")
         .first();
       if (folder && folder.path !== removeTrailingSlash(path)) {
@@ -263,19 +224,9 @@ export const secretFolderDALFactory = (db: TDbClient) => {
   // used in folder creation
   // even if its the original given /path1/path2
   // it will stop automatically at /path2
-  const findClosestFolder = async (
-    projectId: string,
-    environment: string,
-    path: string,
-    tx?: Knex
-  ) => {
+  const findClosestFolder = async (projectId: string, environment: string, path: string, tx?: Knex) => {
     try {
-      const folder = await sqlFindFolderByPathQuery(
-        tx || db,
-        projectId,
-        environment,
-        removeTrailingSlash(path)
-      )
+      const folder = await sqlFindFolderByPathQuery(tx || db, projectId, environment, removeTrailingSlash(path))
         .orderBy("depth", "desc")
         .first();
       if (!folder) return;
@@ -286,10 +237,7 @@ export const secretFolderDALFactory = (db: TDbClient) => {
     }
   };
 
-  const findByManySecretPath = async (
-    query: Array<{ envId: string; secretPath: string }>,
-    tx?: Knex
-  ) => {
+  const findByManySecretPath = async (query: Array<{ envId: string; secretPath: string }>, tx?: Knex) => {
     try {
       const formatedQuery = query.map(({ secretPath, envId }) => ({
         envId,
@@ -297,10 +245,7 @@ export const secretFolderDALFactory = (db: TDbClient) => {
       }));
       const folders = await sqlFindMultipleFolderByEnvPathQuery(tx || db, formatedQuery);
       return formatedQuery.map(({ envId, secretPath }) =>
-        folders.find(
-          ({ path: targetPath, envId: targetEnvId }) =>
-            targetPath === secretPath && targetEnvId === envId
-        )
+        folders.find(({ path: targetPath, envId: targetEnvId }) => targetPath === secretPath && targetEnvId === envId)
       );
     } catch (error) {
       throw new DatabaseError({ error, name: "FindByManySecretPath" });
@@ -339,11 +284,7 @@ export const secretFolderDALFactory = (db: TDbClient) => {
     try {
       const folder = await (tx || db)(TableName.SecretFolder)
         .where({ [`${TableName.SecretFolder}.id` as "id"]: id })
-        .join(
-          TableName.Environment,
-          `${TableName.SecretFolder}.envId`,
-          `${TableName.Environment}.id`
-        )
+        .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
         .select(selectAllTableCols(TableName.SecretFolder))
         .select(
           db.ref("id").withSchema(TableName.Environment).as("envId"),