prostgles-server 4.2.158 → 4.2.160

package/lib/PubSubManager/addSub.ts

@@ -1,138 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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;
-}