prostgles-server 4.2.439 → 4.2.441

package/lib/PubSubManager/notifListener.ts

@@ -101,21 +101,21 @@ export async function notifListener(this: PubSubManager, data: { payload: string
   } else if (conditionIds?.every((id) => Number.isInteger(id))) {
     state = "ok";
     const firedTableConditions = tableTriggerConditions.filter(({ idx }) =>
-      conditionIds.includes(idx)
+      conditionIds.includes(idx),
     );
     const orphanedTableConditions = conditionIds.filter((condId) => {
       const tc = tableTriggerConditions.at(condId);
       return !tc || (tc.subs.length === 0 && tc.syncs.length === 0);
     });
     if (orphanedTableConditions.length) {
-      void this.deleteOrphanedTriggers.bind(this)(table_name);
+      void this.deleteOrphanedTriggers(new Set(table_name));
     }
 
     firedTableConditions.map(({ subs, syncs }) => {
       log(
         "notifListener",
         subs.map((s) => s.channel_name),
-        syncs.map((s) => s.channel_name)
+        syncs.map((s) => s.channel_name),
       );
 
       syncs.map((s) => {
@@ -128,8 +128,8 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           (trg) =>
             this.dbo[trg.table_name] &&
             sub.is_ready &&
-            ((sub.socket_id && this.sockets[sub.socket_id]) || sub.localFuncs)
-        )
+            ((sub.socket_id && this.sockets[sub.socket_id]) || sub.onData),
+        ),
       );
 
       activeAndReadySubs.forEach((sub) => {
@@ -143,7 +143,7 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           tracked_columns
         ) {
           const subFieldsHaveChanged = changedColumns.some((changedColumn) =>
-            tracked_columns.includes(changedColumn)
+            tracked_columns.includes(changedColumn),
           );
           if (!subFieldsHaveChanged) return;
         }
@@ -181,11 +181,11 @@ export async function notifListener(this: PubSubManager, data: { payload: string
     state,
     op_name,
     condition_ids_str,
-    tableTriggers: this._triggers[table_name],
+    tableTriggers: this._triggers.get(table_name),
     tableSyncs: JSON.stringify(
       this.syncs
         .filter((s) => s.table_name === table_name)
-        .map((s) => pickKeys(s, ["condition", "socket_id"]))
+        .map((s) => pickKeys(s, ["condition", "socket_id"])),
     ),
     connectedSocketIds: this.connectedSocketIds,
   });

package/lib/PubSubManager/pushSubData.ts

@@ -1,12 +1,10 @@
-import { getSerialisableError } from "prostgles-types";
-import { parseLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
 import type { EventTypes } from "../Logging";
 import type { Subscription } from "./PubSubManager";
 import { type PubSubManager } from "./PubSubManager";
 import { log } from "./PubSubManagerUtils";
 
 export async function pushSubData(this: PubSubManager, sub: Subscription, err?: any) {
-  const { socket_id, channel_name } = sub;
+  const { socket_id, channel_name, onData } = sub;
 
   const onLog = (
     state: Extract<EventTypes.SyncOrSub, { type: "syncOrSub"; command: "pushSubData" }>["state"],
@@ -28,7 +26,6 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
     onLog("sub_not_found");
     return;
   }
-  const localFuncs = parseLocalFuncs(sub.localFuncs);
 
   if (err) {
     onLog("error");
@@ -39,40 +36,28 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
   }
 
   sub.lastPushed = Date.now();
-  return new Promise(async (resolve, reject) => {
-    /* TODO: Retire subOne -> it's redundant */
 
-    const { data, err } = await this.getSubData(sub);
+  const { data, err: subDataError } = await this.getSubData(sub);
 
-    if (data) {
-      if (socket_id && this.sockets[socket_id]) {
-        log("Pushed " + data.length + " records to sub");
-        onLog("Emiting to socket");
-        this.sockets[socket_id].emit(channel_name, { data }, () => {
-          resolve(data);
-        });
+  if (subDataError !== undefined) {
+    onLog("fetch data error");
+  }
+  if (socket_id && this.sockets[socket_id]) {
+    log(`Pushing ${data?.length ?? 0} rows to socket`);
+    onLog("Emiting to socket");
+    this.sockets[socket_id].emit(
+      channel_name,
+      subDataError !== undefined ? { err: subDataError } : { data },
+      () => {
         /* TO DO: confirm receiving data or server will unsubscribe
           { data }, (cb)=> { console.log(cb) });
         */
-      } else if (localFuncs) {
-        onLog("pushed to local client");
-        localFuncs.onData(data);
-        resolve(data);
-      } else {
-        onLog("no client to push data to");
-      }
-    } else {
-      onLog("fetch data error");
-      const errObj = getSerialisableError(err) || "Unknown error fetching subscription data";
-      if (socket_id && this.sockets[socket_id]) {
-        this.sockets[socket_id].emit(channel_name, { err: errObj });
-      } else if (localFuncs) {
-        if (!localFuncs.onError) {
-          console.error("Uncaught subscription error", err);
-        }
-        localFuncs.onError?.(errObj);
-      }
-      reject(errObj);
-    }
-  });
+      },
+    );
+  } else if (onData) {
+    onLog("pushed to local client");
+    onData(data ?? [], subDataError);
+  } else {
+    onLog("no client to push data to");
+  }
 }

package/lib/PubSubManager/refreshTriggers.ts

@@ -2,27 +2,28 @@ import type { PubSubManager } from "./PubSubManager";
 
 export async function refreshTriggers(this: PubSubManager) {
   const start = Date.now();
-  const triggers: {
+  const triggers = await this.db.any<{
     table_name: string;
     condition: string;
     condition_hash: string;
-  }[] = await this.db.any(
+  }>(
     `
         SELECT *
         FROM prostgles.v_triggers
         WHERE app_id = $1
         ORDER BY table_name, condition
       `,
-    [this.dboBuilder.prostgles.appId]
+    [this.dboBuilder.prostgles.appId],
   );
 
-  const oldTriggers = { ...this._triggers };
+  const oldTriggers = new Map(this._triggers);
 
-  this._triggers = {};
+  this._triggers = new Map();
   triggers.map((t) => {
-    this._triggers[t.table_name] ??= [];
-    if (!this._triggers[t.table_name]?.map((t) => t.condition).includes(t.condition)) {
-      this._triggers[t.table_name]?.push({ condition: t.condition, hash: t.condition_hash });
+    this._triggers.set(t.table_name, this._triggers.get(t.table_name) ?? []);
+    const tableTriggers = this._triggers.get(t.table_name)!;
+    if (!tableTriggers.map((t) => t.condition).includes(t.condition)) {
+      tableTriggers.push({ condition: t.condition, hash: t.condition_hash });
     }
   });
 

package/lib/PublishParser/PublishParser.ts

@@ -1,10 +1,10 @@
-import { isObject } from "prostgles-types";
 import { getClientRequestIPsInfo } from "../Auth/AuthHandler";
 import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 import type { ProstglesInitOptions } from "../ProstglesTypes";
 import { getClientHandlers } from "../WebsocketAPI/getClientHandlers";
+import type { ServerFunctionDefinition } from "./defineServerFunction";
 import { getFileTableRules } from "./getFileTableRules";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
 import { getTableRulesWithoutFileTable } from "./getTableRulesWithoutFileTable";
@@ -20,7 +20,6 @@ import {
   type PermissionScope,
   type PublishObject,
 } from "./publishTypesAndUtils";
-import type { ServerFunctionDefinition } from "./defineServerFunction";
 
 export class PublishParser {
   publish: ProstglesInitOptions["publish"];
@@ -63,31 +62,20 @@ export class PublishParser {
     };
   }
 
-  getFunctionHandler = async (
-    params: PublishParams,
-  ): Promise<{ [key: string]: ServerFunctionDefinition } | undefined> => {
-    try {
-      const prostgles = this.prostgles;
-      return await prostgles.opts.functions?.(params);
-    } catch (e) {
-      console.error("Invalid functions:", e);
-      throw e;
-    }
-  };
   async getAllowedFunctions(clientReq: AuthClientRequest, userData: AuthResultWithSID | undefined) {
     const publishParams = await this.getPublishParams(clientReq, userData);
-    const functionHandler = await this.getFunctionHandler(publishParams);
-    if (!functionHandler) {
+    const allowedFunctions = await this.prostgles.opts.functions?.(publishParams);
+    if (!allowedFunctions) {
       return;
     }
-    const methods: Map<string, ServerFunctionDefinition> = new Map();
+    const allowedFunctionsMap: Map<string, ServerFunctionDefinition> = new Map();
 
-    for (const [name, method] of Object.entries(functionHandler)) {
+    for (const [name, method] of Object.entries(allowedFunctions)) {
       if (method.run !== undefined) {
-        methods.set(name, method);
+        allowedFunctionsMap.set(name, method);
       }
     }
-    return methods;
+    return allowedFunctionsMap;
   }
 
   /**
@@ -116,37 +104,21 @@ export class PublishParser {
     command,
     clientReq,
   }: DboTableCommand): Promise<ParsedTableRule> {
+    const rules = await this.getParsedTableRule({ tableName, clientReq }, undefined);
     const clientInfo =
       clientReq && (await this.prostgles.authHandler.getSidAndUserFromRequest(clientReq));
     if (clientInfo === "new-session-redirect") {
       throw "new-session-redirect";
     }
-    const rules = await this.getValidatedRequestRule(
-      { tableName, command, clientReq },
-      clientInfo,
-      undefined,
-    );
+    this.validateRequestRule({ tableName, command, clientReq }, rules, undefined);
     return rules;
   }
 
-  async getValidatedRequestRule(
-    { tableName, command, clientReq }: DboTableCommand,
+  async getParsedTableRule(
+    { tableName, clientReq }: Pick<DboTableCommand, "tableName" | "clientReq">,
     clientInfo: AuthResultWithSID | undefined,
-    scope: PermissionScope | undefined,
   ): Promise<ParsedTableRule> {
-    if (!command || !tableName) throw "command OR tableName are missing";
-
-    const rule = RULE_TO_METHODS.find((rtms) => rtms.methods.some((v) => v === command));
-    if (!rule) {
-      throw "Invalid command: " + command;
-    }
-
-    if (scope) {
-      const tableScope = scope.tables;
-      if (!tableScope?.[tableName] || !tableScope[tableName][rule.sqlRule]) {
-        throw `Invalid or disallowed command: ${tableName}.${command}. The PermissionsScope does not allow this command.`;
-      }
-    }
+    if (!tableName) throw "tableName missing";
 
     /* Must be local request -> allow everything */
     if (!clientReq) {
@@ -162,17 +134,41 @@ export class PublishParser {
     /* Must be from socket. Must have a publish */
     if (!this.publish) throw "publish is missing";
 
+    const tableErrors = clientReq.socket?.prostgles?.tableSchemaErrors[tableName];
     /* Get any publish errors for socket */
-    const errorInfo = clientReq.socket?.prostgles?.tableSchemaErrors[tableName]?.[command];
-
-    if (errorInfo) throw errorInfo.error;
+    Object.values(tableErrors ?? {}).forEach((errorInfo) => {
+      throw errorInfo.error;
+    });
 
     const tableRule = await this.getTableRules({ tableName, clientReq }, clientInfo);
-    if (!tableRule)
+
+    if (!tableRule) {
       throw {
         stack: ["getValidatedRequestRule()"],
         message: "Invalid or disallowed table: " + tableName,
       };
+    }
+    return tableRule;
+  }
+
+  validateRequestRule(
+    { tableName, command }: DboTableCommand,
+    tableRule: ParsedTableRule,
+    scope: PermissionScope | undefined,
+  ) {
+    if (!command || !tableName) throw "command OR tableName are missing";
+
+    const rule = RULE_TO_METHODS.find((rtms) => rtms.methods.some((v) => v === command));
+    if (!rule) {
+      throw "Invalid command: " + command;
+    }
+
+    if (scope) {
+      const tableScope = scope.tables;
+      if (!tableScope?.[tableName] || !tableScope[tableName][rule.sqlRule]) {
+        throw `Invalid or disallowed command: ${tableName}.${command}. The PermissionsScope does not allow this command.`;
+      }
+    }
 
     if (command === "upsert") {
       if (!tableRule.update || !tableRule.insert) {
@@ -189,8 +185,6 @@ export class PublishParser {
         message: `Invalid or disallowed command: ${tableName}.${command}`,
       };
     }
-
-    return tableRule;
   }
 
   async getTableRules(
@@ -236,9 +230,3 @@ function applyParamsIfFunc<T>(
   //@ts-ignore
   return maybeFunc;
 }
-
-export const getV2Methods = (functions: ProstglesInitOptions["functions"]) => {
-  if (typeof functions !== "function" && isObject(functions)) {
-    return functions;
-  }
-};

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -20,7 +20,7 @@ const SUBSCRIBE_METHODS = ["subscribe", "subscribeOne", "sync", "unsubscribe", "
 export async function getSchemaFromPublish(
   this: PublishParser,
   { userData, ...clientReq }: Args,
-  scope: PermissionScope | undefined
+  scope: PermissionScope | undefined,
 ): Promise<{
   schema: TableSchemaForClient;
   tables: DBSchemaTable[];
@@ -60,7 +60,7 @@ export async function getSchemaFromPublish(
         !tableNames.includes(fileTableName)
       ) {
         const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some((t) =>
-          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName))
+          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
         );
         if (isReferenced) {
           tableNames.unshift(fileTableName);
@@ -77,17 +77,17 @@ export async function getSchemaFromPublish(
             throw errMsg;
           }
 
-          const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo);
+          const parsedTableRule = await this.getTableRules({ clientReq, tableName }, clientInfo);
 
-          if (!tableRules || isEmpty(tableRules)) return;
-          if (!isObject(tableRules)) {
+          if (!parsedTableRule || isEmpty(parsedTableRule)) return;
+          if (!isObject(parsedTableRule)) {
             throw `Invalid tableRules for table ${tableName}. Expecting an object`;
           }
 
           schema[tableName] = {};
           const tableSchema = schema[tableName];
-          const methods = getKeys(tableRules).filter(
-            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m)
+          const methods = getKeys(parsedTableRule).filter(
+            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m),
           );
           let tableInfo: TableInfo | undefined;
           let tableColumns: DBSchemaTable["columns"] | undefined;
@@ -98,25 +98,25 @@ export async function getSchemaFromPublish(
               .map(async (method) => {
                 if (method === "sync") {
                   /* Pass sync info */
-                  tableSchema[method] = tableRules[method];
-                } else if (includes(getKeys(tableRules), method) && tableRules[method]) {
+                  tableSchema[method] = parsedTableRule[method];
+                } else if (includes(getKeys(parsedTableRule), method) && parsedTableRule[method]) {
                   //@ts-ignore
                   tableSchema[method] =
                     method === "insert" ?
-                      pickKeys(tableRules[method], ["allowedNestedInserts"])
+                      pickKeys(parsedTableRule[method], ["allowedNestedInserts"])
                     : ({} as AnyObject);
 
                   /* Test for issues with the common table CRUD methods () */
                   if (includes(TABLE_METHODS, method)) {
                     try {
-                      const parsedTableRule = await this.getValidatedRequestRule(
+                      this.validateRequestRule(
                         {
                           tableName,
                           command: method,
                           clientReq,
                         },
-                        clientInfo,
-                        scope
+                        parsedTableRule,
+                        scope,
                       );
                       if (this.prostgles.opts.testRulesOnConnect) {
                         await (this.dbo[tableName] as TableHandler)[method](
@@ -128,7 +128,7 @@ export async function getSchemaFromPublish(
                             ...clientReq,
                             isRemoteRequest: {},
                             testRule: true,
-                          }
+                          },
                         );
                       }
                     } catch (e) {
@@ -146,17 +146,17 @@ export async function getSchemaFromPublish(
                   }
 
                   if (method === "getInfo" || method === "getColumns") {
-                    const tableRules = await this.getValidatedRequestRule(
+                    this.validateRequestRule(
                       { tableName, command: method, clientReq },
-                      clientInfo,
-                      scope
+                      parsedTableRule,
+                      scope,
                     );
                     const res = await (this.dbo[tableName] as TableHandler)[method](
                       undefined,
                       undefined,
                       undefined,
-                      tableRules,
-                      { ...clientReq, isRemoteRequest: {} }
+                      parsedTableRule,
+                      { ...clientReq, isRemoteRequest: {} },
                     );
                     if (method === "getInfo") {
                       tableInfo = res as TableInfo;
@@ -165,7 +165,7 @@ export async function getSchemaFromPublish(
                     }
                   }
                 }
-              })
+              }),
           );
 
           if (tableInfo && tableColumns) {
@@ -175,7 +175,7 @@ export async function getSchemaFromPublish(
               columns: tableColumns,
             });
           }
-        })
+        }),
       );
     }
   } catch (error) {

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -9,7 +9,6 @@ import type {
   ParsedPublishTable,
   PublishTableRule,
   PublishViewRule,
-  SubscribeRule,
 } from "./publishTypesAndUtils";
 import { type PublishObject, RULE_TO_METHODS } from "./publishTypesAndUtils";
 
@@ -17,7 +16,7 @@ export async function getTableRulesWithoutFileTable(
   this: PublishParser,
   { tableName, clientReq }: DboTable,
   clientInfo: AuthResultWithSID | undefined,
-  overridenPublish?: PublishObject
+  overridenPublish?: PublishObject,
 ): Promise<ParsedPublishTable | undefined> {
   if (!tableName) throw new Error("tableName is missing in getTableRules");
 
@@ -111,7 +110,7 @@ export async function getTableRulesWithoutFileTable(
         const rule = parsedTableRule[method];
 
         const ruleInfo = MY_RULES.find(
-          (r) => r.rule === method || (r.methods as readonly string[]).includes(method)
+          (r) => r.rule === method || (r.methods as readonly string[]).includes(method),
         );
         if (!ruleInfo) {
           let extraInfo = "";
@@ -120,7 +119,7 @@ export async function getTableRulesWithoutFileTable(
             RULE_TO_METHODS.find(
               (r) =>
                 r.table_only &&
-                (r.rule === method || (r.methods as readonly string[]).includes(method))
+                (r.rule === method || (r.methods as readonly string[]).includes(method)),
             )
           ) {
             extraInfo = "You've specified table rules to a view\n";
@@ -159,8 +158,8 @@ export async function getTableRulesWithoutFileTable(
         if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
           const sr = MY_RULES.find((r) => r.rule === subKey);
           if (sr && canSubscribe) {
-            parsedTableRule[subKey] = { ...(sr.no_limits) };
-            parsedTableRule.subscribeOne = { ...(sr.no_limits) };
+            parsedTableRule[subKey] = { ...sr.no_limits };
+            parsedTableRule.subscribeOne = { ...sr.no_limits };
           }
         }
       });

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -505,6 +505,7 @@ export type DbTableInfo = {
 };
 export type PermissionScope = {
   sql?: "commited" | "rolledback";
+  /** TODO: this should match publish types */
   tables?: Record<string, Partial<Record<"select" | "update" | "delete" | "insert", boolean>>>;
   methods?: Record<string, boolean>;
 };

package/lib/SyncReplication.ts

@@ -115,6 +115,7 @@ export async function syncData(
         { orderBy: orderByAsc, select: sync_fields, limit, offset },
         undefined,
         table_rules,
+        { clientReq: { socket } },
       );
       const last_rows = first_rows.slice(-1); // Why not logic below?
       // const last_rows = await _this?.dbo[table_name]?.find?.(_filter, { orderBy: (orderByDesc as OrderBy), select: sync_fields, limit: 1, offset: -offset || 0 }, null, table_rules);

package/lib/initProstgles.ts

@@ -74,11 +74,11 @@ export type OnReadyParams<S> = OnReadyParamsCommon & {
 export type OnReadyCallback<S, SUser extends SessionUser> = (
   params: OnReadyParams<S>,
   update: (newOpts: UpdateableOptions<S, SUser>, force?: true) => Promise<void>,
-) => any;
+) => void | Promise<void>;
 export type OnReadyCallbackBasic = (
   params: OnReadyParamsBasic,
   update: (newOpts: UpdateableOptions<void, SessionUser>, force?: true) => Promise<void>,
-) => any;
+) => void | Promise<void>;
 
 export type InitResult<S = void, SUser extends SessionUser = SessionUser> = {
   db: DBOFullyTyped<S>;
@@ -155,6 +155,24 @@ export const initProstgles = async function (
         }
       },
     });
+
+    /** Drop stale triggers */
+    await db
+      .any(
+        `
+      WITH active_app_ids AS (
+        SELECT DISTINCT (string_to_array(application_name, ' '))[2] AS app_id
+        FROM pg_stat_activity
+        WHERE application_name LIKE 'prostgles %'
+      )
+      DELETE FROM prostgles.app_triggers
+      WHERE app_id NOT IN (SELECT app_id FROM active_app_ids)
+      AND app_id != $1
+      `,
+        [this.appId],
+      )
+      .catch(() => {});
+
     this.db = db;
     this.pgp = pgp;
     this.isSuperUser = await getIsSuperUser(db);
@@ -200,7 +218,7 @@ export const initProstgles = async function (
       if (this.destroyed) {
         console.trace("Prostgles: Instance is destroyed");
       }
-      onReady(
+      void onReady(
         {
           sql: this.dboBuilder.sql,
           dbo: this.dbo!,

package/lib/runClientRequest.ts

@@ -101,14 +101,15 @@ export const runClientRequest = async function (
   if (clientInfo === "new-session-redirect") {
     throw clientInfo;
   }
-  const validRules = await this.publishParser.getValidatedRequestRule(
-    { tableName, command, clientReq },
+
+  const parsedTableRule = await this.publishParser.getParsedTableRule(
+    { tableName, clientReq },
     clientInfo,
-    scope,
   );
+  this.publishParser.validateRequestRule({ tableName, command, clientReq }, parsedTableRule, scope);
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (!validRules) {
+  if (!parsedTableRule) {
     throw `Invalid OR disallowed request: ${tableName}.${command} `;
   }
 
@@ -150,7 +151,7 @@ export const runClientRequest = async function (
     param1,
     param2,
     param3,
-    validRules,
+    parsedTableRule,
     localParams,
   ) as AnyObject | undefined;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.439",
+  "version": "4.2.441",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,7 @@
   ],
   "homepage": "https://prostgles.com",
   "dependencies": {
-    "@aws-sdk/client-ses": "^3.980.0",
+    "@aws-sdk/client-ses": "^3.985.0",
     "@aws-sdk/credential-provider-node": "^3.972.4",
     "@types/passport": "^1.0.17",
     "@types/passport-facebook": "^3.0.3",
@@ -57,7 +57,7 @@
     "pg": "^8.15.6",
     "pg-cursor": "^2.17.0",
     "pg-promise": "^12.6.0",
-    "prostgles-types": "^4.0.207"
+    "prostgles-types": "^4.0.209"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",