prostgles-server 4.2.648 → 4.2.650

package/lib/DboBuilder/TableHandler/executeAfterHooksCheckAndPostValidation.ts

@@ -4,6 +4,7 @@ import { isArray } from "../../utils/utils";
 import type { LocalParams } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
 import { isApplicableHook } from "./isApplicableHook";
+import { runTableHook } from "../../ExecutionContext";
 
 /**
  * Prevent same-table same-command after-hook re-entry within the same tx.
@@ -82,10 +83,12 @@ export const executeAfterHooksCheckAndPostValidation = async ({
         );
         if (!isApplicable) continue;
         if (hook.type === "afterEach") {
-          await hook.validate({
-            ...commonParams,
-            localParams,
-          });
+          await runTableHook(tableHandler, [row], () =>
+            hook.validate({
+              ...commonParams,
+              localParams,
+            }),
+          );
         } else if (hook.type === "postValidate") {
           if (!localParams) throw new Error("Unexpected: no localParams for postValidate");
           await hook.validate({
@@ -117,27 +120,31 @@ export const executeAfterHooksCheckAndPostValidation = async ({
       });
       if (!applicableRows.length && !applicableData.length) continue;
       if (hook.type === "afterAll") {
-        await hook.validate({
-          ...txParams,
-          command,
-          data: applicableData,
-          rows: applicableRows,
-          localParams,
-          context: tableHandler.dboBuilder.prostgles.context,
-        });
-      } else if (hook.type === "afterCommit" && applicableRows.length) {
-        const context = tableHandler.dboBuilder.prostgles.context;
-        txParams.onCommit(({ db, dbo }) =>
-          hook.run({
-            rows: applicableRows,
+        await runTableHook(tableHandler, applicableRows, () =>
+          hook.validate({
+            ...txParams,
             command,
-            context,
-            db,
-            dbo,
-            getClientDBHandlers: tableHandler.dboBuilder.prostgles.getClientDBHandlers,
+            data: applicableData,
+            rows: applicableRows,
             localParams,
+            context: tableHandler.dboBuilder.prostgles.context,
           }),
         );
+      } else if (hook.type === "afterCommit" && applicableRows.length) {
+        const context = tableHandler.dboBuilder.prostgles.context;
+        runTableHook(tableHandler, applicableRows, () =>
+          txParams.onCommit(({ db, dbo }) =>
+            hook.run({
+              rows: applicableRows,
+              command,
+              context,
+              db,
+              dbo,
+              getClientDBHandlers: tableHandler.dboBuilder.prostgles.getClientDBHandlers,
+              localParams,
+            }),
+          ),
+        );
       }
     }
   } finally {

package/lib/ExecutionContext.ts

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import type { AuthClientRequest, SessionUser } from "./Auth/AuthTypes";
+import type { ViewHandler } from "./DboBuilder/ViewHandler/ViewHandler";
+
+export type FunctionInvocation = {
+  type: "function";
+  id: string;
+  functionName: string;
+  relatedRecords: {
+    argName: string;
+    tableName: string;
+    rowPart: Record<string, unknown>;
+  }[];
+};
+
+export type TriggerInvocation = {
+  type: "trigger";
+  id: string;
+  tableName: string;
+  rowParts: Record<string, unknown>[];
+};
+
+type Invocation = FunctionInvocation | TriggerInvocation;
+
+/** Correlation metadata only; database authorization still uses the explicit caller. */
+export type ExecutionContext = {
+  runId: string;
+  user: undefined | SessionUser["user"];
+  clientReq: undefined | AuthClientRequest;
+  /** Invocation ancestry, oldest first. Parallel branches have separate lists. */
+  invocations: Invocation[];
+};
+
+/** Record the row parts available to the hook, including rows without primary keys. */
+export const runTableHook = <T>(
+  table: ViewHandler,
+  rows: Record<string, unknown>[],
+  callback: () => T,
+): T => {
+  const prostgles = table.dboBuilder.prostgles;
+  const parent = createExecutionContext(prostgles.getExecution());
+  const invocation: TriggerInvocation = {
+    type: "trigger",
+    id: randomUUID(),
+    tableName: table.name,
+    rowParts: rows,
+  };
+  return prostgles.runWithExecution(
+    { ...parent, invocations: [...parent.invocations, invocation] },
+    callback,
+  );
+};
+
+export const createExecutionContext = (parent: ExecutionContext | undefined): ExecutionContext =>
+  parent ?? {
+    runId: randomUUID(),
+    invocations: [],
+    clientReq: undefined,
+    user: undefined,
+  };

package/lib/Prostgles.ts

@@ -1,4 +1,6 @@
 import { DB_GENERATED_NAMES } from "./DBSchemaBuilder/constants";
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { ExecutionContext } from "./ExecutionContext";
 import type pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
 import type { SessionUser } from "./Auth/AuthTypes";
@@ -6,10 +8,7 @@ import type { ContextCleanup, OnInitReason } from "./initProstgles";
 import { initProstgles } from "./initProstgles";
 import type { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { getClientSchema } from "./WebsocketAPI/getClientSchema";
-import {
-  getClientDBHandlers,
-  type GetClientDBHandlers,
-} from "./WebsocketAPI/getClientHandlers";
+import { getClientDBHandlers, type GetClientDBHandlers } from "./WebsocketAPI/getClientHandlers";
 import { onSocketConnected } from "./WebsocketAPI/onSocketConnected";
 import pg = require("pg-promise/typescript/pg-subset");
 
@@ -266,6 +265,10 @@ export class Prostgles {
   }
 
   context: unknown;
+  readonly executionStorage = new AsyncLocalStorage<ExecutionContext | undefined>();
+  getExecution = () => this.executionStorage.getStore();
+  runWithExecution = <T>(execution: ExecutionContext | undefined, callback: () => T): T =>
+    this.executionStorage.run(execution, callback);
   private contextCleanups: ContextCleanup[] = [];
 
   cleanupContext = async () => {
@@ -296,6 +299,7 @@ export class Prostgles {
         sql: this.dboBuilder.sql,
         tables: this.dboBuilder.tables,
         reason,
+        getExecution: this.getExecution,
         onCleanup: (cleanup) => cleanups.push(cleanup),
       });
       this.context = context;

package/lib/PubSubManager/init/getPubSubManagerInitQuery.ts

@@ -57,6 +57,8 @@ BEGIN; -- TRANSACTION ISOLATION LEVEL SERIALIZABLE;
 
 DO
 $do$
+DECLARE
+    reset_pubsub BOOLEAN := false;
 BEGIN
 
     /* Drop older version.  */
@@ -69,21 +71,21 @@ BEGIN
           ${PROSTGLES_SCHEMA_EXISTS_QUERY}
         )
       THEN
-        DROP SCHEMA IF EXISTS prostgles CASCADE;
+        reset_pubsub := true;
       ELSIF
         /* There is no newer version or same same version but different schema */
         NOT EXISTS (
           ${PROSTGLES_SCHEMA_VERSION_OK_QUERY}
         )
       THEN
-        DROP SCHEMA IF EXISTS prostgles CASCADE;
+        reset_pubsub := true;
 
       END IF;
 
     END IF;
 
 
-    IF NOT EXISTS (
+    IF reset_pubsub OR NOT EXISTS (
         SELECT 1 
         FROM information_schema.schemata 
         WHERE schema_name = 'prostgles'
@@ -93,6 +95,12 @@ BEGIN
         CREATE SCHEMA IF NOT EXISTS prostgles;
         COMMENT ON SCHEMA prostgles IS 'Used by prostgles-server to enable data/schema change tracking through subscribe/sync/watchSchema';
 
+        -- Keep application dependencies on the validator and helper functions intact.
+        DROP FUNCTION IF EXISTS ${DB_OBJ_NAMES.schema_watch_func}() CASCADE;
+        DROP FUNCTION IF EXISTS ${DB_OBJ_NAMES.data_watch_func}() CASCADE;
+        DROP FUNCTION IF EXISTS ${DB_OBJ_NAMES.trigger_add_remove_func}() CASCADE;
+        DROP TABLE IF EXISTS prostgles.app_triggers, prostgles.apps, prostgles.versions CASCADE;
+
         ${CREATE_VALIDATE_SCHEMA_FUNCTION_SQL}
 
         CREATE TABLE IF NOT EXISTS prostgles.versions(

package/lib/PublishParser/PublishParser.ts

@@ -36,6 +36,9 @@ import {
   type PublishObject,
 } from "./publishTypesAndUtils";
 import { validatePublishProfiles } from "./validatePublishProfiles";
+import { randomUUID } from "node:crypto";
+import { createExecutionContext } from "../ExecutionContext";
+import { getFunctionRelatedRecords } from "./getFunctionRelatedRecords";
 
 export class PublishParser {
   parsedPublish: ReturnType<typeof getParsedPublish>;
@@ -144,7 +147,20 @@ export class PublishParser {
           })();
 
           this.prostgles.checkNotDestroyed();
-          return method.run(args, ctx);
+          const parent = createExecutionContext(this.prostgles.getExecution());
+          const relatedRecords = getFunctionRelatedRecords(method.input, args);
+          return this.prostgles.runWithExecution(
+            {
+              ...parent,
+              user,
+              clientReq,
+              invocations: [
+                ...parent.invocations,
+                { type: "function", id: randomUUID(), functionName: name, relatedRecords },
+              ],
+            },
+            () => method.run(args, ctx),
+          );
         };
         allowedFunctionsMap.set(name, { ...method, run: runWithContext });
       }

package/lib/PublishParser/getFunctionRelatedRecords.ts

@@ -0,0 +1,25 @@
+import type { FunctionInvocation } from "../ExecutionContext";
+import type { ServerFunctionDefinition } from "./defineServerFunction";
+
+/** Capture top-level RowLookup/ValueLookup inputs without querying the database. */
+export const getFunctionRelatedRecords = (
+  input: ServerFunctionDefinition["input"],
+  args: Record<string, unknown> | undefined,
+): FunctionInvocation["relatedRecords"] => {
+  const records: FunctionInvocation["relatedRecords"] = [];
+  for (const [argName, schema] of Object.entries(input ?? {})) {
+    if (typeof schema !== "object" || !("table" in schema)) continue;
+    const isRow = schema.type === "RowLookup" || schema.type === "RowLookup[]";
+    const isValue = schema.type === "ValueLookup" || schema.type === "ValueLookup[]";
+    if (!isRow && !isValue) continue;
+    const value = args?.[argName];
+    if (value === undefined || value === null) continue;
+    const values: unknown[] = schema.type.endsWith("[]") ? (value as unknown[]) : [value];
+    for (const item of values) {
+      const rowPart =
+        "column" in schema ? { [schema.column]: item } : (item as Record<string, unknown>);
+      records.push({ argName, tableName: schema.table, rowPart });
+    }
+  }
+  return records;
+};

package/lib/index.ts

@@ -28,6 +28,7 @@ export const createProstgles = <
 };
 export * from "./PublishParser/defineServerFunction";
 export * from "./Auth/AuthTypes";
+export type { ExecutionContext, FunctionInvocation, TriggerInvocation } from "./ExecutionContext";
 
 export type {
   PublishContextValue,
@@ -42,10 +43,7 @@ export type {
   PublishProfile,
   PublishParams,
 } from "./PublishParser/publishTypesAndUtils";
-export type {
-  ClientDBHandlerRequest,
-  GetClientDBHandlers,
-} from "./WebsocketAPI/getClientHandlers";
+export type { ClientDBHandlerRequest, GetClientDBHandlers } from "./WebsocketAPI/getClientHandlers";
 export type { DBOFullyTyped, DBOFullyTypedClient } from "./DBSchemaBuilder/DBSchemaBuilder";
 export type { DBHandlerServer } from "./Prostgles";
 export type { StorageClient as CloudClient } from "./StorageClient/StorageClientTypes";

package/lib/initProstgles.ts

@@ -1,4 +1,5 @@
 import { syncTableTriggers } from "./TableConfig/syncTableTriggers";
+import type { ExecutionContext } from "./ExecutionContext";
 import { deferDbQueries } from "./deferDbQueries";
 import type pgPromise from "pg-promise";
 import type pg from "pg-promise/typescript/pg-subset";
@@ -18,10 +19,7 @@ import { runSQLFile } from "./TableConfig/runSQLFile";
 import { updateConfiguration, type clientOnlyUpdateKeys } from "./updateConfiguration";
 import { sleep } from "./utils/utils";
 import { getAdminClient } from "./DboBuilder/runSql/getAdminClient";
-import type {
-  ClientDBHandlerRequest,
-  GetClientDBHandlers,
-} from "./WebsocketAPI/getClientHandlers";
+import type { ClientDBHandlerRequest, GetClientDBHandlers } from "./WebsocketAPI/getClientHandlers";
 
 /**
  * Database connection details
@@ -93,6 +91,8 @@ export type OnReadyParams<S, Context = undefined> = OnReadyParamsCommon & {
 export type ContextCleanup = () => MaybePromise<void>;
 export type CreateContextParams<S> = OnReadyParamsCommon & {
   dbo: DBOFullyTyped<S>;
+  /** Read at call time; undefined outside a function, client operation, or table hook. */
+  getExecution: () => ExecutionContext | undefined;
   onCleanup: (cleanup: ContextCleanup) => void;
 };
 export type CreateContext<S, Context> = (params: CreateContextParams<S>) => MaybePromise<Context>;
@@ -324,6 +324,7 @@ export const initProstgles = async function (
         }
         this.restApi?.destroy();
         await this.cleanupContext();
+        this.executionStorage.disable();
         await this.dboBuilder.destroy();
         this.authHandler.destroy();
         await this.tableConfigurator?.destroy();

package/lib/runClientRequest.ts

@@ -12,10 +12,10 @@ import type { LocalParams } from "./DboBuilder/DboBuilder";
 import type { DbTxTableHandlers } from "./DboBuilder/DboBuilderTypes";
 import type { TableHandler as TableHandlerServer } from "./DboBuilder/TableHandler/TableHandler";
 import { canRunSQL } from "./DboBuilder/runSql/runSQL";
+import { createExecutionContext } from "./ExecutionContext";
 import type { Prostgles } from "./Prostgles";
 import type { ParsedTableRule } from "./PublishParser/publishTypesAndUtils";
 import { type PermissionScope } from "./PublishParser/publishTypesAndUtils";
-import { getAbortSignalKeys } from "./DboBuilder/ViewHandler/getDbHandlerWithAbort";
 
 const TABLE_METHODS = {
   find: 1,
@@ -184,13 +184,21 @@ export const runClientRequest = async function (
     undefined | TableMethodFunctionWithRulesAndLocalParams;
 
   this.checkNotDestroyed();
-  return (tableHandler[command] as TableMethodFunctionWithRulesAndLocalParams)(
-    param1,
-    param2,
-    param3,
-    parsedTableRule,
-    localParams,
-  ) as AnyObject | undefined;
+  return this.runWithExecution(
+    {
+      ...createExecutionContext(this.getExecution()),
+      user: clientInfo.user,
+      clientReq,
+    },
+    () =>
+      (tableHandler[command] as TableMethodFunctionWithRulesAndLocalParams)(
+        param1,
+        param2,
+        param3,
+        parsedTableRule,
+        localParams,
+      ) as AnyObject | undefined,
+  );
 };
 
 export const clientCanRunSqlRequest = async function (

package/package.json

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