feat(infisical-pg): completed secret rollback

backend-pg/src/lib/fn/array.ts

@@ -0,0 +1,18 @@
+/**
+ * Sorts an array of items into groups. The return value is a map where the keys are
+ * the group ids the given getGroupId function produced and the value is an array of
+ * each item in that group.
+ */
+export const groupBy = <T, Key extends string | number | symbol>(
+  array: readonly T[],
+  getGroupId: (item: T) => Key
+): Record<Key, T[]> =>
+  array.reduce(
+    (acc, item) => {
+      const groupId = getGroupId(item);
+      if (!acc[groupId]) acc[groupId] = [];
+      acc[groupId].push(item);
+      return acc;
+    },
+    {} as Record<Key, T[]>
+  );

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

@@ -0,0 +1,5 @@
+// Some of the functions are taken from https://github.com/rayepps/radash
+// Full credits goes to https://github.com/rayapps to those functions
+// Code taken to keep in in house and to adjust somethings for our needs
+export * from "./array";
+export * from "./object";

backend-pg/src/lib/fn/object.ts

@@ -0,0 +1,17 @@
+/**
+ * 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> => {
+  if (!obj) return {} as Pick<T, TKeys>;
+  return keys.reduce(
+    (acc, key) => {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) acc[key] = obj[key];
+      return acc;
+    },
+    {} as Pick<T, TKeys>
+  );
+};

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

@@ -16,7 +16,7 @@ export const withTransaction = <K extends object>(db: Knex, dal: K) => ({
 });
 
 export type TFindFilter<R extends {} = any> = Partial<R> & {
-  $in?: Partial<{ [K in keyof R]: R[K][] }>;
+  $in?: Partial<{ [k in keyof R]: R[k][] }>;
 };
 export const buildFindFilter =
   <R extends {} = any>({ $in, ...filter }: TFindFilter<R>) =>
@@ -30,6 +30,13 @@ export const buildFindFilter =
     return bd;
   };
 
+export type TFindOpt<R extends {} = any> = {
+  limit?: number;
+  offset?: number;
+  sort?: Array<[keyof R, "asc" | "desc"] | [keyof R, "asc" | "desc", "first" | "last"]>;
+  tx?: Knex;
+};
+
 // What is ormify
 // It is to inject typical operations like find, findOne, update, delete, create
 // This will avoid writing most common ones each time
@@ -60,9 +67,20 @@ export const ormify = <DbOps extends object, Tname extends keyof Tables>(
       throw new DatabaseError({ error, name: "Find one" });
     }
   },
-  find: async (filter: TFindFilter<Tables[Tname]["base"]>, tx?: Knex) => {
+  find: async (
+    filter: TFindFilter<Tables[Tname]["base"]>,
+    { offset, limit, sort, tx }: TFindOpt<Tables[Tname]["base"]> = {}
+  ) => {
     try {
-      const res = await (tx || db)(tableName).where(buildFindFilter(filter));
+      const query = (tx || db)(tableName).where(buildFindFilter(filter));
+      if (limit) query.limit(limit);
+      if (offset) query.offset(offset);
+      if (sort) {
+        query.orderBy(
+          sort.map(([column, order, nulls]) => ({ column: column as string, order, nulls }))
+        );
+      }
+      const res = await query;
       return res;
     } catch (error) {
       throw new DatabaseError({ error, name: "Find one" });
@@ -78,6 +96,7 @@ export const ormify = <DbOps extends object, Tname extends keyof Tables>(
   },
   insertMany: async (data: readonly Tables[Tname]["insert"][], tx?: Knex) => {
     try {
+      if (!data.length) return [];
       const res = await (tx || db)(tableName)
         .insert(data as any)
         .returning("*");

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

@@ -76,12 +76,14 @@ export const sqlNestRelationships = <
       parentLookup.add(pk);
     }
     childrenMapper.forEach(({ label, mapper, key: cKey }) => {
-      const ck = `${pk}-${label}-${el[cKey]}`;
-      if (!childLookUp.has(ck)) {
-        if (!recordsGroupedByPk[pk][label]) recordsGroupedByPk[pk][label as keyof Cm] = [] as any;
-        const val = mapper(el);
-        if (typeof val !== "undefined") recordsGroupedByPk[pk][label].push(val);
-        childLookUp.add(ck);
+      if (!recordsGroupedByPk[pk][label]) recordsGroupedByPk[pk][label as keyof Cm] = [] as any;
+      if (el[cKey] !== null && typeof el[cKey] !== "undefined") {
+        const ck = `${pk}-${label}-${el[cKey]}`;
+        if (!childLookUp.has(ck)) {
+          const val = mapper(el);
+          if (typeof val !== "undefined" && val !== null) recordsGroupedByPk[pk][label].push(val);
+          childLookUp.add(ck);
+        }
       }
     });
   });