prostgles-server 4.2.602 → 4.2.604

package/lib/DboBuilder/TableHandler/delete.ts

@@ -125,7 +125,11 @@ export async function _delete(
     //   }
     // }
 
-    const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
+    const queryWithRLS = withUserRLS(
+      localParams,
+      queryWithoutRLS,
+      !!this.getTransaction(localParams),
+    );
 
     const queryToReturn = await getReturnTypeQuery({
       handler: this,
@@ -155,6 +159,9 @@ export async function _delete(
           "onInsteadOfDelete requires a transaction. Please wrap the delete call in a transaction.",
         );
       }
+      if (localParams?.isRemoteRequest) {
+        await transaction.t.none(withUserRLS(localParams, ""));
+      }
       const result = await onInsteadOfDelete({
         context: this.dboBuilder.prostgles.context,
         queryType,

package/lib/DboBuilder/TableHandler/insert/insert.ts

@@ -164,7 +164,7 @@ export async function insert(
     }
 
     const queryWithoutUserRLS = query;
-    const queryWithRLS = withUserRLS(localParams, query);
+    const queryWithRLS = withUserRLS(localParams, query, !!this.getTransaction(localParams));
 
     const queryToReturn = await getReturnTypeQuery({
       handler: this,

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -65,7 +65,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
     checkCondition = `NOT (${checkCond.where})`;
   }
   const hasReturning = !!returningSelectItems.length;
-  const userRLS = withUserRLS(localParams, "");
+  const userRLS = withUserRLS(localParams, "", !!tableHandler.getTransaction(localParams));
   const CHECK_CONDITION_ALIAS = "prostgles_check_condition";
   const RETURNING_ALIAS_PREFIX = "prostgles_returning_";
   const returningSelectKeyRemap = new Map<string, string>();

package/lib/DboBuilder/TableHandler/update.ts

@@ -166,7 +166,7 @@ export async function update(
     ).getQuery();
     query += "\n" + updateFilter.where;
     const queryWithoutUserRLS = query;
-    query = withUserRLS(localParams, query);
+    query = withUserRLS(localParams, query, !!this.getTransaction(localParams));
 
     const queryToReturn = await getReturnTypeQuery({
       handler: this,

package/lib/DboBuilder/TableHandler/updateBatch.ts

@@ -37,7 +37,10 @@ export async function updateBatch(
         return query;
       }),
     );
-    const queries = [withUserRLS(localParams, ""), ...updateQueries];
+    const queries = [
+      withUserRLS(localParams, "", !!this.getTransaction(localParams)),
+      ...updateQueries,
+    ];
 
     const queryToReturn = await getReturnTypeQuery({
       handler: this,

package/lib/DboBuilder/ViewHandler/count.ts

@@ -41,7 +41,11 @@ export async function count(
         ${findQuery}
         ) t 
       `;
-      const queryWithRLS = withUserRLS(localParams, queryWithoutUserRLS);
+      const queryWithRLS = withUserRLS(
+        localParams,
+        queryWithoutUserRLS,
+        !!this.getTransaction(localParams),
+      );
 
       const queryToReturn = await getReturnTypeQuery({
         handler: this,

package/lib/DboBuilder/ViewHandler/find.ts

@@ -113,7 +113,11 @@ export const find = async function (
       !!selectParamsLimitCheck.groupBy,
     );
 
-    const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
+    const queryWithRLS = withUserRLS(
+      localParams,
+      queryWithoutRLS,
+      !!this.getTransaction(localParams),
+    );
 
     const queryToReturn = await getReturnTypeQuery({
       handler: this,

package/lib/DboBuilder/ViewHandler/size.ts

@@ -44,7 +44,11 @@ export async function size(
           ${selectQueryWithoutRLS}
         ) prgl_size_query
       `;
-      const queryWithRLS = withUserRLS(localParams, queryWithoutUserRLS);
+      const queryWithRLS = withUserRLS(
+        localParams,
+        queryWithoutUserRLS,
+        !!this.getTransaction(localParams),
+      );
 
       const queryToReturn = await getReturnTypeQuery({
         handler: this,

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -92,6 +92,7 @@ async function subscribe(
         { actions, skipFirst, throttle, throttleOpts, skipChangedColumnsCheck },
         table_rules?.select,
       ),
+      localParams,
       lastPushed: 0,
       tracked_columns: !firstField ? undefined : [firstField, ...otherFields],
       pushRequestedVersion: 0,

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -178,13 +178,22 @@ export const getCanExecute = async (db: DB) => {
 
 export const QUERY_ID_PREFIX = "-- prostgles query id: ";
 
-export const withUserRLS = (localParams: LocalParams | undefined, query: string) => {
+export const withUserRLS = (
+  localParams: LocalParams | undefined,
+  query: string,
+  inTransaction = false,
+) => {
   const user = localParams?.isRemoteRequest?.user;
-  const queryPrefix = `SET SESSION "prostgles.user" \nTO`;
+  const queryPrefix = `SET LOCAL "prostgles.user" \nTO`;
   let firstQuery = `${queryPrefix} '';`;
   if (user) {
     firstQuery = pgp.as.format(`${queryPrefix} \${user};`, { user });
   }
+  // Local calls through a transaction's dbx must preserve its request context.
+  // Anonymous remote requests still explicitly clear the user.
+  if (inTransaction && !localParams?.isRemoteRequest) {
+    firstQuery = "";
+  }
 
   const queryId = crypto.randomUUID();
   return [QUERY_ID_PREFIX + queryId, firstQuery, query].filter(Boolean).join("\n");

package/lib/DboBuilder/prepareShortestJoinPaths.spec.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { DboBuilder } from "./DboBuilder";
+import { prepareShortestJoinPaths } from "./prepareShortestJoinPaths";
+
+void test("configured joins are deferred only during table configuration", async () => {
+  const builder = {
+    prostgles: { preparingTableConfig: true, opts: { joins: [
+      { tables: ["conditions", "members"], on: [{ project_id: "project_id" }], type: "many-many" },
+    ] } },
+    tablesOrViews: [],
+  } as unknown as DboBuilder;
+  assert.deepEqual((await prepareShortestJoinPaths(builder)).joins, []);
+  builder.prostgles.preparingTableConfig = false;
+  await assert.rejects(prepareShortestJoinPaths(builder), (error: unknown) =>
+    typeof error === "string" && error.includes("Table not found: conditions")
+  );
+});
+
+void test("existing configured joins remain available during table configuration", async () => {
+  const join = { tables: ["conditions", "members"], on: [{ project_id: "project_id" }], type: "many-many" };
+  const builder = {
+    prostgles: { preparingTableConfig: true, opts: { joins: [join] } },
+    tablesOrViews: ["conditions", "members"].map((name) => ({ name, columns: [{ name: "project_id" }] })),
+  } as unknown as DboBuilder;
+  assert.deepEqual((await prepareShortestJoinPaths(builder)).joins, [join]);
+  builder.prostgles.preparingTableConfig = false;
+  assert.deepEqual((await prepareShortestJoinPaths(builder)).joins, [join]);
+});

package/lib/DboBuilder/prepareShortestJoinPaths.ts

@@ -18,6 +18,19 @@ export async function prepareShortestJoinPaths(dboBuilder: DboBuilder): Promise<
       throw new Error("Could not create join config. this.tablesOrViews missing");
     }
 
+    // The initial DBO is needed by tableConfig before its tables/columns exist.
+    // Defer only joins that cannot be resolved yet; the final rebuild validates all.
+    if (Array.isArray(joinConfig) && dboBuilder.prostgles.preparingTableConfig) {
+      const tables = dboBuilder.tablesOrViews;
+      joinConfig = joinConfig.filter((join) => join.tables.every((name, index) => {
+        const table = tables.find((candidate) => candidate.name === name);
+        return table && join.on.every((on) =>
+          (index === 0 ? Object.keys(on) : Object.values(on)).every((column) =>
+            table.columns.some((candidate) => candidate.name === column)
+          )
+        );
+      }));
+    }
     const inferredJoins = await getInferredJoins2(dboBuilder.tablesOrViews);
     if (joinConfig === "inferred") {
       joinConfig = inferredJoins;

package/lib/Prostgles.ts

@@ -106,6 +106,7 @@ export class Prostgles {
 
   keywords = DEFAULT_KEYWORDS;
   loaded = false;
+  preparingTableConfig = false;
 
   dbEventsManager?: DBEventsManager;
   schemaAge = "0";

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/StorageClient/getFileTableConfig.spec.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { Prostgles } from "../Prostgles";
+import { getFileTableConfig } from "./getFileTableConfig";
+
+void test("managed files preserve hooks on other tables and append file hooks", () => {
+  const guard = { afterEach: [{ commands: { insert: 1 }, validate: async () => {} }] };
+  const fileGuard = { beforeEach: [{ commands: { insert: 1 }, validate: async () => {} }] };
+  const prostgles = {
+    opts: {
+      fileTable: { tableName: "files", storageClient: {}, expressApp: {} },
+      tableHooks: { documents: guard, files: fileGuard },
+    },
+  } as unknown as Prostgles;
+  const result = getFileTableConfig(prostgles);
+  assert.equal(result.tableHooks?.documents, guard);
+  assert.equal(result.tableHooks.files?.beforeEach?.length, 2);
+  assert.equal(result.tableHooks.files.beforeEach[1], fileGuard.beforeEach[0]);
+});

package/lib/StorageClient/getFileTableConfig.ts

@@ -103,6 +103,7 @@ export const getFileTableConfig = (
 
   const userFileTableHooks = tableHooks?.[fileTableName];
   const mergedTableHooks: TableHooks<void, any> = {
+    ...tableHooks,
     [fileTableName]: {
       ...userFileTableHooks,
       beforeEach: [

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/initTableConfig.ts

@@ -162,7 +162,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 +172,8 @@ export const initTableConfig = async function (this: TableConfigurator) {
         })
       );
 
-    if (coldef) {
-      queries.push(coldef.fullQuery);
+    if (tableColumnDefinition) {
+      queries.push(tableColumnDefinition.fullQuery);
     }
 
     /** CONSTRAINTS */
@@ -181,13 +181,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) => ({

package/lib/initProstgles.ts

@@ -223,8 +223,14 @@ export const initProstgles = async function (
 
     /* 2. Execute any SQL file if provided */
     await runSQLFile(this);
-    await this.rebuildDBO();
-    await this.initTableConfig(reason);
+    this.preparingTableConfig = true;
+    try {
+      await this.rebuildDBO();
+      await this.initTableConfig(reason);
+    } finally {
+      this.preparingTableConfig = false;
+    }
+    // Validate all configured joins against the completed schema before publishing.
     await this.rebuildDBO();
     await this.createContext(reason);
     this.initRestApi();

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.602",
+  "version": "4.2.604",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",