prostgles-server 4.2.159 → 4.2.161

package/lib/PubSubManager/addSub.ts

@@ -0,0 +1,138 @@
+import { SubscriptionChannels } from "prostgles-types";
+import { BasicCallback, parseCondition, PubSubManager, Subscription, SubscriptionParams } from "./PubSubManager";
+import { VoidFunction } from "../SchemaWatch/SchemaWatch";
+
+type AddSubscriptionParams = SubscriptionParams & {
+  condition: string;
+}
+
+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> {
+  const {
+    socket, localFuncs, table_rules, filter = {},
+    params = {}, condition = "", throttle = 0,  //subOne = false, 
+    viewOptions, table_info, throttleOpts,
+  } = subscriptionParams || {};
+  const table_name = table_info.name;
+
+  if (!socket && !localFuncs) {
+    throw "socket AND func missing";
+  }
+  if (socket && localFuncs) {
+    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 mainTrigger = {
+    table_name: table_name,
+    condition: parseCondition(condition),
+    is_related: false,
+  } as const;
+
+  const newSub: Subscription = {
+    channel_name,
+    filter,
+    localFuncs,
+    params,
+    last_throttled: 0,
+    socket,
+    throttleOpts,
+    table_info,
+    is_ready: true,
+    is_throttling: false,
+    socket_id: socket?.id,
+    table_rules,
+    throttle: validated_throttle,
+    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){
+    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){
+      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);      
+    }
+
+  }
+
+
+  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 });
+    });
+  }
+
+  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(mainTrigger, undefined, socket);
+  }
+
+  return result;
+}

package/lib/PubSubManager/addSync.ts

@@ -0,0 +1,141 @@
+import { find, tryCatch } from "prostgles-types/dist/util";
+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 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;
+    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,
+        sid,
+        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,
+        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 ??= [];
+      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, 
+            condition,
+            sid,
+            connectedSocketIds: this.connectedSocketIds,
+            duration: -1,
+          });
+          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.onSyncRequest) {
+            this.syncData(newSync, data.onSyncRequest, "client");
+
+          } else {
+            console.error("Unexpected sync request data from client: ", data)
+          }
+        });
+
+      } else {
+        console.warn("UNCLOSED DUPLICATE SYNC FOUND", existing.channel_name);
+      }
+
+      return newSync;
+    };
+
+    upsertSync();
+
+    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, 
+    socketId: syncParams.socket.id,
+    connectedSocketIds: this.connectedSocketIds,
+    duration: res.duration,
+    error: res.error,
+    sid,
+  });
+
+  if(res.error !== undefined) throw res.error;
+
+  return res.result;
+} 

package/lib/PubSubManager/getCreatePubSubManagerError.ts

@@ -0,0 +1,72 @@
+import { tryCatch } from "prostgles-types";
+import { getPubSubManagerInitQuery } from "./getPubSubManagerInitQuery";
+import { getCanExecute } from "../DboBuilder/dboBuilderUtils";
+import { DboBuilder } from "../DboBuilder/DboBuilder";
+
+export const getCreatePubSubManagerError = async (dboBuilder: DboBuilder): Promise<string | undefined> => {
+  const db = dboBuilder.db;
+  
+  const canExecute = await getCanExecute(db)
+  if (!canExecute) return "Cannot run EXECUTE statements on this connection";
+
+  /** Check if prostgles schema exists */
+  const prglSchema = await db.any(`
+    SELECT *
+    FROM pg_catalog.pg_namespace
+    WHERE nspname = 'prostgles'
+  `);
+
+  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;
+      }
+
+      return true;
+    });
+
+    return allGood;
+  });
+
+  if (!prglSchema.length) {
+    const canCreate = await checkIfCanCreateProstglesSchema();
+    if (!canCreate) {
+      const dbName = await db.one(`SELECT current_database()`);
+      const user = await db.one(`SELECT current_user`);
+      return `Not allowed to create prostgles schema. GRANT CREATE ON DATABASE ${dbName} TO ${user}`;
+    }
+    return undefined;
+  } else {
+    const canCheckVersion = await tryCatch(async () => {
+      await db.any(`
+        SELECT * FROM prostgles.versions
+      `);
+      return { ok: true };
+    });
+
+    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){
+    console.error(initQuery.error);
+    return "Could not get initQuery. Check logs";
+  }
+
+  if(!initQuery.query){
+    return undefined;
+  }
+
+  return undefined;
+}