feat: changed backend-pg to backend

backend/src/lib/fn/array.ts

@@ -0,0 +1,40 @@
+/**
+ * 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[]>
+  );
+
+/**
+ * Given a list of items returns a new list with only
+ * unique items. Accepts an optional identity function
+ * 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[] => {
+  const valueMap = array.reduce(
+    (acc, item) => {
+      const key = toKey ? toKey(item) : (item as any as string | number | symbol);
+      if (acc[key]) return acc;
+      acc[key] = item;
+      return acc;
+    },
+    {} as Record<string | number | symbol, T>
+  );
+  return Object.values(valueMap);
+};

backend/src/lib/fn/index.ts

@@ -0,0 +1,6 @@
+// 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";
+export * from "./string";

backend/src/lib/fn/object.ts

@@ -0,0 +1,37 @@
+/**
+ * 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>
+  );
+};
+
+/**
+ * Removes (shakes out) undefined entries from an
+ * object. Optional second argument shakes out values
+ * by custom evaluation.
+ */
+export const shake = <RemovedKeys extends string, T = {}>(
+  obj: T,
+  filter: (value: any) => boolean = (x) => x === undefined || x === null
+): Omit<T, RemovedKeys> => {
+  if (!obj) return {} as T;
+  const keys = Object.keys(obj) as (keyof T)[];
+  return keys.reduce((acc, key) => {
+    if (filter(obj[key])) {
+      return acc;
+    }
+    acc[key] = obj[key];
+    return acc;
+  }, {} as T);
+};

backend/src/lib/fn/string.ts

@@ -0,0 +1,5 @@
+import path from "path";
+
+// given two paths irrespective of ending with / or not
+// this will return true if its equal
+export const isSamePath = async (from: string, to: string) => !path.relative(from, to);