feat(infisical-pg): test first milestone one flow

backend-pg/src/lib/config/env.ts

@@ -8,33 +8,35 @@ const zodStrBool = z
   .optional()
   .transform((val) => val === "true");
 
-const envSchema = z.object({
-  PORT: z.coerce.number().default(4000),
-  HOST: zpStr(z.string().default("localhost")),
-  DB_CONNECTION_URI: zpStr(z.string().describe("Postgres database conntection string")),
-  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
-  SALT_ROUNDS: z.coerce.number().default(10),
-  // TODO(akhilmhdh): will be changed to one
-  ENCRYPTION_KEY: zpStr(z.string().optional()),
-  ROOT_ENCRYPTION_KEY: zpStr(z.string().optional()),
-  HTTPS_ENABLED: zodStrBool,
-  // smtp options
-  SMTP_HOST: zpStr(z.string().optional()),
-  SMTP_SECURE: zodStrBool,
-  SMTP_PORT: z.coerce.number().default(587),
-  SMTP_USERNAME: zpStr(z.string().optional()),
-  SMTP_PASSWORD: zpStr(z.string().optional()),
-  SMTP_FROM_ADDRESS: zpStr(z.string().optional()),
-  SMTP_FROM_NAME: zpStr(z.string().optional().default("Infisical")),
-  COOKIE_SECRET_SIGN_KEY: z.string().default("g5giLbOMpaJhqEogXApkiw2ZFW5Q0jvA"),
-  SITE_URL: zpStr(z.string().optional()),
-  // jwt options
-  JWT_AUTH_SECRET: zpStr(z.string()),
-  JWT_AUTH_LIFETIME: zpStr(z.string().default("10d")),
-  JWT_SIGNUP_LIFETIME: zpStr(z.string().default("15m")),
-  JWT_REFRESH_LIFETIME: zpStr(z.string().default("90d")),
-  JWT_MFA_LIFETIME: zpStr(z.string().default("5m"))
-});
+const envSchema = z
+  .object({
+    PORT: z.coerce.number().default(4000),
+    HOST: zpStr(z.string().default("localhost")),
+    DB_CONNECTION_URI: zpStr(z.string().describe("Postgres database conntection string")),
+    NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+    SALT_ROUNDS: z.coerce.number().default(10),
+    // TODO(akhilmhdh): will be changed to one
+    ENCRYPTION_KEY: zpStr(z.string().optional()),
+    ROOT_ENCRYPTION_KEY: zpStr(z.string().optional()),
+    HTTPS_ENABLED: zodStrBool,
+    // smtp options
+    SMTP_HOST: zpStr(z.string().optional()),
+    SMTP_SECURE: zodStrBool,
+    SMTP_PORT: z.coerce.number().default(587),
+    SMTP_USERNAME: zpStr(z.string().optional()),
+    SMTP_PASSWORD: zpStr(z.string().optional()),
+    SMTP_FROM_ADDRESS: zpStr(z.string().optional()),
+    SMTP_FROM_NAME: zpStr(z.string().optional().default("Infisical")),
+    COOKIE_SECRET_SIGN_KEY: z.string().default("g5giLbOMpaJhqEogXApkiw2ZFW5Q0jvA"),
+    SITE_URL: zpStr(z.string().optional()),
+    // jwt options
+    JWT_AUTH_SECRET: zpStr(z.string()),
+    JWT_AUTH_LIFETIME: zpStr(z.string().default("10d")),
+    JWT_SIGNUP_LIFETIME: zpStr(z.string().default("15m")),
+    JWT_REFRESH_LIFETIME: zpStr(z.string().default("90d")),
+    JWT_MFA_LIFETIME: zpStr(z.string().default("5m"))
+  })
+  .transform((data) => ({ ...data, isSmtpConfigured: Boolean(data.SMTP_HOST) }));
 
 let envCfg: Readonly<z.infer<typeof envSchema>>;
 

backend-pg/src/lib/errors/index.ts

@@ -28,7 +28,7 @@ export class BadRequestError extends Error {
 
   error: unknown;
 
-  constructor({ name, error, message }: { message?: string; name: string; error: unknown }) {
+  constructor({ name, error, message }: { message?: string; name: string; error?: unknown }) {
     super(message ?? "The request is invalid");
     this.name = name;
     this.error = error;

backend-pg/src/lib/knex/index.ts

@@ -1,10 +1,108 @@
 import { Knex } from "knex";
+import { Tables } from "knex/types/tables";
+
+import { TableName } from "@app/db/schemas";
+
+import { DatabaseError } from "../errors";
 
 export const withTransaction = <K extends object>(db: Knex, dal: K) => ({
-  transaction: async <T>(cb: (tx: Knex) => T) =>
+  transaction: async <T>(cb: (tx: Knex) => Promise<T>) =>
     db.transaction(async (trx) => {
       const res = await cb(trx);
       return res;
     }),
   ...dal
 });
+
+// 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 TableName>(
+  db: Knex,
+  tableName: Tname,
+  dal?: DbOps
+) => ({
+  transaction: async <T>(cb: (tx: Knex) => Promise<T>) =>
+    db.transaction(async (trx) => {
+      const res = await cb(trx);
+      return res;
+    }),
+  findById: (id: string, tx?: Knex) => {
+    try {
+      return (tx || db)(tableName)
+        .where({ id } as any)
+        .first("*");
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find by id" });
+    }
+  },
+  findOne: async (filter: Partial<Tables[Tname]["base"]>, tx?: Knex) => {
+    try {
+      const res = await (tx || db)(tableName).where(filter).first("*");
+      return res;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find one" });
+    }
+  },
+  find: (filter: Partial<Tables[Tname]["base"]>, tx?: Knex) => {
+    try {
+      return (tx || db)(tableName).where(filter);
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find one" });
+    }
+  },
+  create: async (data: Tables[Tname]["insert"], tx?: Knex) => {
+    try {
+      const [user] = await (tx || db)(tableName).insert(data).returning("*");
+      return user;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Create" });
+    }
+  },
+  updateById: async (id: string, data: Tables[Tname]["update"], tx?: Knex) => {
+    try {
+      const [user] = await (tx || db)(tableName)
+        .where({ id } as any)
+        .update(data as any)
+        .returning("*");
+      return user;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Update by id" });
+    }
+  },
+  update: async (
+    filter: Partial<Tables[Tname]["base"]>,
+    data: Tables[Tname]["update"],
+    tx?: Knex
+  ) => {
+    try {
+      const user = await (tx || db)(tableName)
+        .where(filter)
+        .update(data as any)
+        .returning("*");
+      return user;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Update" });
+    }
+  },
+  deleteById: async (id: string, tx?: Knex) => {
+    try {
+      const [user] = await (tx || db)(tableName)
+        .where({ id } as any)
+        .delete()
+        .returning("*");
+      return user;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Delete by id" });
+    }
+  },
+  delete: async (filter: Partial<Tables[Tname]["base"]>, tx?: Knex) => {
+    try {
+      const user = await (tx || db)(tableName).where(filter).delete().returning("*");
+      return user;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Delete" });
+    }
+  },
+  ...(dal || {})
+});