prostgles-server 3.0.154 → 4.0.1

package/lib/PubSubManager/addSub.d.ts

@@ -0,0 +1,8 @@
+import { SubscriptionChannels } from "prostgles-types";
+import { PubSubManager, SubscriptionParams } from "./PubSubManager";
+type AddSubscriptionParams = SubscriptionParams & {
+    condition: string;
+};
+export declare function addSub(this: PubSubManager, subscriptionParams: Omit<AddSubscriptionParams, "channel_name" | "parentSubParams">): Promise<SubscriptionChannels>;
+export {};
+//# sourceMappingURL=addSub.d.ts.map

package/lib/PubSubManager/addSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addSub.d.ts","sourceRoot":"","sources":["addSub.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAiC,aAAa,EAAgB,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEjH,KAAK,qBAAqB,GAAG,kBAAkB,GAAG;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAA;AAID,wBAAsB,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,kBAAkB,EAAE,IAAI,CAAC,qBAAqB,EAAE,cAAc,GAAG,iBAAiB,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAiHpK"}

package/lib/PubSubManager/addSub.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSub = void 0;
+const PubSubManager_1 = require("./PubSubManager");
+/* Must return a channel for socket */
+/* The distinct list of {table_name, condition} must have a corresponding trigger in the database */
+async function addSub(subscriptionParams) {
+    const { socket, func, table_rules, filter = {}, params = {}, condition = "", throttle = 0, //subOne = false, 
+    viewOptions, table_info, } = subscriptionParams || {};
+    const table_name = table_info.name;
+    if (!socket && !func) {
+        throw "socket AND func missing";
+    }
+    if (socket && func) {
+        throw "addSub: cannot have socket AND func";
+    }
+    let validated_throttle = subscriptionParams.throttle || 10;
+    const pubThrottle = table_rules?.subscribe?.throttle || 0;
+    if (pubThrottle && Number.isInteger(pubThrottle) && pubThrottle > 0) {
+        validated_throttle = pubThrottle;
+    }
+    if (throttle && Number.isInteger(throttle) && throttle >= pubThrottle) {
+        validated_throttle = throttle;
+    }
+    const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;
+    const result = {
+        channelName: channel_name,
+        channelNameReady: channel_name + ".ready",
+        channelNameUnsubscribe: channel_name + ".unsubscribe"
+    };
+    this.upsertSocket(socket);
+    // const upsertSub = _upsertSub.bind(this);
+    const newSub = {
+        channel_name,
+        filter,
+        func,
+        params,
+        last_throttled: 0,
+        socket,
+        table_info,
+        is_ready: true,
+        is_throttling: false,
+        socket_id: socket?.id,
+        table_rules,
+        throttle: validated_throttle,
+        triggers: [
+            {
+                table_name: table_name,
+                condition: (0, PubSubManager_1.parseCondition)(condition),
+                is_related: false,
+            }
+        ]
+    };
+    if (viewOptions) {
+        for await (const relatedTable of viewOptions.relatedTables) {
+            const relatedSub = {
+                table_name: relatedTable.tableName,
+                condition: (0, PubSubManager_1.parseCondition)(relatedTable.condition),
+                is_related: true,
+            };
+            newSub.triggers.push(relatedSub);
+            await this.addTrigger(relatedSub, viewOptions);
+        }
+    }
+    if (func) {
+        this.pushSubData(newSub);
+    }
+    else if (socket) {
+        const removeListeners = () => {
+            socket.removeAllListeners(channel_name);
+            socket.removeAllListeners(result.channelNameReady);
+            socket.removeAllListeners(result.channelNameUnsubscribe);
+        };
+        removeListeners();
+        socket.once(result.channelNameReady, () => {
+            this.pushSubData(newSub);
+        });
+        socket.once(result.channelNameUnsubscribe, (_data, cb) => {
+            const res = "ok"; // this.onSocketDisconnected({ socket, subChannel: channel_name });
+            this.subs = this.subs.filter(s => {
+                const isMatch = s.socket && s.socket.id === socket.id && s.channel_name === channel_name;
+                return !isMatch;
+            });
+            removeListeners();
+            cb(null, { res });
+        });
+    }
+    this.subs.push(newSub);
+    /** A view does not have triggers. Only related triggers */
+    if (table_info.is_view) {
+        if (!viewOptions?.relatedTables.length) {
+            throw "PubSubManager: view parent_tables missing";
+        }
+    }
+    else {
+        await this.addTrigger({
+            table_name: table_info.name,
+            condition: (0, PubSubManager_1.parseCondition)(condition),
+        });
+    }
+    return result;
+}
+exports.addSub = addSub;
+// const _upsertSub = async function(
+//   this: PubSubManager, 
+//   newSubData: {
+//     table_name: string; 
+//     condition: string; 
+//     is_ready: boolean; 
+//     channel_name: string;
+//     viewOptions: SubscriptionParams["viewOptions"];
+//   },
+//   consumer: Pick<SubscriptionParams, "channel_name" | "socket" | "func">,
+//   isReadyOverride: boolean | undefined
+// ){
+//   const { table_name, condition: _cond, is_ready = false, viewOptions } = newSubData;
+//   const { channel_name, func, socket } = consumer;
+//   const condition = parseCondition(_cond);
+//   const newSub: SubscriptionParams = {
+//       socket,
+//       table_name,
+//       filter,
+//       params,
+//       table_rules,
+//       channel_name,
+//       parentSubParams,
+//       func: func ?? undefined,
+//       socket_id: socket?.id,
+//       throttle: validated_throttle,
+//       is_throttling: null,
+//       last_throttled: 0,
+//       is_ready,
+//     };
+//   this.subs[table_name] = this.subs[table_name] ?? {};
+//   this.subs[table_name]![condition] = this.subs[table_name]![condition] ?? { subs: [] };
+//   this.subs[table_name]![condition]!.subs = this.subs[table_name]![condition]!.subs ?? [];
+//   // console.log("1034 upsertSub", this.subs)
+//   const sub_idx = this.subs[table_name]![condition]!.subs.findIndex(s =>
+//     s.channel_name === channel_name &&
+//     (
+//       socket && s.socket_id === socket.id ||
+//       func && s.func === func
+//     ) && 
+//     JSON.stringify(s.viewOptions) === JSON.stringify((subscriptionParams.viewOptions)
+//   ));
+//   if (sub_idx < 0) {
+//     this.subs[table_name]![condition]!.subs.push(newSub);
+//     if (socket) {
+//       const chnUnsub = channel_name + "unsubscribe";
+//       socket.removeAllListeners(chnUnsub);
+//       socket.once(chnUnsub, (_data: any, cb: BasicCallback) => {
+//         const res = this.onSocketDisconnected({ socket, subChannel: channel_name });
+//         cb(null, { res });
+//       });
+//     }
+//   } else {
+//     this.subs[table_name]![condition]!.subs[sub_idx] = newSub;
+//   }
+//   if (isReadyOverride ?? is_ready) {
+//     this.pushSubData(newSub);
+//   }
+// };

package/lib/PubSubManager/addSub.ts

@@ -0,0 +1,186 @@
+import { SubscriptionChannels } from "prostgles-types";
+import { BasicCallback, parseCondition, PubSubManager, Subscription, SubscriptionParams } from "./PubSubManager";
+
+type AddSubscriptionParams = SubscriptionParams & {
+  condition: string;
+}
+
+/* Must return a channel for socket */
+/* The distinct list of {table_name, condition} must have a corresponding trigger in the database */
+export async function addSub(this: PubSubManager, subscriptionParams: Omit<AddSubscriptionParams, "channel_name" | "parentSubParams">): Promise<SubscriptionChannels> {
+  const {
+    socket, func, table_rules, filter = {},
+    params = {}, condition = "", throttle = 0,  //subOne = false, 
+    viewOptions, table_info,
+  } = subscriptionParams || {};
+  const table_name = table_info.name;
+
+  if (!socket && !func) {
+    throw "socket AND func missing";
+  }
+  if (socket && func) {
+    throw "addSub: cannot have socket AND func";
+  }
+
+  let validated_throttle = subscriptionParams.throttle || 10;
+  const pubThrottle = table_rules?.subscribe?.throttle || 0;
+  if (pubThrottle && Number.isInteger(pubThrottle) && pubThrottle > 0) {
+    validated_throttle = pubThrottle;
+  }
+  if (throttle && Number.isInteger(throttle) && throttle >= pubThrottle) {
+    validated_throttle = throttle;
+  }
+
+  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;
+  const result: SubscriptionChannels = {
+    channelName: channel_name,
+    channelNameReady: channel_name + ".ready",
+    channelNameUnsubscribe: channel_name + ".unsubscribe"
+  }
+
+  this.upsertSocket(socket);
+
+  // const upsertSub = _upsertSub.bind(this);
+
+  const newSub: Subscription = {
+    channel_name,
+    filter,
+    func,
+    params,
+    last_throttled: 0,
+    socket,
+    table_info,
+    is_ready: true,
+    is_throttling: false,
+    socket_id: socket?.id,
+    table_rules,
+    throttle: validated_throttle,
+    triggers: [
+      {
+        table_name: table_name,
+        condition: parseCondition(condition),
+        is_related: false,
+      }
+    ]
+  }
+
+  if(viewOptions){
+    for await(const relatedTable of viewOptions.relatedTables){
+      const relatedSub = {
+        table_name: relatedTable.tableName,
+        condition: parseCondition(relatedTable.condition),
+        is_related: true,
+      } as const;
+
+      newSub.triggers.push(relatedSub)
+  
+      await this.addTrigger(relatedSub, viewOptions);      
+    }
+
+  }
+
+  if(func){
+    this.pushSubData(newSub);
+
+  } else if (socket) {
+    const removeListeners = () => {
+      socket.removeAllListeners(channel_name);
+      socket.removeAllListeners(result.channelNameReady);
+      socket.removeAllListeners(result.channelNameUnsubscribe);
+    }
+    removeListeners();
+
+    socket.once(result.channelNameReady, () => {
+      this.pushSubData(newSub);
+    });
+    socket.once(result.channelNameUnsubscribe, (_data: any, cb: BasicCallback) => {
+      const res = "ok";// this.onSocketDisconnected({ socket, subChannel: channel_name });
+      this.subs = this.subs.filter(s => {
+        const isMatch = s.socket && s.socket.id === socket.id && s.channel_name === channel_name;
+        return !isMatch;
+      });
+      removeListeners();
+      cb(null, { res });
+    });
+  }
+
+  this.subs.push(newSub);
+
+  /** A view does not have triggers. Only related triggers */
+  if (table_info.is_view) {
+    if (!viewOptions?.relatedTables.length) {
+      throw "PubSubManager: view parent_tables missing";
+    }
+
+  } else {
+    await this.addTrigger({
+      table_name: table_info.name,
+      condition: parseCondition(condition),
+    });
+  }
+
+  return result;
+}
+
+// const _upsertSub = async function(
+//   this: PubSubManager, 
+//   newSubData: {
+//     table_name: string; 
+//     condition: string; 
+//     is_ready: boolean; 
+//     channel_name: string;
+//     viewOptions: SubscriptionParams["viewOptions"];
+//   },
+//   consumer: Pick<SubscriptionParams, "channel_name" | "socket" | "func">,
+//   isReadyOverride: boolean | undefined
+// ){
+//   const { table_name, condition: _cond, is_ready = false, viewOptions } = newSubData;
+//   const { channel_name, func, socket } = consumer;
+//   const condition = parseCondition(_cond);
+//   const newSub: SubscriptionParams = {
+//       socket,
+//       table_name,
+//       filter,
+//       params,
+//       table_rules,
+//       channel_name,
+//       parentSubParams,
+//       func: func ?? undefined,
+//       socket_id: socket?.id,
+//       throttle: validated_throttle,
+//       is_throttling: null,
+//       last_throttled: 0,
+//       is_ready,
+//     };
+
+//   this.subs[table_name] = this.subs[table_name] ?? {};
+//   this.subs[table_name]![condition] = this.subs[table_name]![condition] ?? { subs: [] };
+//   this.subs[table_name]![condition]!.subs = this.subs[table_name]![condition]!.subs ?? [];
+
+//   // console.log("1034 upsertSub", this.subs)
+//   const sub_idx = this.subs[table_name]![condition]!.subs.findIndex(s =>
+//     s.channel_name === channel_name &&
+//     (
+//       socket && s.socket_id === socket.id ||
+//       func && s.func === func
+//     ) && 
+//     JSON.stringify(s.viewOptions) === JSON.stringify((subscriptionParams.viewOptions)
+//   ));
+//   if (sub_idx < 0) {
+//     this.subs[table_name]![condition]!.subs.push(newSub);
+//     if (socket) {
+//       const chnUnsub = channel_name + "unsubscribe";
+//       socket.removeAllListeners(chnUnsub);
+//       socket.once(chnUnsub, (_data: any, cb: BasicCallback) => {
+//         const res = this.onSocketDisconnected({ socket, subChannel: channel_name });
+//         cb(null, { res });
+//       });
+//     }
+//   } else {
+//     this.subs[table_name]![condition]!.subs[sub_idx] = newSub;
+//   }
+
+//   if (isReadyOverride ?? is_ready) {
+//     this.pushSubData(newSub);
+//   }
+// };

package/lib/PubSubManager/addSync.d.ts

@@ -0,0 +1,8 @@
+import { PubSubManager } from "./PubSubManager";
+import { AddSyncParams } from "./PubSubManager";
+/**
+ * Returns a sync channel
+ * A sync channel is unique per socket for each filter
+ */
+export declare function addSync(this: PubSubManager, syncParams: AddSyncParams): Promise<string>;
+//# sourceMappingURL=addSync.d.ts.map

package/lib/PubSubManager/addSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addSync.d.ts","sourceRoot":"","sources":["addSync.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAA2B,MAAM,iBAAiB,CAAC;AAEzE;;;GAGG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,mBAsH3E"}

package/lib/PubSubManager/addSync.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSync = void 0;
+const util_1 = require("prostgles-types/dist/util");
+const PubSubManager_1 = require("./PubSubManager");
+const PubSubManager_2 = require("./PubSubManager");
+/**
+ * Returns a sync channel
+ * A sync channel is unique per socket for each filter
+ */
+async function addSync(syncParams) {
+    const { socket = null, table_info = null, table_rules, synced_field = null, allow_delete = false, id_fields = [], filter = {}, params, condition = "", throttle = 0 } = syncParams || {};
+    const conditionParsed = (0, PubSubManager_1.parseCondition)(condition);
+    if (!socket || !table_info)
+        throw "socket or table_info missing";
+    const { name: table_name } = table_info;
+    const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.sync`;
+    if (!synced_field)
+        throw "synced_field missing from table_rules";
+    this.upsertSocket(socket);
+    const upsertSync = () => {
+        const newSync = {
+            channel_name,
+            table_name,
+            filter,
+            condition: conditionParsed,
+            synced_field,
+            id_fields,
+            allow_delete,
+            table_rules,
+            throttle: Math.max(throttle || 0, table_rules?.sync?.throttle || 0),
+            batch_size: table_rules?.sync?.batch_size || PubSubManager_2.DEFAULT_SYNC_BATCH_SIZE,
+            last_throttled: 0,
+            socket_id: socket.id,
+            is_sync: true,
+            last_synced: 0,
+            lr: undefined,
+            table_info,
+            is_syncing: false,
+            wal: undefined,
+            socket,
+            params
+        };
+        /* Only a sync per socket per table per condition allowed */
+        this.syncs = this.syncs || [];
+        const existing = (0, util_1.find)(this.syncs, { socket_id: socket.id, channel_name });
+        if (!existing) {
+            this.syncs.push(newSync);
+            // console.log("Added SYNC");
+            const unsyncChn = channel_name + "unsync";
+            socket.removeAllListeners(unsyncChn);
+            socket.once(unsyncChn, (_data, cb) => {
+                // this.onSocketDisconnected({ socket, syncChannel: channel_name });
+                socket.removeAllListeners(channel_name);
+                socket.removeAllListeners(unsyncChn);
+                this.syncs = this.syncs.filter(s => {
+                    const isMatch = s.socket_id && s.socket_id === socket.id && s.channel_name === channel_name;
+                    return !isMatch;
+                });
+                cb(null, { res: "ok" });
+            });
+            socket.removeAllListeners(channel_name);
+            socket.on(channel_name, (data, cb) => {
+                if (!data) {
+                    cb({ err: "Unexpected request. Need data or onSyncRequest" });
+                    return;
+                }
+                /*
+                */
+                /* Server will:
+                    1. Ask for last_synced  emit(onSyncRequest)
+                    2. Ask for data >= server_synced    emit(onPullRequest)
+                        -> Upsert that data
+                    2. Push data >= last_synced     emit(data.data)
+        
+                   Client will:
+                    1. Send last_synced     on(onSyncRequest)
+                    2. Send data >= server_synced   on(onPullRequest)
+                    3. Send data on CRUD    emit(data.data | data.deleted)
+                    4. Upsert data.data | deleted     on(data.data | data.deleted)
+                */
+                // if(data.data){
+                //     console.error("THIS SHOUKD NEVER FIRE !! NEW DATA FROM SYNC");
+                //     this.upsertClientData(newSync, data.data);
+                // } else 
+                if (data.onSyncRequest) {
+                    // console.log("syncData from socket")
+                    this.syncData(newSync, data.onSyncRequest, "client");
+                    // console.log("onSyncRequest ", socket._user)
+                }
+                else {
+                    console.error("Unexpected sync request data from client: ", data);
+                }
+            });
+            // socket.emit(channel_name, { onSyncRequest: true }, (response) => {
+            //     console.log(response)
+            // });
+        }
+        else {
+            console.warn("UNCLOSED DUPLICATE SYNC FOUND", existing.channel_name);
+        }
+        return newSync;
+    };
+    // const { min_id, max_id, count, max_synced } = params;
+    const _sync = upsertSync();
+    await this.addTrigger({ table_name, condition: conditionParsed });
+    return channel_name;
+}
+exports.addSync = addSync;

package/lib/PubSubManager/addSync.ts

@@ -0,0 +1,127 @@
+import { find } from "prostgles-types/dist/util";
+import { BasicCallback, parseCondition, PubSubManager } from "./PubSubManager";
+import { AddSyncParams, DEFAULT_SYNC_BATCH_SIZE } from "./PubSubManager";
+
+/**
+ * Returns a sync channel
+ * A sync channel is unique per socket for each filter
+ */
+export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
+  const {
+    socket = null, table_info = null, table_rules, synced_field = null,
+    allow_delete = false, id_fields = [], filter = {},
+    params, condition = "", throttle = 0
+  } = syncParams || {};
+
+  const conditionParsed = parseCondition(condition);
+  if (!socket || !table_info) throw "socket or table_info missing";
+
+
+  const { name: table_name } = table_info;
+  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.sync`;
+
+  if (!synced_field) throw "synced_field missing from table_rules";
+
+  this.upsertSocket(socket);
+
+  const upsertSync = () => {
+    const newSync = {
+      channel_name,
+      table_name,
+      filter,
+      condition: conditionParsed,
+      synced_field,
+      id_fields,
+      allow_delete,
+      table_rules,
+      throttle: Math.max(throttle || 0, table_rules?.sync?.throttle || 0),
+      batch_size: table_rules?.sync?.batch_size || DEFAULT_SYNC_BATCH_SIZE,
+      last_throttled: 0,
+      socket_id: socket.id,
+      is_sync: true,
+      last_synced: 0,
+      lr: undefined,
+      table_info,
+      is_syncing: false,
+      wal: undefined,
+      socket,
+      params
+    };
+
+    /* Only a sync per socket per table per condition allowed */
+    this.syncs = this.syncs || [];
+    const existing = find(this.syncs, { socket_id: socket.id, channel_name });
+    if (!existing) {
+      this.syncs.push(newSync);
+      // console.log("Added SYNC");
+
+      const unsyncChn = channel_name + "unsync";
+      socket.removeAllListeners(unsyncChn);
+      socket.once(unsyncChn, (_data: any, cb: BasicCallback) => {
+        // this.onSocketDisconnected({ socket, syncChannel: channel_name });
+        socket.removeAllListeners(channel_name);
+        socket.removeAllListeners(unsyncChn);
+        this.syncs = this.syncs.filter(s => {
+          const isMatch = s.socket_id && s.socket_id === socket.id && s.channel_name === channel_name;
+          return !isMatch;
+        });
+        cb(null, { res: "ok" })
+      });
+
+      socket.removeAllListeners(channel_name);
+      socket.on(channel_name, (data: any, cb: BasicCallback) => {
+
+        if (!data) {
+          cb({ err: "Unexpected request. Need data or onSyncRequest" });
+          return;
+        }
+
+        /*
+        */
+
+        /* Server will:
+            1. Ask for last_synced  emit(onSyncRequest)
+            2. Ask for data >= server_synced    emit(onPullRequest)
+                -> Upsert that data
+            2. Push data >= last_synced     emit(data.data)
+
+           Client will:
+            1. Send last_synced     on(onSyncRequest)
+            2. Send data >= server_synced   on(onPullRequest)
+            3. Send data on CRUD    emit(data.data | data.deleted)
+            4. Upsert data.data | deleted     on(data.data | data.deleted)
+        */
+
+        // if(data.data){
+        //     console.error("THIS SHOUKD NEVER FIRE !! NEW DATA FROM SYNC");
+        //     this.upsertClientData(newSync, data.data);
+        // } else 
+        if (data.onSyncRequest) {
+          // console.log("syncData from socket")
+          this.syncData(newSync, data.onSyncRequest, "client");
+
+          // console.log("onSyncRequest ", socket._user)
+        } else {
+          console.error("Unexpected sync request data from client: ", data)
+        }
+      });
+
+      // socket.emit(channel_name, { onSyncRequest: true }, (response) => {
+      //     console.log(response)
+      // });
+    } else {
+      console.warn("UNCLOSED DUPLICATE SYNC FOUND", existing.channel_name);
+    }
+
+    return newSync;
+  };
+
+
+  // const { min_id, max_id, count, max_synced } = params;
+
+  const _sync = upsertSync();
+
+  await this.addTrigger({ table_name, condition: conditionParsed });
+
+  return channel_name;
+} 

package/lib/PubSubManager/notifListener.d.ts

@@ -0,0 +1,5 @@
+import { PubSubManager } from "./PubSubManager";
+export declare function notifListener(this: PubSubManager, data: {
+    payload: string;
+}): Promise<void>;
+//# sourceMappingURL=notifListener.d.ts.map

package/lib/PubSubManager/notifListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifListener.d.ts","sourceRoot":"","sources":["notifListener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,wBAAsB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,iBAwHjF"}