prostgles-server 4.2.603 → 4.2.605

package/lib/PubSubManager/PubSubManager.ts

@@ -3,7 +3,12 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import type { DBHandlerServer, DboBuilder, PRGLIOSocket } from "../DboBuilder/DboBuilder";
+import type {
+  DBHandlerServer,
+  DboBuilder,
+  LocalParams,
+  PRGLIOSocket,
+} from "../DboBuilder/DboBuilder";
 import type { PostgresNotifListenManager } from "../PostgresNotifListenManager";
 import type { DB } from "../Prostgles";
 import { addSync } from "./addSync";
@@ -56,6 +61,7 @@ export type SyncParams = {
   lr?: AnyObject;
   is_syncing: boolean;
   handlers: ReturnType<(typeof ReplicationProtocol)["getServerHandlers"]>;
+  localParams: LocalParams;
 };
 
 export type AddSyncParams = SyncTableInfo & {
@@ -74,6 +80,7 @@ export type AddSyncParams = SyncTableInfo & {
   };
   condition: string;
   throttle?: number;
+  localParams: LocalParams;
 };
 
 export type ViewSubscriptionOptions = (
@@ -114,6 +121,7 @@ export type SubscriptionParams = {
 
   onData?: OnData;
   socket: PRGLIOSocket | undefined;
+  localParams?: LocalParams;
 
   lastPushed: number;
   /**
@@ -143,6 +151,7 @@ export type Subscription = Pick<
   | "table_info"
   | "filter"
   | "table_rules"
+  | "localParams"
 > & {
   triggers: [AddTriggerParams, ...AddTriggerParams[]];
 };
@@ -321,7 +330,15 @@ export class PubSubManager {
   };
 
   getSubData = async (sub: Subscription) => {
-    const { table_info, filter, selectParams: params, table_rules, socket, onData } = sub; //, subOne = false
+    const {
+      table_info,
+      filter,
+      selectParams: params,
+      table_rules,
+      localParams,
+      socket,
+      onData,
+    } = sub; //, subOne = false
     const { name: table_name } = table_info;
     const tableHandler = this.dbo[table_name];
     if (!onData && !socket) {
@@ -337,9 +354,7 @@ export class PubSubManager {
         params,
         undefined,
         table_rules,
-        socket && {
-          clientReq: { socket },
-        },
+        localParams,
       )) as AnyObject[];
       return { data };
     } catch (err) {

package/lib/PubSubManager/SyncReplication/fetchSyncServerData.ts

@@ -1,5 +1,5 @@
 import type { AnyObject } from "prostgles-types";
-import type { PRGLIOSocket } from "../../DboBuilder/DboBuilder";
+import type { LocalParams } from "../../DboBuilder/DboBuilder";
 import type { TableHandler } from "../../DboBuilder/TableHandler/TableHandler";
 import type { SyncParams } from "../PubSubManager";
 import { getSyncOrderByAndFields } from "./getSyncOrderByAndFields";
@@ -8,12 +8,12 @@ import { getSyncBatchOptions } from "./getSyncBatchOptions";
 export const fetchSyncServerData = async (
   {
     tableHandler,
-    socket,
+    localParams,
     from_synced,
     offset,
   }: {
     tableHandler: TableHandler;
-    socket: PRGLIOSocket;
+    localParams: LocalParams;
     from_synced: number | undefined;
     offset: number | undefined;
   },
@@ -48,7 +48,7 @@ export const fetchSyncServerData = async (
     },
     undefined,
     table_rules,
-    { clientReq: { socket } },
+    localParams,
   );
 
   return batchRows as AnyObject[];

package/lib/PubSubManager/SyncReplication/getSyncUtilFunctions.ts

@@ -6,7 +6,7 @@ import {
   type AnyObject,
   type SyncBatchParams,
 } from "prostgles-types";
-import type { PRGLIOSocket } from "../../DboBuilder/DboBuilder";
+import type { LocalParams, PRGLIOSocket } from "../../DboBuilder/DboBuilder";
 import type { TableHandler } from "../../DboBuilder/TableHandler/TableHandler";
 import { getSyncOrderByAndFields } from "./getSyncOrderByAndFields";
 import type { PubSubManager, SyncParams } from "../PubSubManager";
@@ -26,6 +26,7 @@ type Args = {
   sync: SyncParams;
   pubSubManager: PubSubManager;
   logSyncData: (state: Extract<EventTypes.Sync, { command: "syncData" }>["state"]) => void;
+  localParams: LocalParams;
 };
 
 export const getSyncUtilFunctions = ({
@@ -34,6 +35,7 @@ export const getSyncUtilFunctions = ({
   sync,
   pubSubManager,
   logSyncData,
+  localParams,
 }: Args) => {
   const {
     synced_field,
@@ -71,12 +73,18 @@ export const getSyncUtilFunctions = ({
         { orderBy: orderByAsc, select: sync_fields, limit, offset },
         undefined,
         table_rules,
-        { clientReq: { socket } },
+        localParams,
       )) as AnyObject[];
 
       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);
-      const count = await tableHandler.count(batchFilter, undefined, undefined, table_rules);
+      const count = await tableHandler.count(
+        batchFilter,
+        undefined,
+        undefined,
+        table_rules,
+        localParams,
+      );
 
       return {
         s_fr: first_rows[0],
@@ -128,7 +136,7 @@ export const getSyncUtilFunctions = ({
     },
     getServerData = async (from_synced: number | undefined, offset = 0): Promise<AnyObject[]> => {
       return fetchSyncServerData(
-        { tableHandler, socket, from_synced, offset },
+        { tableHandler, localParams, from_synced, offset },
         { filter, id_fields, params, synced_field, batch_size, table_rules },
       );
     },
@@ -173,7 +181,7 @@ export const getSyncUtilFunctions = ({
             },
             undefined,
             table_rules,
-            { clientReq: { socket } },
+            localParams,
           )) as AnyObject[];
           let rowsToInsert = data.filter(
             (incomingRow) =>
@@ -201,7 +209,7 @@ export const getSyncUtilFunctions = ({
               { removeDisallowedFields: true },
               undefined,
               table_rules,
-              { clientReq: { socket } },
+              localParams,
             );
           } else {
             rowsToUpdate = [];
@@ -213,7 +221,7 @@ export const getSyncUtilFunctions = ({
               { removeDisallowedFields: true },
               undefined,
               table_rules,
-              { clientReq: { socket } },
+              localParams,
             );
           } else {
             rowsToInsert = [];
@@ -355,7 +363,7 @@ export const getSyncUtilFunctions = ({
               { select: sync_fields, limit: 1 },
               undefined,
               table_rules,
-              { clientReq: { socket } },
+              localParams,
             );
           }
 

package/lib/PubSubManager/SyncReplication/syncData.ts

@@ -82,7 +82,6 @@ export async function syncData(
   if (!tableHandler?.find) {
     throw `dbo.${table_name}.find missing or not allowed`;
   }
-
   const {
     upsertData,
     updateSyncLR,
@@ -98,6 +97,7 @@ export async function syncData(
     sync,
     pubSubManager: this,
     logSyncData,
+    localParams: sync.localParams,
   });
 
   /* Used to throttle and merge incoming updates */

package/lib/PubSubManager/addSub.ts

@@ -34,6 +34,7 @@ export async function addSub(
     table_info,
     subscribeOptions,
     tracked_columns,
+    localParams,
   } = subscriptionParams;
   const table_name = table_info.name;
 
@@ -65,6 +66,7 @@ export async function addSub(
     is_throttling: false,
     socket_id: socket?.id,
     table_rules,
+    localParams,
     triggers: [mainTrigger],
   };
 

package/lib/PubSubManager/addSync.ts

@@ -20,6 +20,7 @@ export async function addSync(
   const res = await tryCatchV2(async () => {
     const { socket, rawSelect, table_info, table_rules, filter, params, condition, initialData } =
       syncParams;
+    const { localParams } = syncParams;
     const conditionParsed = parseCondition(condition);
 
     const { name: table_name } = table_info;
@@ -84,6 +85,7 @@ export async function addSync(
         socket,
         params,
         handlers,
+        localParams,
       };
       const unsyncChn = channelName + "unsync";
       socket.removeAllListeners(unsyncChn);

package/lib/PubSubManager/init/getPubSubManagerInitQuery.ts

@@ -162,11 +162,11 @@ BEGIN
           END IF;
         
           IF length(key) > 0 THEN
-            RETURN jsonb_extract_path(user_jsonb, key);
+            RETURN jsonb_extract_path_text(user_jsonb, key);
           END IF;
           RETURN user_jsonb;
         END;
-        $$ LANGUAGE plpgsql;
+        $$ LANGUAGE plpgsql STABLE PARALLEL SAFE;
         COMMENT ON FUNCTION prostgles."user" IS 'Used for row level security';
  
         CREATE OR REPLACE FUNCTION prostgles.user_id()
@@ -174,7 +174,7 @@ BEGIN
         BEGIN
           RETURN prostgles.user('id')::UUID;
         END;
-        $$ LANGUAGE plpgsql;
+        $$ LANGUAGE plpgsql STABLE PARALLEL SAFE;
         COMMENT ON FUNCTION prostgles.user_id IS 'Session user id';
 
         CREATE OR REPLACE FUNCTION prostgles.user_type()
@@ -182,7 +182,7 @@ BEGIN
         BEGIN
           RETURN prostgles.user('type')::TEXT;
         END;
-        $$ LANGUAGE plpgsql;
+        $$ LANGUAGE plpgsql STABLE PARALLEL SAFE;
         COMMENT ON FUNCTION prostgles.user_type IS 'Session user type'; 
 
         CREATE TABLE IF NOT EXISTS prostgles.apps (

package/lib/TableConfig/getTableConfigSchemaQueries.ts

@@ -115,7 +115,7 @@ const getTableQueries = async (
       `);`,
     ].join("\n");
 
-    const dataQuerys = rows.map((row) => {
+    const insertQueries = rows.map((row) => {
       const values = allColumns.map((key) => row[key]);
       return as.format(
         `INSERT INTO ${tableName}  (${allColumns.map((t) => asName(t)).join(", ")})  ` +
@@ -123,7 +123,7 @@ const getTableQueries = async (
         { values },
       );
     });
-    const queries = [createQuery, ...dataQuerys];
+    const queries = [createQuery, ...insertQueries];
     return {
       queries,
       colDefs,

package/lib/TableConfig/getTableTriggerQueries.spec.ts

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { asName } from "prostgles-types";
+import type { DB } from "../initProstgles";
+import { getTableTriggerQueries } from "./getTableTriggerQueries";
+
+void test("trigger configuration quotes names and bodies and preserves unmanaged triggers", async () => {
+  const db = {
+    any: () =>
+      Promise.resolve([
+        { name: "manual", comment: null },
+        { name: "old_insert", comment: "prostgles.tableConfig:old" },
+      ]),
+  } as unknown as DB;
+  const queries = await getTableTriggerQueries(
+    db,
+    "Odd ' table",
+    {
+      triggers: {
+        audit: {
+          type: "after",
+          actions: ["insert"],
+          forEach: "row",
+          query: "BEGIN RAISE NOTICE '$$'; RETURN NULL; END;",
+        },
+      },
+    },
+    asName,
+  );
+  assert.ok(queries.some((query) => query.includes('ON "Odd \' table"')));
+  assert.ok(
+    queries.some((query) =>
+      query.includes("AS 'BEGIN RAISE NOTICE ''$$''; RETURN NULL; END;';"),
+    ),
+  );
+  assert.ok(
+    queries.some((query) => query.includes('DROP TRIGGER "old_insert"')),
+  );
+  assert.ok(!queries.some((query) => query.includes('DROP TRIGGER "manual"')));
+});
+
+void test("unchanged triggers do not produce DDL; changed bodies replace them", async () => {
+  const trigger = {
+    type: "after",
+    actions: ["update"],
+    forEach: "row",
+    query: "BEGIN RETURN NULL; END;" as string,
+  } as const;
+  const config = {
+    triggers: { audit: { ...trigger, actions: [...trigger.actions] } },
+  };
+  const first = await getTableTriggerQueries(
+    { any: () => Promise.resolve([]) } as unknown as DB,
+    "records",
+    config,
+    asName,
+  );
+  const commentQuery = first.find((query) => query.startsWith("COMMENT ON"))!;
+  const comment = commentQuery.split(" IS '")[1]!.slice(0, -2);
+  const db = {
+    any: () => Promise.resolve([{ name: "audit_update", comment }]),
+  } as unknown as DB;
+  assert.deepEqual(
+    await getTableTriggerQueries(db, "records", config, asName),
+    [],
+  );
+  config.triggers.audit.query =
+    "BEGIN RAISE NOTICE 'changed'; RETURN NULL; END;";
+  assert.ok(
+    (await getTableTriggerQueries(db, "records", config, asName)).some(
+      (query) => query.startsWith("CREATE OR REPLACE FUNCTION"),
+    ),
+  );
+  assert.deepEqual(await getTableTriggerQueries(db, "records", {}, asName), [
+    'DROP TRIGGER "audit_update" ON "records";',
+  ]);
+});

package/lib/TableConfig/getTableTriggerQueries.ts

@@ -0,0 +1,74 @@
+import { as } from "pg-promise";
+import { md5 } from "prostgles-types/dist/md5";
+import type { DB } from "../initProstgles";
+import type { TableConfig } from "./TableConfigTypes";
+
+const MANAGED_TRIGGER_PREFIX = "prostgles.tableConfig:";
+
+/** Reconcile only triggers owned by tableConfig; preserve manually created triggers. */
+export const getTableTriggerQueries = async (
+  db: DB,
+  tableName: string,
+  tableConfig: TableConfig[string],
+  asName: (name: string) => string,
+): Promise<string[]> => {
+  const tableIdent = asName(tableName);
+  const existing = await db.any<{ name: string; comment: string | null }>(
+    `
+    SELECT t.tgname AS name, obj_description(t.oid, 'pg_trigger') AS comment
+    FROM pg_trigger t
+    WHERE t.tgrelid = to_regclass($1) AND NOT t.tgisinternal
+  `,
+    [tableIdent],
+  );
+  const queries: string[] = [];
+  const desired = new Set<string>();
+  const isDropped = tableConfig.dropIfExists || tableConfig.dropIfExistsCascade;
+  for (const [functionName, trigger] of Object.entries(
+    tableConfig.triggers ?? {},
+  )) {
+    const functionIdent = asName(functionName);
+    let functionAdded = false;
+    for (const action of trigger.actions) {
+      const name = `${functionName}_${action}`;
+      desired.add(name);
+      const triggerIdent = asName(name);
+      const transitionTables =
+        trigger.forEach === "row"
+          ? ""
+          : [
+              "REFERENCING",
+              action !== "delete" ? "NEW TABLE AS new_table" : "",
+              action !== "insert" ? "OLD TABLE AS old_table" : "",
+            ].join(" ");
+      const definition = `CREATE TRIGGER ${triggerIdent}
+        ${trigger.type} ${action} ON ${tableIdent}
+        ${transitionTables} FOR EACH ${trigger.forEach}
+        EXECUTE FUNCTION ${functionIdent}();`;
+      const comment = MANAGED_TRIGGER_PREFIX + md5(definition + trigger.query);
+      const previous = existing.find((entry) => entry.name === name);
+      if (!isDropped && previous?.comment === comment) continue;
+      if (!functionAdded) {
+        queries.push(`CREATE OR REPLACE FUNCTION ${functionIdent}()
+          RETURNS trigger LANGUAGE plpgsql AS ${as.text(trigger.query)};`);
+        functionAdded = true;
+      }
+      queries.push(`DROP TRIGGER IF EXISTS ${triggerIdent} ON ${tableIdent};`);
+      queries.push(definition);
+      queries.push(
+        `COMMENT ON TRIGGER ${triggerIdent} ON ${tableIdent} IS ${as.text(comment)};`,
+      );
+    }
+  }
+  if (!isDropped) {
+    for (const trigger of existing) {
+      if (
+        trigger.comment?.startsWith(MANAGED_TRIGGER_PREFIX) &&
+        !desired.has(trigger.name)
+      ) {
+        queries.push(`DROP TRIGGER ${asName(trigger.name)} ON ${tableIdent};`);
+      }
+    }
+  }
+  return queries;
+};

package/lib/TableConfig/initTableConfig.ts

@@ -9,6 +9,7 @@ import { fetchTableConstraints } from "./fetchTableConstraints";
 import { getConstraintDefinitionQueries } from "./getConstraintDefinitionQueries";
 import { getFutureTableSchema } from "./getFutureTableSchema";
 import { getTableColumnQueries } from "./getTableColumnQueries";
+import { getTableTriggerQueries } from "./getTableTriggerQueries";
 import { getIndexesQueries } from "./indexes/getIndexesQueries";
 import { runMigrations } from "./runMigrations";
 import type { TableConfigurator } from "./TableConfigurator";
@@ -162,7 +163,7 @@ export const initTableConfig = async function (this: TableConfigurator) {
     const ALTER_TABLE_Q = `ALTER TABLE ${asName(tableName)}`;
 
     /* isLookupTable table has already been created */
-    const coldef =
+    const tableColumnDefinition =
       "isLookupTable" in tableConf ? undefined : (
         await getTableColumnQueries({
           db: this.db,
@@ -172,8 +173,8 @@ export const initTableConfig = async function (this: TableConfigurator) {
         })
       );
 
-    if (coldef) {
-      queries.push(coldef.fullQuery);
+    if (tableColumnDefinition) {
+      queries.push(tableColumnDefinition.fullQuery);
     }
 
     /** CONSTRAINTS */
@@ -181,13 +182,13 @@ export const initTableConfig = async function (this: TableConfigurator) {
       tableName,
       tableConf,
     });
-    if (coldef?.isCreate) {
+    if (tableColumnDefinition?.isCreate) {
       queries.push(...(constraintDefs?.map((c) => c.alterQuery) ?? []));
-    } else if (coldef) {
+    } else if (tableColumnDefinition) {
       const fullSchema = await getFutureTableSchema({
         db: this.db,
         tableName,
-        columnDefs: coldef.columnDefs,
+        columnDefs: tableColumnDefinition.columnDefs,
         constraintDefs,
       });
       const futureCons = fullSchema.constraints.map((nc) => ({
@@ -234,73 +235,7 @@ export const initTableConfig = async function (this: TableConfigurator) {
     const indexQueries = await getIndexesQueries(this.db, tableName, tableConf);
     queries.push(...indexQueries);
 
-    const { triggers, dropIfExists, dropIfExistsCascade } = tableConf;
-    if (triggers) {
-      const isDropped = dropIfExists || dropIfExistsCascade;
-
-      const existingTriggers = await this.db.any<{ trigger_name: string }>(
-        `
-            SELECT event_object_table
-              ,trigger_name
-            FROM  information_schema.triggers
-            WHERE event_object_table = \${tableName}
-            ORDER BY event_object_table
-          `,
-        { tableName },
-      );
-
-      // const existingTriggerFuncs = await this.dbo.sql!(`
-      //   SELECT p.oid,proname,prosrc,u.usename
-      //   FROM  pg_proc p
-      //   JOIN  pg_user u ON u.usesysid = p.proowner
-      //   WHERE prorettype = 2279;
-      // `, {}, { returnType: "rows" }) as { proname: string }[];
-
-      Object.entries(triggers).forEach(([triggerFuncName, trigger]) => {
-        const funcNameParsed = asName(triggerFuncName);
-
-        let addedFunc = false;
-        const addFuncDef = () => {
-          if (addedFunc) return;
-          addedFunc = true;
-          queries.push(`
-              CREATE OR REPLACE FUNCTION ${funcNameParsed}()
-                RETURNS trigger
-                LANGUAGE plpgsql
-              AS
-              $$
-  
-              ${trigger.query}
-              
-              $$;
-            `);
-        };
-
-        trigger.actions.forEach((action) => {
-          const triggerActionName = triggerFuncName + "_" + action;
-
-          const triggerActionNameParsed = asName(triggerActionName);
-          if (isDropped) {
-            queries.push(`DROP TRIGGER IF EXISTS ${triggerActionNameParsed} ON ${tableName};`);
-          }
-
-          if (isDropped || !existingTriggers.some((t) => t.trigger_name === triggerActionName)) {
-            addFuncDef();
-            const newTableName = action !== "delete" ? "NEW TABLE AS new_table" : "";
-            const oldTableName = action !== "insert" ? "OLD TABLE AS old_table" : "";
-            const transitionTables =
-              trigger.forEach === "row" ? "" : `REFERENCING ${newTableName} ${oldTableName}`;
-            queries.push(`
-                CREATE TRIGGER ${triggerActionNameParsed}
-                ${trigger.type} ${action} ON ${tableName}
-                ${transitionTables}
-                FOR EACH ${trigger.forEach}
-                EXECUTE PROCEDURE ${funcNameParsed}();
-              `);
-          }
-        });
-      });
-    }
+    queries.push(...(await getTableTriggerQueries(this.db, tableName, tableConf, asName)));
   }
 
   if (queries.length) {

package/lib/runClientRequest.ts

@@ -1,16 +1,15 @@
-import type { SQLRequest, TableHandler, UserLike } from "prostgles-types";
+import type { SQLRequest, TableHandler } from "prostgles-types";
 import {
   ABORTABLE_METHODS,
   getJSONBObjectSchemaValidationError,
   getJSONBSchemaValidationErrorAsync,
   getKeys,
-  pickKeys,
   type AnyObject,
 } from "prostgles-types";
 import type { AuthClientRequest } from "./Auth/AuthTypes";
+import { getSessionUser } from "./Auth/utils/getSessionUser";
 import type { LocalParams } from "./DboBuilder/DboBuilder";
 import type { TableHandler as TableHandlerServer } from "./DboBuilder/TableHandler/TableHandler";
-import { parseFieldFilter } from "./DboBuilder/ViewHandler/parseFieldFilter";
 import { canRunSQL } from "./DboBuilder/runSql/runSQL";
 import type { Prostgles } from "./Prostgles";
 import type { ParsedTableRule } from "./PublishParser/publishTypesAndUtils";
@@ -118,18 +117,7 @@ export const runClientRequest = async function (
     scope,
   );
 
-  const sessionUser: UserLike | undefined =
-    !clientInfo.user ? undefined : (
-      {
-        ...parseFieldFilter(
-          //@ts-ignore
-          clientInfo.sessionFields ?? [],
-          false,
-          getKeys(clientInfo.user),
-        ),
-        ...(pickKeys(clientInfo.user, ["id", "type"]) as UserLike),
-      }
-    );
+  const sessionUser = getSessionUser(clientInfo);
   const localParams: LocalParams = {
     clientReq,
     isRemoteRequest: { user: sessionUser, clientInfo },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.603",
+  "version": "4.2.605",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",