prostgles-types 4.0.113 → 4.0.115

package/lib/util.ts

@@ -2,20 +2,24 @@ import { AnyObject, JoinMaker, JoinPath, TS_COLUMN_DATA_TYPES } from ".";
 import { md5 } from "./md5";
 
 export function asName(str: string) {
-  if (str === null || str === undefined || !str.toString || !str.toString()) throw "Expecting a non empty string";
+  if (str === null || str === undefined || !str.toString || !str.toString())
+    throw "Expecting a non empty string";
 
   return `"${str.toString().replace(/"/g, `""`)}"`;
 }
 
-export const pickKeys = <T extends AnyObject, Include extends keyof T>(obj: T, keys: Include[] = [], onlyIfDefined = true): Pick<T, Include> => {
+export const pickKeys = <T extends AnyObject, Include extends keyof T>(
+  obj: T,
+  keys: Include[] = [],
+  onlyIfDefined = true
+): Pick<T, Include> => {
   if (!keys.length) {
     return {} as T;
   }
   if (obj && keys.length) {
     let res = {} as T;
-    keys.forEach(k => {
-      if(onlyIfDefined && obj[k] === undefined){
-
+    keys.forEach((k) => {
+      if (onlyIfDefined && obj[k] === undefined) {
       } else {
         res[k] = obj[k];
       }
@@ -24,104 +28,120 @@ export const pickKeys = <T extends AnyObject, Include extends keyof T>(obj: T, k
   }
 
   return obj;
-}
+};
 
-export function omitKeys<T extends AnyObject, Exclude extends keyof T>(obj: T, exclude: Exclude[]): Omit<T, Exclude> {
-  return pickKeys(obj, getKeys(obj).filter(k => !exclude.includes(k as any)))
+export function omitKeys<T extends AnyObject, Exclude extends keyof T>(
+  obj: T,
+  exclude: Exclude[]
+): Omit<T, Exclude> {
+  return pickKeys(
+    obj,
+    getKeys(obj).filter((k) => !exclude.includes(k as any))
+  );
 }
 
-export function filter<T extends AnyObject, ArrFilter extends Partial<T>>(array: T[], arrFilter: ArrFilter): T[] {
-  return array.filter(d => Object.entries(arrFilter).every(([k, v]) => d[k] === v))  
+export function filter<T extends AnyObject, ArrFilter extends Partial<T>>(
+  array: T[],
+  arrFilter: ArrFilter
+): T[] {
+  return array.filter((d) => Object.entries(arrFilter).every(([k, v]) => d[k] === v));
 }
-export function find<T extends AnyObject, ArrFilter extends Partial<T>>(array: T[], arrFilter: ArrFilter): T | undefined {
+export function find<T extends AnyObject, ArrFilter extends Partial<T>>(
+  array: T[],
+  arrFilter: ArrFilter
+): T | undefined {
   return filter(array, arrFilter)[0];
 }
-export function includes<Arr extends any[] | readonly any[], Elem extends Arr[number]>(array: Arr, elem: Elem): boolean {
-  return array.some(v => v === elem);
+export function includes<Arr extends any[] | readonly any[], Elem extends Arr[number]>(
+  array: Arr,
+  elem: Elem
+): boolean {
+  return array.some((v) => v === elem);
 }
 
 export function stableStringify(data: AnyObject, opts: any) {
   if (!opts) opts = {};
-  if (typeof opts === 'function') opts = { cmp: opts };
-  var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;
-
-  var cmp = opts.cmp && (function (f) {
-    return function (node: any) {
-      return function (a: any, b: any) {
-        var aobj = { key: a, value: node[a] };
-        var bobj = { key: b, value: node[b] };
-        return f(aobj, bobj);
+  if (typeof opts === "function") opts = { cmp: opts };
+  var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
+
+  var cmp =
+    opts.cmp &&
+    (function (f) {
+      return function (node: any) {
+        return function (a: any, b: any) {
+          var aobj = { key: a, value: node[a] };
+          var bobj = { key: b, value: node[b] };
+          return f(aobj, bobj);
+        };
       };
-    };
-  })(opts.cmp);
+    })(opts.cmp);
 
   var seen: any[] = [];
   return (function stringify(node) {
-    if (node && node.toJSON && typeof node.toJSON === 'function') {
+    if (node && node.toJSON && typeof node.toJSON === "function") {
       node = node.toJSON();
     }
 
     if (node === undefined) return;
-    if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';
-    if (typeof node !== 'object') return JSON.stringify(node);
+    if (typeof node == "number") return isFinite(node) ? "" + node : "null";
+    if (typeof node !== "object") return JSON.stringify(node);
 
     var i, out;
     if (Array.isArray(node)) {
-      out = '[';
+      out = "[";
       for (i = 0; i < node.length; i++) {
-        if (i) out += ',';
-        out += stringify(node[i]) || 'null';
+        if (i) out += ",";
+        out += stringify(node[i]) || "null";
       }
-      return out + ']';
+      return out + "]";
     }
 
-    if (node === null) return 'null';
+    if (node === null) return "null";
 
     if (seen.indexOf(node) !== -1) {
-      if (cycles) return JSON.stringify('__cycle__');
-      throw new TypeError('Converting circular structure to JSON');
+      if (cycles) return JSON.stringify("__cycle__");
+      throw new TypeError("Converting circular structure to JSON");
     }
 
     var seenIndex = seen.push(node) - 1;
     var keys = Object.keys(node).sort(cmp && cmp(node));
-    out = '';
+    out = "";
     for (i = 0; i < keys.length; i++) {
       var key = keys[i]!;
       var value = stringify(node[key]);
 
       if (!value) continue;
-      if (out) out += ',';
-      out += JSON.stringify(key) + ':' + value;
+      if (out) out += ",";
+      out += JSON.stringify(key) + ":" + value;
     }
     seen.splice(seenIndex, 1);
-    return '{' + out + '}';
+    return "{" + out + "}";
   })(data);
-};
-
+}
 
 export type TextPatch = {
   from: number;
   to: number;
   text: string;
   md5: string;
-}
+};
 
 export function getTextPatch(oldStr: string, newStr: string): TextPatch | string {
-
   /* Big change, no point getting diff */
   if (!oldStr || !newStr || !oldStr.trim().length || !newStr.trim().length) return newStr;
 
   /* Return no change if matching */
-  if (oldStr === newStr) return {
-    from: 0,
-    to: 0,
-    text: "",
-    md5: md5(newStr)
-  }
+  if (oldStr === newStr)
+    return {
+      from: 0,
+      to: 0,
+      text: "",
+      md5: md5(newStr),
+    };
 
   function findLastIdx(direction = 1) {
-
-    let idx = direction < 1 ? -1 : 0, found = false;
+    let idx = direction < 1 ? -1 : 0,
+      found = false;
     while (!found && Math.abs(idx) <= newStr.length) {
       const args = direction < 1 ? [idx] : [0, idx];
 
@@ -142,21 +162,22 @@ export function getTextPatch(oldStr: string, newStr: string): TextPatch | string
     from,
     to,
     text: newStr.slice(from, toNew),
-    md5: md5(newStr)
-  }
+    md5: md5(newStr),
+  };
 }
 
-
 export function unpatchText(original: string | null, patch: TextPatch): string {
-  if (!patch || typeof patch === "string") return (patch as unknown as string);
+  if (!patch || typeof patch === "string") return patch as unknown as string;
   const { from, to, text, md5: md5Hash } = patch;
   if (text === null || original === null) return text;
   let res = original.slice(0, from) + text + original.slice(to);
-  if (md5Hash && md5(res) !== md5Hash) throw "Patch text error: Could not match md5 hash: (original/result) \n" + original + "\n" + res;
+  if (md5Hash && md5(res) !== md5Hash)
+    throw (
+      "Patch text error: Could not match md5 hash: (original/result) \n" + original + "\n" + res
+    );
   return res;
 }
 
-
 /* Replication */
 export type SyncTableInfo = {
   id_fields: string[];
@@ -214,14 +235,13 @@ export type WALItemsObj = Record<string, WALItem>;
  * This allows a high rate of optimistic updates on the client
  */
 export class WAL {
-
   /**
    * Instantly merged records for prepared for update
    */
   private changed: WALItemsObj = {};
 
   /**
-   * Batch of records (removed from this.changed) that are currently being sent 
+   * Batch of records (removed from this.changed) that are currently being sent
    */
   private sending: WALItemsObj = {};
 
@@ -231,18 +251,17 @@ export class WAL {
   private sentHistory: Record<string, AnyObject> = {};
 
   private options: WALConfig;
-  private callbacks: { cb: Function, idStrs: string[] }[] = [];
+  private callbacks: { cb: Function; idStrs: string[] }[] = [];
 
   constructor(args: WALConfig) {
     this.options = { ...args };
     if (!this.options.orderBy) {
       const { synced_field, id_fields } = args;
-      this.options.orderBy = [synced_field, ...id_fields.sort()]
-        .map(fieldName => ({
-          fieldName,
-          tsDataType: fieldName === synced_field ? "number" : "string",
-          asc: true
-        }));
+      this.options.orderBy = [synced_field, ...id_fields.sort()].map((fieldName) => ({
+        fieldName,
+        tsDataType: fieldName === synced_field ? "number" : "string",
+        asc: true,
+      }));
     }
   }
 
@@ -250,27 +269,33 @@ export class WAL {
     const { orderBy } = this.options;
     if (!orderBy || !a || !b) return 0;
 
-    return orderBy.map(ob => {
-      /* TODO: add fullData to changed items + ensure orderBy is in select */
-      if (!(ob.fieldName in a) || !(ob.fieldName in b)) {
-        throw `Replication error: \n   some orderBy fields missing from data`;
-      }
-      let v1 = ob.asc ? a[ob.fieldName] : b[ob.fieldName],
-        v2 = ob.asc ? b[ob.fieldName] : a[ob.fieldName];
-
-      let vNum = +v1 - +v2,
-        vStr = v1 < v2 ? -1 : v1 == v2 ? 0 : 1;
-      return (ob.tsDataType === "number" && Number.isFinite(vNum)) ? vNum : vStr
-    }).find(v => v) || 0;
-  }
+    return (
+      orderBy
+        .map((ob) => {
+          /* TODO: add fullData to changed items + ensure orderBy is in select */
+          if (!(ob.fieldName in a) || !(ob.fieldName in b)) {
+            throw `Replication error: \n   some orderBy fields missing from data`;
+          }
+          let v1 = ob.asc ? a[ob.fieldName] : b[ob.fieldName],
+            v2 = ob.asc ? b[ob.fieldName] : a[ob.fieldName];
+
+          let vNum = +v1 - +v2,
+            vStr =
+              v1 < v2 ? -1
+              : v1 == v2 ? 0
+              : 1;
+          return ob.tsDataType === "number" && Number.isFinite(vNum) ? vNum : vStr;
+        })
+        .find((v) => v) || 0
+    );
+  };
 
   isSending(): boolean {
-
     const result = this.isOnSending || !(isEmpty(this.sending) && isEmpty(this.changed));
     if (this.options.DEBUG_MODE) {
-      console.log(this.options.id, " CHECKING isSending ->", result)
+      console.log(this.options.id, " CHECKING isSending ->", result);
     }
-    return result
+    return result;
   }
 
   /**
@@ -281,33 +306,38 @@ export class WAL {
    */
   isInHistory = (item: AnyObject): boolean => {
     if (!item) throw "Provide item";
-    const itemSyncVal = item[this.options.synced_field]
-    if (!Number.isFinite(+itemSyncVal)) throw "Provided item Synced field value is missing/invalid ";
+    const itemSyncVal = item[this.options.synced_field];
+    if (!Number.isFinite(+itemSyncVal))
+      throw "Provided item Synced field value is missing/invalid ";
 
     const existing = this.sentHistory[this.getIdStr(item)];
     const existingSyncVal = existing?.[this.options.synced_field];
     if (existing) {
-      if (!Number.isFinite(+existingSyncVal)) throw "Provided historic item Synced field value is missing/invalid";
+      if (!Number.isFinite(+existingSyncVal))
+        throw "Provided historic item Synced field value is missing/invalid";
       if (+existingSyncVal === +itemSyncVal) {
-        return true
+        return true;
       }
     }
     return false;
-  }
+  };
 
   getIdStr(d: AnyObject): string {
-    return this.options.id_fields.sort().map(key => `${d[key] || ""}`).join(".");
+    return this.options.id_fields
+      .sort()
+      .map((key) => `${d[key] || ""}`)
+      .join(".");
   }
   getIdObj(d: AnyObject): AnyObject {
     let res: AnyObject = {};
-    this.options.id_fields.sort().map(key => {
+    this.options.id_fields.sort().map((key) => {
       res[key] = d[key];
     });
     return res;
   }
   getDeltaObj(d: AnyObject): AnyObject {
     let res: AnyObject = {};
-    Object.keys(d).map(key => {
+    Object.keys(d).map((key) => {
       if (!this.options.id_fields.includes(key)) {
         res[key] = d[key];
       }
@@ -318,7 +348,7 @@ export class WAL {
   addData = (data: WALItem[]) => {
     if (isEmpty(this.changed) && this.options.onSendStart) this.options.onSendStart();
 
-    data.map(d => {
+    data.map((d) => {
       const { initial, current, delta } = { ...d };
       if (!current) throw "Expecting { current: object, initial?: object }";
       const idStr = this.getIdStr(current);
@@ -327,24 +357,31 @@ export class WAL {
       this.changed[idStr] ??= { initial, current, delta };
       this.changed[idStr]!.current = {
         ...this.changed[idStr]!.current,
-        ...current
+        ...current,
       };
       this.changed[idStr]!.delta = {
         ...this.changed[idStr]!.delta,
-        ...delta
+        ...delta,
       };
     });
     this.sendItems();
-  }
+  };
 
   isOnSending = false;
   isSendingTimeout?: ReturnType<typeof setTimeout> = undefined;
   willDeleteHistory?: ReturnType<typeof setTimeout> = undefined;
   private sendItems = async () => {
-    const { DEBUG_MODE, onSend, onSendEnd, batch_size, throttle, historyAgeSeconds = 2 } = this.options;
+    const {
+      DEBUG_MODE,
+      onSend,
+      onSendEnd,
+      batch_size,
+      throttle,
+      historyAgeSeconds = 2,
+    } = this.options;
 
     // Sending data. stop here
-    if (this.isSendingTimeout || this.sending && !isEmpty(this.sending)) return;
+    if (this.isSendingTimeout || (this.sending && !isEmpty(this.sending))) return;
 
     // Nothing to send. stop here
     if (!this.changed || isEmpty(this.changed)) return;
@@ -360,7 +397,7 @@ export class WAL {
     Object.keys(this.changed)
       .sort((a, b) => this.sort(this.changed[a]!.current, this.changed[b]!.current))
       .slice(0, batch_size)
-      .map(key => {
+      .map((key) => {
         let item = { ...this.changed[key] } as WALItem;
         this.sending[key] = { ...item };
         walBatch.push({ ...item });
@@ -370,24 +407,24 @@ export class WAL {
 
         delete this.changed[key];
       });
-    batchItems = walBatch.map(d => {
+    batchItems = walBatch.map((d) => {
       let result: AnyObject = {};
-      Object.keys(d.current).map(k => {
+      Object.keys(d.current).map((k) => {
         const oldVal = d.initial?.[k];
         const newVal = d.current[k];
         /** Send only id fields and delta */
-        if(
+        if (
           [this.options.synced_field, ...this.options.id_fields].includes(k) ||
           !areEqual(oldVal, newVal)
-        ){
+        ) {
           result[k] = newVal;
         }
-      })
+      });
       return result;
     });
 
     if (DEBUG_MODE) {
-      console.log(this.options.id, " SENDING lr->", batchItems[batchItems.length - 1])
+      console.log(this.options.id, " SENDING lr->", batchItems[batchItems.length - 1]);
     }
 
     // Throttle next data send
@@ -400,12 +437,11 @@ export class WAL {
       }, throttle);
     }
 
-
     let error: any;
     this.isOnSending = true;
     try {
       /* Deleted data should be sent normally through await db.table.delete(...) */
-      await onSend(batchItems, walBatch);//, deletedData);
+      await onSend(batchItems, walBatch); //, deletedData);
 
       /**
        * Keep history if required
@@ -414,7 +450,7 @@ export class WAL {
         this.sentHistory = {
           ...this.sentHistory,
           ...batchObj,
-        }
+        };
         /**
          * Delete history after some time
          */
@@ -427,7 +463,7 @@ export class WAL {
       }
     } catch (err) {
       error = err;
-      console.error("WAL onSend failed:", err, batchItems, walBatch)
+      console.error("WAL onSend failed:", err, batchItems, walBatch);
     }
     this.isOnSending = false;
 
@@ -435,17 +471,17 @@ export class WAL {
     if (this.callbacks.length) {
       const ids = Object.keys(this.sending);
       this.callbacks.forEach((c, i) => {
-        c.idStrs = c.idStrs.filter(id => ids.includes(id));
+        c.idStrs = c.idStrs.filter((id) => ids.includes(id));
         if (!c.idStrs.length) {
           c.cb(error);
         }
       });
-      this.callbacks = this.callbacks.filter(cb => cb.idStrs.length)
+      this.callbacks = this.callbacks.filter((cb) => cb.idStrs.length);
     }
 
     this.sending = {};
     if (DEBUG_MODE) {
-      console.log(this.options.id, " SENT lr->", batchItems[batchItems.length - 1])
+      console.log(this.options.id, " SENT lr->", batchItems[batchItems.length - 1]);
     }
     if (!isEmpty(this.changed)) {
       this.sendItems();
@@ -453,17 +489,15 @@ export class WAL {
       if (onSendEnd) onSendEnd(batchItems, walBatch, error);
     }
   };
-};
+}
 
 export function isEmpty(obj?: any): boolean {
   for (var v in obj) return false;
   return true;
 }
 
-
 /* Get nested property from an object */
 export function get(obj: any, propertyPath: string | string[]): any {
-
   let p = propertyPath,
     o = obj;
 
@@ -471,84 +505,93 @@ export function get(obj: any, propertyPath: string | string[]): any {
   if (typeof p === "string") p = p.split(".");
   return p.reduce((xs, x) => {
     if (xs && xs[x]) {
-      return xs[x]
+      return xs[x];
     } else {
       return undefined;
     }
   }, o);
 }
 
-
-export const getObjectEntries = <T extends Record<string, any>> (obj: T): [keyof T, T[keyof T]][] => {
+export const getObjectEntries = <T extends Record<string, any>>(
+  obj: T
+): [keyof T, T[keyof T]][] => {
   return Object.entries(obj) as [keyof T, T[keyof T]][];
-}
+};
 
-function areEqual(a: any, b: any){
-  if(a === b) return true;
-  if(["number", "string", "boolean"].includes(typeof a)){
+function areEqual(a: any, b: any) {
+  if (a === b) return true;
+  if (["number", "string", "boolean"].includes(typeof a)) {
     return a === b;
   }
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
-
 export function isObject(obj: any | undefined): obj is Record<string, any> {
   return Boolean(obj && typeof obj === "object" && !Array.isArray(obj));
 }
-export function isDefined<T>(v: T | undefined | void): v is T { return v !== undefined && v !== null }
+export function isDefined<T>(v: T | undefined | void): v is T {
+  return v !== undefined && v !== null;
+}
 
-export function getKeys<T extends AnyObject>(o: T): Array<keyof T>{
-  return Object.keys(o) as any
+export function getKeys<T extends AnyObject>(o: T): Array<keyof T> {
+  return Object.keys(o) as any;
 }
 
-export type Explode<T> = keyof T extends infer K
-  ? K extends unknown
-  ? { [I in keyof T]: I extends K ? T[I] : never }
-  : never
+export type Explode<T> =
+  keyof T extends infer K ?
+    K extends unknown ?
+      { [I in keyof T]: I extends K ? T[I] : never }
+    : never
   : never;
 export type AtMostOne<T> = Explode<Partial<T>>;
-export type AtLeastOne<T, U = {[K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U]
+export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U];
 export type ExactlyOne<T> = AtMostOne<T> & AtLeastOne<T>;
 
-
 type UnionKeys<T> = T extends T ? keyof T : never;
-type StrictUnionHelper<T, TAll> = T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+type StrictUnionHelper<T, TAll> =
+  T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
 export type StrictUnion<T> = StrictUnionHelper<T, T>;
 
 /**
  * @deprecated
  * use tryCatchV2 instead
  */
-export const tryCatch = async <T extends AnyObject>(func: () => T | Promise<T>): 
-Promise<T & { hasError?: false; error?: undefined; duration: number; } | Partial<Record<keyof T, undefined>> & { hasError: true; error: unknown; duration: number; }> => {
+export const tryCatch = async <T extends AnyObject>(
+  func: () => T | Promise<T>
+): Promise<
+  | (T & { hasError?: false; error?: undefined; duration: number })
+  | (Partial<Record<keyof T, undefined>> & { hasError: true; error: unknown; duration: number })
+> => {
   const startTime = Date.now();
   try {
     const res = await func();
     return {
       ...res,
       duration: Date.now() - startTime,
-    }
-  } catch(error){
-    return { 
+    };
+  } catch (error) {
+    return {
       error,
       hasError: true,
-      duration: Date.now() - startTime, 
+      duration: Date.now() - startTime,
     } as any;
   }
-}
+};
 
-type TryCatchResult<T> = 
-| { data: T; hasError?: false; error?: undefined; duration: number; }
-| { data?: undefined; hasError: true; error: unknown; duration: number; } 
+type TryCatchResult<T> =
+  | { data: T; hasError?: false; error?: undefined; duration: number }
+  | { data?: undefined; hasError: true; error: unknown; duration: number };
 
-export const tryCatchV2 = <T,>(func: () => T | Promise<T>): T extends Promise<T>? Promise<TryCatchResult<Awaited<T>>> : TryCatchResult<T> => {
+export const tryCatchV2 = <T>(
+  func: () => T | Promise<T>
+): T extends Promise<T> ? Promise<TryCatchResult<Awaited<T>>> : TryCatchResult<T> => {
   const startTime = Date.now();
   try {
     const dataOrResult = func();
-    if(dataOrResult instanceof Promise){
+    if (dataOrResult instanceof Promise) {
       return new Promise(async (resolve, reject) => {
         const duration = Date.now() - startTime;
-        const data = await dataOrResult
+        const data = await dataOrResult;
         resolve({
           data,
           duration,
@@ -559,48 +602,47 @@ export const tryCatchV2 = <T,>(func: () => T | Promise<T>): T extends Promise<T>
       data: dataOrResult,
       duration: Date.now() - startTime,
     } as any;
-  } catch(error){
+  } catch (error) {
     console.error(error);
-    return { 
+    return {
       error,
       hasError: true,
-      duration: Date.now() - startTime, 
+      duration: Date.now() - startTime,
     } as any;
   }
-}
+};
 
 export const getJoinHandlers = (tableName: string) => {
   const getJoinFunc = (isLeft: boolean, expectsOne: boolean): JoinMaker => {
-    return (filter: Parameters<JoinMaker<AnyObject>>[0], select: Parameters<JoinMaker<AnyObject>>[1], options: Parameters<JoinMaker<AnyObject>>[2] = {}) => {
+    return (
+      filter: Parameters<JoinMaker<AnyObject>>[0],
+      select: Parameters<JoinMaker<AnyObject>>[1],
+      options: Parameters<JoinMaker<AnyObject>>[2] = {}
+    ) => {
       // return makeJoin(isLeft, filter, select, expectsOne? { ...options, limit: 1 } : options);
       return {
         [isLeft ? "$leftJoin" : "$innerJoin"]: options.path ?? tableName,
         filter,
-        ... omitKeys(options, ["path", "select"]),
+        ...omitKeys(options, ["path", "select"]),
         select,
-      }
-    }
-  }
+      };
+    };
+  };
 
   return {
     innerJoin: getJoinFunc(false, false),
     leftJoin: getJoinFunc(true, false),
     innerJoinOne: getJoinFunc(false, true),
     leftJoinOne: getJoinFunc(true, true),
-  }
-}
+  };
+};
 
 export type ParsedJoinPath = Required<JoinPath>;
 export const reverseJoinOn = (on: ParsedJoinPath["on"]) => {
-  return on.map(constraint => 
-    Object.fromEntries(
-      Object.entries(constraint)
-        .map(([left, right]) => 
-          [right, left]
-        )
-    )
+  return on.map((constraint) =>
+    Object.fromEntries(Object.entries(constraint).map(([left, right]) => [right, left]))
   );
-}
+};
 
 /**
  * result = [
@@ -609,16 +651,16 @@ export const reverseJoinOn = (on: ParsedJoinPath["on"]) => {
  * ]
  */
 export const reverseParsedPath = (parsedPath: ParsedJoinPath[], table: string) => {
-  const newPPath: ParsedJoinPath[] = [
-    { table, on: [{}] },
-    ...(parsedPath ?? [])
-  ]
-  return newPPath.map((pp, i) => {
-    const nextPath = newPPath[i+1];
-    if(!nextPath) return undefined;
-    return {
-      table: pp.table,
-      on: reverseJoinOn(nextPath.on)
-    }
-  }).filter(isDefined).reverse();
-}
+  const newPPath: ParsedJoinPath[] = [{ table, on: [{}] }, ...(parsedPath ?? [])];
+  return newPPath
+    .map((pp, i) => {
+      const nextPath = newPPath[i + 1];
+      if (!nextPath) return undefined;
+      return {
+        table: pp.table,
+        on: reverseJoinOn(nextPath.on),
+      };
+    })
+    .filter(isDefined)
+    .reverse();
+};