prostgles-server 4.2.183 → 4.2.185

package/lib/PubSubManager/PubSubManager.ts

@@ -29,7 +29,11 @@ import {
 } from "prostgles-types";
 
 import { find, pickKeys, tryCatch } from "prostgles-types/dist/util";
-import { LocalFuncs, getOnDataFunc, matchesLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
+import {
+  LocalFuncs,
+  getOnDataFunc,
+  matchesLocalFuncs,
+} from "../DboBuilder/ViewHandler/subscribe";
 import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
 import { EventTypes } from "../Logging";
 import { TableRule } from "../PublishParser/PublishParser";
@@ -109,7 +113,10 @@ export type ViewSubscriptionOptions = (
   }[];
 };
 
-export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpts"> & {
+export type SubscriptionParams = Pick<
+  SubscribeParams,
+  "throttle" | "throttleOpts"
+> & {
   socket_id?: string;
   channel_name: string;
 
@@ -230,16 +237,17 @@ export class PubSubManager {
     const { watchSchema } = this.dboBuilder.prostgles.opts;
     if (watchSchema && !(await getIsSuperUser(this.db))) {
       console.warn(
-        "prostgles watchSchema requires superuser db user. Will not watch using event triggers"
+        "prostgles watchSchema requires superuser db user. Will not watch using event triggers",
       );
     }
 
     try {
       /** We use these names because they include schema where necessary */
-      const allTableNames = Object.keys(this.dbo).filter((k) => this.dbo[k]?.tableOrViewInfo);
-      const tableFilterQuery =
-        allTableNames.length ?
-          `OR table_name NOT IN (${allTableNames.map((tblName) => asValue(tblName)).join(", ")})`
+      const allTableNames = Object.keys(this.dbo).filter(
+        (k) => this.dbo[k]?.tableOrViewInfo,
+      );
+      const tableFilterQuery = allTableNames.length
+        ? `OR table_name NOT IN (${allTableNames.map((tblName) => asValue(tblName)).join(", ")})`
         : "";
       const query = pgp.as.format(
         `
@@ -295,7 +303,7 @@ export class PubSubManager {
 
         COMMIT;
       `,
-        { EVENT_TRIGGER_TAGS }
+        { EVENT_TRIGGER_TAGS },
       );
 
       await this.db
@@ -316,45 +324,58 @@ export class PubSubManager {
     channel_name,
     localFuncs,
     socket_id,
-  }: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[] {
+  }: Pick<
+    Subscription,
+    "localFuncs" | "socket_id" | "channel_name"
+  >): Subscription[] {
     return this.subs.filter((s) => {
       return (
         s.channel_name === channel_name &&
-        (matchesLocalFuncs(localFuncs, s.localFuncs) || (socket_id && s.socket_id === socket_id))
+        (matchesLocalFuncs(localFuncs, s.localFuncs) ||
+          (socket_id && s.socket_id === socket_id))
       );
     });
   }
 
   getTriggerSubs(table_name: string, condition: string): Subscription[] {
-    const subs = this.subs.filter((s) => find(s.triggers, { table_name, condition }));
+    const subs = this.subs.filter((s) =>
+      find(s.triggers, { table_name, condition }),
+    );
     return subs;
   }
 
   removeLocalSub(channelName: string, localFuncs: LocalFuncs) {
     const matchingSubIdx = this.subs.findIndex(
       (s) =>
-        s.channel_name === channelName && getOnDataFunc(localFuncs) === getOnDataFunc(s.localFuncs)
+        s.channel_name === channelName &&
+        getOnDataFunc(localFuncs) === getOnDataFunc(s.localFuncs),
     );
     if (matchingSubIdx > -1) {
       this.subs.splice(matchingSubIdx, 1);
     } else {
-      console.error("Could not unsubscribe. Subscription might not have initialised yet", {
-        channelName,
-      });
+      console.error(
+        "Could not unsubscribe. Subscription might not have initialised yet",
+        {
+          channelName,
+        },
+      );
     }
   }
 
   getSyncs(table_name: string, condition: string) {
     return (this.syncs || []).filter(
-      (s: SyncParams) => s.table_name === table_name && s.condition === condition
+      (s: SyncParams) =>
+        s.table_name === table_name && s.condition === condition,
     );
   }
 
   notifListener = notifListener.bind(this);
 
   getSubData = async (
-    sub: Subscription
-  ): Promise<{ data: any[]; err?: undefined } | { data?: undefined; err: any }> => {
+    sub: Subscription,
+  ): Promise<
+    { data: any[]; err?: undefined } | { data?: undefined; err: any }
+  > => {
     const { table_info, filter, params, table_rules } = sub; //, subOne = false
     const { name: table_name } = table_info;
 
@@ -363,7 +384,12 @@ export class PubSubManager {
     }
 
     try {
-      const data = await this.dbo?.[table_name]!.find!(filter, params, undefined, table_rules);
+      const data = await this.dbo?.[table_name]!.find!(
+        filter,
+        params,
+        undefined,
+        table_rules,
+      );
       return { data };
     } catch (err) {
       return { err };
@@ -395,10 +421,13 @@ export class PubSubManager {
           socketId: socket.id,
           connectedSocketIds: this.connectedSocketIds,
           remainingSubs: JSON.stringify(
-            this.subs.map((s) => ({ tableName: s.table_info.name, triggers: s.triggers }))
+            this.subs.map((s) => ({
+              tableName: s.table_info.name,
+              triggers: s.triggers,
+            })),
           ),
           remainingSyncs: JSON.stringify(
-            this.syncs.map((s) => pickKeys(s, ["table_name", "condition"]))
+            this.syncs.map((s) => pickKeys(s, ["table_name", "condition"])),
           ),
         });
 
@@ -424,7 +453,9 @@ export class PubSubManager {
   getActiveListeners = (): { table_name: string; condition: string }[] => {
     const activeListeners: { table_name: string; condition: string }[] = [];
     const upsert = (t: string, c: string) => {
-      if (!activeListeners.find((r) => r.table_name === t && r.condition === c)) {
+      if (
+        !activeListeners.find((r) => r.table_name === t && r.condition === c)
+      ) {
         activeListeners.push({ table_name: t, condition: c });
       }
     };
@@ -455,7 +486,7 @@ export class PubSubManager {
         WHERE app_id = $1
         ORDER BY table_name, condition
       `,
-      [this.dboBuilder.prostgles.appId]
+      [this.dboBuilder.prostgles.appId],
     );
 
     this._triggers = {};
@@ -473,7 +504,7 @@ export class PubSubManager {
   async addTrigger(
     params: { table_name: string; condition: string },
     viewOptions: ViewSubscriptionOptions | undefined,
-    socket: PRGLIOSocket | undefined
+    socket: PRGLIOSocket | undefined,
   ) {
     const addedTrigger = await tryCatch(async () => {
       const { table_name } = { ...params };
@@ -491,7 +522,9 @@ export class PubSubManager {
       const trgVals = {
         tbl: asValue(table_name),
         cond: asValue(condition),
-        condHash: asValue(crypto.createHash("md5").update(condition).digest("hex")),
+        condHash: asValue(
+          crypto.createHash("md5").update(condition).digest("hex"),
+        ),
       };
 
       await this.db.tx((t) =>
@@ -530,7 +563,7 @@ export class PubSubManager {
         ON CONFLICT DO NOTHING;
 
         COMMIT WORK;
-      `)
+      `),
       );
 
       /** This might be redundant due to trigger on app_triggers */
@@ -549,7 +582,9 @@ export class PubSubManager {
       error: addedTrigger.error,
       sid: this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
       tableName: addedTrigger.tbl ?? params.table_name,
-      connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
+      connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map(
+        (s) => s.id,
+      ),
       localParams: { socket },
     });
 

package/lib/PubSubManager/addSub.ts

@@ -1,20 +1,41 @@
 import { SubscriptionChannels } from "prostgles-types";
-import { BasicCallback, parseCondition, PubSubManager, Subscription, SubscriptionParams } from "./PubSubManager";
+import {
+  BasicCallback,
+  parseCondition,
+  PubSubManager,
+  Subscription,
+  SubscriptionParams,
+} from "./PubSubManager";
 import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 
 type AddSubscriptionParams = SubscriptionParams & {
   condition: string;
-}
+};
 
-type AddSubResult = SubscriptionChannels & { sendFirstData: VoidFunction | undefined }
+type AddSubResult = SubscriptionChannels & {
+  sendFirstData: VoidFunction | undefined;
+};
 
 /* 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<AddSubResult> {
+export async function addSub(
+  this: PubSubManager,
+  subscriptionParams: Omit<
+    AddSubscriptionParams,
+    "channel_name" | "parentSubParams"
+  >,
+): Promise<AddSubResult> {
   const {
-    socket, localFuncs, table_rules, filter = {},
-    params = {}, condition = "", throttle = 0,  //subOne = false, 
-    viewOptions, table_info, throttleOpts,
+    socket,
+    localFuncs,
+    table_rules,
+    filter = {},
+    params = {},
+    condition = "",
+    throttle = 0, //subOne = false,
+    viewOptions,
+    table_info,
+    throttleOpts,
   } = subscriptionParams || {};
   const table_name = table_info.name;
 
@@ -55,71 +76,70 @@ export async function addSub(this: PubSubManager, subscriptionParams: Omit<AddSu
     socket_id: socket?.id,
     table_rules,
     throttle: validated_throttle,
-    triggers: [
-      mainTrigger
-    ]
-  }
+    triggers: [mainTrigger],
+  };
 
   const result: AddSubResult = {
     channelName: channel_name,
     channelNameReady: channel_name + ".ready",
     channelNameUnsubscribe: channel_name + ".unsubscribe",
     sendFirstData: undefined,
-  }
+  };
 
   const [matchingSub] = this.getClientSubs(newSub);
-  if(matchingSub){
+  if (matchingSub) {
     console.error("Trying to add a duplicate sub for: ", channel_name);
     return result;
   }
 
   this.upsertSocket(socket);
 
-  if(viewOptions){
-    for await(const relatedTable of viewOptions.relatedTables){
+  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, socket);      
-    }
+      newSub.triggers.push(relatedSub);
 
+      await this.addTrigger(relatedSub, viewOptions, socket);
+    }
   }
 
-
-  if(localFuncs){
-    /** 
-     * Must ensure sub will start sending data after all triggers are set up. 
+  if (localFuncs) {
+    /**
+     * Must ensure sub will start sending data after all triggers are set up.
      * Socket clients are not affected as they need to confirm they are ready to receive data
-    */
+     */
     result.sendFirstData = () => {
       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.subs = this.subs.filter(s => {
-        const isMatch = s.socket?.id === socket.id && s.channel_name === channel_name;
-        return !isMatch;
-      });
-      removeListeners();
-      cb(null, { res });
-    });
+    socket.once(
+      result.channelNameUnsubscribe,
+      (_data: any, cb: BasicCallback) => {
+        const res = "ok";
+        this.subs = this.subs.filter((s) => {
+          const isMatch =
+            s.socket?.id === socket.id && s.channel_name === channel_name;
+          return !isMatch;
+        });
+        removeListeners();
+        cb(null, { res });
+      },
+    );
   }
 
   this.subs.push(newSub);
@@ -129,7 +149,6 @@ export async function addSub(this: PubSubManager, subscriptionParams: Omit<AddSu
     if (!viewOptions?.relatedTables.length) {
       throw "PubSubManager: view parent_tables missing";
     }
-
   } else {
     await this.addTrigger(mainTrigger, undefined, socket);
   }

package/lib/PubSubManager/addSync.ts

@@ -1,30 +1,43 @@
 import { find, tryCatch } from "prostgles-types/dist/util";
-import { AddSyncParams, BasicCallback, DEFAULT_SYNC_BATCH_SIZE, PubSubManager, parseCondition } from "./PubSubManager";
+import {
+  AddSyncParams,
+  BasicCallback,
+  DEFAULT_SYNC_BATCH_SIZE,
+  PubSubManager,
+  parseCondition,
+} 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 sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket: syncParams.socket });
+  const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError({
+    socket: syncParams.socket,
+  });
   const res = await tryCatch(async () => {
-
     const {
-      socket = null, table_info = null, table_rules, synced_field = null,
-      allow_delete = false, id_fields = [], filter = {},
-      params, condition = "", throttle = 0
-    } = syncParams || {} as AddSyncParams;
+      socket = null,
+      table_info = null,
+      table_rules,
+      synced_field = null,
+      allow_delete = false,
+      id_fields = [],
+      filter = {},
+      params,
+      condition = "",
+      throttle = 0,
+    } = syncParams || ({} as AddSyncParams);
     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,
@@ -46,7 +59,7 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
         is_syncing: false,
         wal: undefined,
         socket,
-        params
+        params,
       };
 
       /* Only a sync per socket per table per condition allowed */
@@ -54,15 +67,15 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
       const existing = find(this.syncs, { socket_id: socket.id, channel_name });
       if (!existing) {
         this.syncs.push(newSync);
-        
+
         const unsyncChn = channel_name + "unsync";
         socket.removeAllListeners(unsyncChn);
         socket.once(unsyncChn, (_data: any, cb: BasicCallback) => {
-          this._log({ 
-            type: "sync", 
-            command: "unsync", 
-            socketId: socket.id, 
-            tableName: table_name, 
+          this._log({
+            type: "sync",
+            command: "unsync",
+            socketId: socket.id,
+            tableName: table_name,
             condition,
             sid,
             connectedSocketIds: this.connectedSocketIds,
@@ -70,8 +83,11 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
           });
           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;
+          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" });
@@ -79,14 +95,13 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
 
         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)
@@ -103,12 +118,10 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
 
           if (data.onSyncRequest) {
             this.syncData(newSync, data.onSyncRequest, "client");
-
           } else {
-            console.error("Unexpected sync request data from client: ", data)
+            console.error("Unexpected sync request data from client: ", data);
           }
         });
-
       } else {
         console.warn("UNCLOSED DUPLICATE SYNC FOUND", existing.channel_name);
       }
@@ -118,16 +131,20 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
 
     upsertSync();
 
-    await this.addTrigger({ table_name, condition: conditionParsed }, undefined, socket);
+    await this.addTrigger(
+      { table_name, condition: conditionParsed },
+      undefined,
+      socket,
+    );
 
     return { result: channel_name };
   });
 
-  await this._log({ 
-    type: "sync", 
-    command: "addSync", 
-    tableName: syncParams.table_info.name, 
-    condition: syncParams.condition, 
+  await this._log({
+    type: "sync",
+    command: "addSync",
+    tableName: syncParams.table_info.name,
+    condition: syncParams.condition,
     socketId: syncParams.socket.id,
     connectedSocketIds: this.connectedSocketIds,
     duration: res.duration,
@@ -135,7 +152,7 @@ export async function addSync(this: PubSubManager, syncParams: AddSyncParams) {
     sid,
   });
 
-  if(res.error !== undefined) throw res.error;
+  if (res.error !== undefined) throw res.error;
 
   return res.result;
-} 
+}

package/lib/PubSubManager/getCreatePubSubManagerError.ts

@@ -3,10 +3,12 @@ import { getPubSubManagerInitQuery } from "./getPubSubManagerInitQuery";
 import { getCanExecute } from "../DboBuilder/dboBuilderUtils";
 import { DboBuilder } from "../DboBuilder/DboBuilder";
 
-export const getCreatePubSubManagerError = async (dboBuilder: DboBuilder): Promise<string | undefined> => {
+export const getCreatePubSubManagerError = async (
+  dboBuilder: DboBuilder,
+): Promise<string | undefined> => {
   const db = dboBuilder.db;
-  
-  const canExecute = await getCanExecute(db)
+
+  const canExecute = await getCanExecute(db);
   if (!canExecute) return "Cannot run EXECUTE statements on this connection";
 
   /** Check if prostgles schema exists */
@@ -16,25 +18,26 @@ export const getCreatePubSubManagerError = async (dboBuilder: DboBuilder): Promi
     WHERE nspname = 'prostgles'
   `);
 
-  const checkIfCanCreateProstglesSchema = () => tryCatch(async () => {
-    const allGood = await db.task(async t => {
-      try {
-        await t.none(`
+  const checkIfCanCreateProstglesSchema = () =>
+    tryCatch(async () => {
+      const allGood = await db.task(async (t) => {
+        try {
+          await t.none(`
           BEGIN;
           DROP SCHEMA IF EXISTS prostgles CASCADE;
           CREATE SCHEMA IF NOT EXISTS prostgles;
           ROLLBACK;
         `);
-      } catch (e) {
-        await t.none(`ROLLBACK`);
-        return false;
-      }
+        } catch (e) {
+          await t.none(`ROLLBACK`);
+          return false;
+        }
 
-      return true;
-    });
+        return true;
+      });
 
-    return allGood;
-  });
+      return allGood;
+    });
 
   if (!prglSchema.length) {
     const canCreate = await checkIfCanCreateProstglesSchema();
@@ -52,21 +55,26 @@ export const getCreatePubSubManagerError = async (dboBuilder: DboBuilder): Promi
       return { ok: true };
     });
 
-    if(!canCheckVersion.ok){
-      console.error("prostgles schema exists but cannot check version. Check logs", canCheckVersion.error);
+    if (!canCheckVersion.ok) {
+      console.error(
+        "prostgles schema exists but cannot check version. Check logs",
+        canCheckVersion.error,
+      );
       return "prostgles schema exists but cannot check version. Check logs";
     }
   }
 
-  const initQuery = await tryCatch(async () => ({ query: await getPubSubManagerInitQuery.bind(dboBuilder)() }));
-  if(initQuery.hasError){
+  const initQuery = await tryCatch(async () => ({
+    query: await getPubSubManagerInitQuery.bind(dboBuilder)(),
+  }));
+  if (initQuery.hasError) {
     console.error(initQuery.error);
     return "Could not get initQuery. Check logs";
   }
 
-  if(!initQuery.query){
+  if (!initQuery.query) {
     return undefined;
   }
 
   return undefined;
-}
+};