feat: changed line length to 120

backend/src/lib/casl/index.ts

@@ -24,9 +24,7 @@ export const conditionsMatcher = buildMongoQueryMatcher({ $glob }, { glob });
  * Extracts and formats permissions from a CASL Ability object or a raw permission set.
  */
 const extractPermissions = (ability: MongoAbility) =>
-  ability.rules.map(
-    (permission) => `${permission.action as string}_${permission.subject as string}`
-  );
+  ability.rules.map((permission) => `${permission.action as string}_${permission.subject as string}`);
 
 /**
  * Compares two sets of permissions to determine if the first set is at least as privileged as the second set.

backend/src/lib/config/env.ts

@@ -38,9 +38,7 @@ const envSchema = z
     // Telemetry
     TELEMETRY_ENABLED: zodStrBool.default("true"),
     POSTHOG_HOST: zpStr(z.string().optional().default("https://app.posthog.com")),
-    POSTHOG_PROJECT_API_KEY: zpStr(
-      z.string().optional().default("phc_nSin8j5q2zdhpFDI1ETmFNUIuTG4DwKVyIigrY10XiE")
-    ),
+    POSTHOG_PROJECT_API_KEY: zpStr(z.string().optional().default("phc_nSin8j5q2zdhpFDI1ETmFNUIuTG4DwKVyIigrY10XiE")),
     LOOPS_API_KEY: zpStr(z.string().optional()),
     // jwt options
     AUTH_SECRET: zpStr(z.string()).default(process.env.JWT_AUTH_SECRET), // for those still using old JWT_AUTH_SECRET

backend/src/lib/crypto/encryption.ts

@@ -20,11 +20,7 @@ export const BLOCK_SIZE_BYTES_16 = 16;
 export const decryptSymmetric = ({ ciphertext, iv, tag, key }: TDecryptSymmetricInput): string => {
   const secretKey = crypto.createSecretKey(key, "base64");
 
-  const decipher = crypto.createDecipheriv(
-    SecretEncryptionAlgo.AES_256_GCM,
-    secretKey,
-    Buffer.from(iv, "base64")
-  );
+  const decipher = crypto.createDecipheriv(SecretEncryptionAlgo.AES_256_GCM, secretKey, Buffer.from(iv, "base64"));
   decipher.setAuthTag(Buffer.from(tag, "base64"));
   let cleartext = decipher.update(ciphertext, "base64", "utf8");
   cleartext += decipher.final("utf8");
@@ -62,17 +58,8 @@ export const encryptSymmetric128BitHexKeyUTF8 = (plaintext: string, key: string)
   };
 };
 
-export const decryptSymmetric128BitHexKeyUTF8 = ({
-  ciphertext,
-  iv,
-  tag,
-  key
-}: TDecryptSymmetricInput): string => {
-  const decipher = crypto.createDecipheriv(
-    SecretEncryptionAlgo.AES_256_GCM,
-    key,
-    Buffer.from(iv, "base64")
-  );
+export const decryptSymmetric128BitHexKeyUTF8 = ({ ciphertext, iv, tag, key }: TDecryptSymmetricInput): string => {
+  const decipher = crypto.createDecipheriv(SecretEncryptionAlgo.AES_256_GCM, key, Buffer.from(iv, "base64"));
 
   decipher.setAuthTag(Buffer.from(tag, "base64"));
 
@@ -104,12 +91,7 @@ export type TDecryptAsymmetricInput = {
   privateKey: string;
 };
 
-export const decryptAsymmetric = ({
-  ciphertext,
-  nonce,
-  publicKey,
-  privateKey
-}: TDecryptAsymmetricInput) => {
+export const decryptAsymmetric = ({ ciphertext, nonce, publicKey, privateKey }: TDecryptAsymmetricInput) => {
   const plaintext: Uint8Array | null = nacl.box.open(
     naclUtils.decodeBase64(ciphertext),
     naclUtils.decodeBase64(nonce),

backend/src/lib/fn/array.ts

@@ -23,10 +23,7 @@ export const groupBy = <T, Key extends string | number | symbol>(
  * to convert each item in the list to a comparable identity
  * value
  */
-export const unique = <T, K extends string | number | symbol>(
-  array: readonly T[],
-  toKey?: (item: T) => K
-): T[] => {
+export const unique = <T, K extends string | number | symbol>(array: readonly T[], toKey?: (item: T) => K): T[] => {
   const valueMap = array.reduce(
     (acc, item) => {
       const key = toKey ? toKey(item) : (item as unknown as string | number | symbol);

backend/src/lib/fn/object.ts

@@ -2,10 +2,7 @@
  * Pick a list of properties from an object
  * into a new object
  */
-export const pick = <T extends object, TKeys extends keyof T>(
-  obj: T,
-  keys: TKeys[]
-): Pick<T, TKeys> => {
+export const pick = <T extends object, TKeys extends keyof T>(obj: T, keys: TKeys[]): Pick<T, TKeys> => {
   if (!obj) return {} as Pick<T, TKeys>;
   return keys.reduce(
     (acc, key) => {

backend/src/lib/ip/index.ts

@@ -111,13 +111,7 @@ export type TIp = {
 /**
  * Validates the IP address [ipAddress] against the trusted IPs [trustedIps].
  */
-export const checkIPAgainstBlocklist = ({
-  ipAddress,
-  trustedIps
-}: {
-  ipAddress: string;
-  trustedIps: TIp[];
-}) => {
+export const checkIPAgainstBlocklist = ({ ipAddress, trustedIps }: { ipAddress: string; trustedIps: TIp[] }) => {
   const blockList = new net.BlockList();
 
   for (const trustedIp of trustedIps) {

backend/src/lib/knex/index.ts

@@ -41,11 +41,7 @@ export type TFindOpt<R extends object = object> = {
 // What is ormify
 // It is to inject typical operations like find, findOne, update, delete, create
 // This will avoid writing most common ones each time
-export const ormify = <DbOps extends object, Tname extends keyof Tables>(
-  db: Knex,
-  tableName: Tname,
-  dal?: DbOps
-) => ({
+export const ormify = <DbOps extends object, Tname extends keyof Tables>(db: Knex, tableName: Tname, dal?: DbOps) => ({
   transaction: async <T>(cb: (tx: Knex) => Promise<T>) =>
     db.transaction(async (trx) => {
       const res = await cb(trx);
@@ -78,9 +74,7 @@ export const ormify = <DbOps extends object, Tname extends keyof Tables>(
       if (limit) void query.limit(limit);
       if (offset) void query.offset(offset);
       if (sort) {
-        void query.orderBy(
-          sort.map(([column, order, nulls]) => ({ column: column as string, order, nulls }))
-        );
+        void query.orderBy(sort.map(([column, order, nulls]) => ({ column: column as string, order, nulls })));
       }
       const res = await query;
       return res;
@@ -120,11 +114,7 @@ export const ormify = <DbOps extends object, Tname extends keyof Tables>(
       throw new DatabaseError({ error, name: "Update by id" });
     }
   },
-  update: async (
-    filter: TFindFilter<Tables[Tname]["base"]>,
-    data: Tables[Tname]["update"],
-    tx?: Knex
-  ) => {
+  update: async (filter: TFindFilter<Tables[Tname]["base"]>, data: Tables[Tname]["update"], tx?: Knex) => {
     try {
       const res = await (tx || db)(tableName)
         .where(buildFindFilter(filter))
@@ -148,10 +138,7 @@ export const ormify = <DbOps extends object, Tname extends keyof Tables>(
   },
   delete: async (filter: TFindFilter<Tables[Tname]["base"]>, tx?: Knex) => {
     try {
-      const res = await (tx || db)(tableName)
-        .where(buildFindFilter(filter))
-        .delete()
-        .returning("*");
+      const res = await (tx || db)(tableName).where(buildFindFilter(filter)).delete().returning("*");
       return res;
     } catch (error) {
       throw new DatabaseError({ error, name: "Delete" });

backend/src/lib/zod/index.ts

@@ -1,10 +1,7 @@
 import { z, ZodTypeAny } from "zod";
 
 // this is a patched zod string to remove empty string to undefined
-export const zpStr = <T extends ZodTypeAny>(
-  schema: T,
-  opt: { stripNull: boolean } = { stripNull: true }
-) =>
+export const zpStr = <T extends ZodTypeAny>(schema: T, opt: { stripNull: boolean } = { stripNull: true }) =>
   z.preprocess((val) => {
     if (opt.stripNull && val === null) return undefined;
     if (typeof val !== "string") return val;