prostgles-server 4.2.642 → 4.2.643

package/eslint.config.mjs

@@ -3,7 +3,18 @@ import tseslint from "typescript-eslint";
 
 export default tseslint.config(
   {
-    ignores: ["node_modules", "dist", "debug", "examples", "**/*.d.ts", "tests", "docs"],
+    ignores: [
+      "**/node_modules",
+      "**/dist",
+      "**/debug",
+      "examples",
+      "**/*.d.ts",
+      "docs",
+      "tests/**/*.js",
+      "tests/DBGeneratedSchema.ts",
+      "tests/config_test",
+      "tests/server/DEMO_SERVER.ts",
+    ],
   },
   eslint.configs.recommended,
   tseslint.configs.recommendedTypeChecked,
@@ -58,4 +69,13 @@ export default tseslint.config(
       ],
     },
   },
+  {
+    files: ["tests/**/*.ts"],
+    languageOptions: {
+      parserOptions: {
+        projectService: false,
+        project: ["./tests/server/tsconfig.json", "./tests/client/tsconfig.json"],
+      },
+    },
+  },
 );

package/lib/Auth/AuthTypes.ts

@@ -21,6 +21,7 @@ import type {
   FullFilter,
   IdentityProvider,
   LocalLoginMode,
+  MaybePromise,
   UserLike,
 } from "prostgles-types";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
@@ -210,7 +211,7 @@ export type LoginWithOAuthConfig<S> = {
     req: ExpressReq;
     res: ExpressRes;
     clientInfo: LoginClientInfo;
-  }) => Promise<
+  }) => MaybePromise<
     AuthResponse.OAuthRegisterSuccess | AuthResponse.OAuthRegisterFailure | AuthResponse.AuthFailure
   >;
 
@@ -225,7 +226,7 @@ export type LoginWithOAuthConfig<S> = {
     req: ExpressReq;
     res: ExpressRes;
     clientInfo: LoginClientInfo;
-  }) => void | Promise<void>;
+  }) => void | MaybePromise<void>;
 };
 
 export type SessionUser<

package/lib/DboBuilder/DboBuilder.ts

@@ -29,6 +29,7 @@ import {
   getCanExecute,
   getConstraints,
   getSerializedClientErrorFromPGError,
+  TX_KEY,
 } from "./dboBuilderUtils";
 import { prepareShortestJoinPaths } from "./joins/prepareShortestJoinPaths";
 import { cacheDBTypes, runSQL } from "./runSql/runSQL";
@@ -304,10 +305,14 @@ export class DboBuilder {
     });
 
     if (this.prostgles.opts.transactions) {
-      const txKey = "tx";
+      if (this.dboMap.has(TX_KEY)) {
+        throw new Error(
+          `Transaction key ${JSON.stringify(TX_KEY)} clashes with an existing table or view name`,
+        );
+      }
 
       //@ts-ignore
-      this.dbo[txKey] = <R, TH extends DbTxTableHandlers & Pick<DBHandlerServer, "sql">>(
+      this.dbo[TX_KEY] = <R, TH extends DbTxTableHandlers & Pick<DBHandlerServer, "sql">>(
         cb: TxCB<Promise<R>, TH>,
       ) => this.getTX(cb);
     }

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -203,3 +203,5 @@ export const withUserRLS = (
   const queryId = crypto.randomUUID();
   return [QUERY_ID_PREFIX + queryId, firstQuery, query].filter(Boolean).join("\n");
 };
+
+export const TX_KEY = "tx" as const;

package/lib/PublishParser/PublishParser.ts

@@ -129,10 +129,11 @@ export class PublishParser {
               };
               return unrestrictedCtx;
             }
-            const { clientDb } = await publishParams.getClientDBHandlers(undefined);
+            const { clientDb, withClientDbTx } = await publishParams.getClientDBHandlers(undefined);
             const { clientInfo, clientReq, tables } = publishParams;
             const restrictedCtx: RestrictedFunctionContext<void, SessionUser, unknown> = {
               dbo: clientDb,
+              withClientDbTx,
               user,
               clientInfo,
               clientReq,

package/lib/PublishParser/defineServerFunction.ts

@@ -11,6 +11,7 @@ import type { SessionUser } from "../Auth/AuthTypes";
 import type { DBOFullyTyped, DBOFullyTypedClient } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB } from "../initProstgles";
 import type { PublishParams } from "./publishTypesAndUtils";
+import type { ClientHandlers } from "../WebsocketAPI/getClientHandlers";
 
 type FunctionContextBase<S, SUser extends SessionUser, Context> = Pick<
   PublishParams<S, SUser>,
@@ -30,6 +31,7 @@ export type RestrictedFunctionContext<
   Context = undefined,
 > = FunctionContextBase<S, SUser, Context> & {
   dbo: DBOFullyTypedClient<S>;
+  withClientDbTx: ClientHandlers<S>["withClientDbTx"];
 };
 
 export type UnrestrictedFunctionContext<
@@ -55,11 +57,7 @@ export type ServerFunctionDefinition = {
 };
 
 declare const serverFunctionContext: unique symbol;
-export type ServerFunctionContextMarker<
-  S,
-  SUser extends SessionUser,
-  Context = undefined,
-> = {
+export type ServerFunctionContextMarker<S, SUser extends SessionUser, Context = undefined> = {
   [serverFunctionContext]?: [S, SUser, [Context] extends [undefined] ? never : Context];
 };
 

package/lib/PublishParser/getPublishedTableNames.ts

@@ -2,12 +2,13 @@ import { isObject } from "prostgles-types";
 import type { PublishParser } from "./PublishParser";
 import { type PublishObject } from "./PublishParser";
 import { getFileVersionTableName, isFileVersionTable } from "../StorageClient/fileVersionUtils";
+import { TX_KEY } from "../DboBuilder/dboBuilderUtils";
 
 export const getPublishedTableNames = (
   publishParserInstance: PublishParser,
   publishObject: PublishObject,
 ) => {
-  const txKey = !publishParserInstance.prostgles.opts.transactions ? "" : "tx";
+  const txKey = !publishParserInstance.prostgles.opts.transactions ? "" : TX_KEY;
   if (txKey && txKey in publishObject) {
     throw new Error(
       `Transactions key ${JSON.stringify(txKey)} collides with a published table name`,

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -127,7 +127,7 @@ export type AfterEachTsTrigger<R, DBX, Context = undefined, InputDataType = R> =
         localParams: undefined | LocalParams;
         context: Context;
       },
-  ) => Promise<void>;
+  ) => MaybePromise<void>;
 };
 
 export type ValidateRowsArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {

package/lib/StorageClient/StorageClientTypes.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from "prostgles-types";
 import type * as stream from "stream";
 
 export type LocalUploadedFileDetails = {
@@ -22,9 +23,9 @@ export type UploadFileOptions = {
   onProgress?: (bytesUploaded: number) => void;
 };
 export type StorageClientBase<T> = {
-  upload: (file: UploadFileOptions) => Promise<T>;
-  downloadAsStream: (name: string) => Promise<stream.Readable>;
-  delete: (fileName: string) => Promise<void>;
+  upload: (file: UploadFileOptions) => MaybePromise<T>;
+  downloadAsStream: (name: string) => MaybePromise<stream.Readable>;
+  delete: (fileName: string) => MaybePromise<void>;
 };
 export type LocalStorageClient = StorageClientBase<LocalUploadedFileDetails> & {
   type: "local";
@@ -32,6 +33,6 @@ export type LocalStorageClient = StorageClientBase<LocalUploadedFileDetails> & {
 };
 export type CloudStorageClient = StorageClientBase<CloudUploadedFileDetails> & {
   type: "cloud";
-  getSignedUrlForDownload: (fileName: string, expiresInSeconds: number) => Promise<string>;
+  getSignedUrlForDownload: (fileName: string, expiresInSeconds: number) => MaybePromise<string>;
 };
 export type StorageClient = LocalStorageClient | CloudStorageClient;

package/lib/WebsocketAPI/getClientHandlers.ts

@@ -1,4 +1,5 @@
 import {
+  getAllowedTableMethods,
   getKeys,
   type AnyObject,
   type ClientSchema,
@@ -8,6 +9,7 @@ import {
 } from "prostgles-types";
 import type { AuthClientRequest } from "../Auth/AuthTypes";
 import type { DBOFullyTypedClient } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { DbTxTableHandlers } from "../DboBuilder/DboBuilderTypes";
 import type { Prostgles } from "../Prostgles";
 import type { ServerFunctionDefinition } from "../PublishParser/defineServerFunction";
 import type { PermissionScope } from "../PublishParser/publishTypesAndUtils";
@@ -17,6 +19,11 @@ import { getClientSchema } from "./getClientSchema";
 export type ClientHandlers<S = void> = {
   clientSql: SQLHandler;
   clientDb: DBOFullyTypedClient<S>;
+  /**
+   * Runs permission-checked table operations in a transaction. Requires transactions: true.
+   * Caught table request errors also roll back the transaction.
+   */
+  withClientDbTx: <R>(callback: (clientDb: DBOFullyTypedClient<S>) => R | Promise<R>) => Promise<R>;
   clientMethods: Record<string, ServerFunctionDefinition>;
   clientSchema: ClientSchema;
 };
@@ -27,47 +34,74 @@ export const getClientHandlers = async <S = void>(
 ): Promise<ClientHandlers<S>> => {
   prostgles.checkNotDestroyed();
   const clientSchema =
-    clientReq.socket?.prostgles?.get(prostgles.appId) ??
+    (scope ? undefined : clientReq.socket?.prostgles?.get(prostgles.appId)) ??
     (await getClientSchema.bind(prostgles)(clientReq, scope));
+
   const sqlHandler: SQLHandler | undefined = ((
     query: string,
     params?: unknown,
     options?: SQLOptions,
   ) => runClientSqlRequest.bind(prostgles)({ query, params, options }, clientReq)) as SQLHandler;
-  const tableHandlers = Object.fromEntries(
-    prostgles.dboBuilder.tablesOrViews!.map((table) => {
-      const methods = [...tableMethods];
-      const handlers = Object.fromEntries(
-        methods.map((command) => {
-          const method = (param1: unknown, param2: unknown, param3: unknown) =>
-            runClientRequest.bind(prostgles)(
-              { command, tableName: table.name, param1, param2, param3 },
-              clientReq,
-              scope,
-            );
-          return [command, method];
-        }),
-      );
-      return [table.name, handlers];
-    }),
-  );
 
-  const txNotAllowed: {} = {
-    tx: () => {
-      throw new Error("Transactions are not allowed in client handlers");
-    },
-  };
+  const getTableHandlers = (
+    transactionHandlers?: DbTxTableHandlers,
+    onRequestError?: (error: unknown) => void,
+  ) =>
+    Object.fromEntries(
+      clientSchema.tableSchema.map((table) => {
+        const allowedMethods = getAllowedTableMethods(table);
+        const methods = tableMethods.filter((command) => allowedMethods.includes(command));
+        const handlers = Object.fromEntries(
+          methods.map((command) => {
+            const method = (param1: unknown, param2: unknown, param3: unknown) =>
+              runClientRequest
+                .bind(prostgles)(
+                  { command, tableName: table.name, param1, param2, param3 },
+                  clientReq,
+                  scope,
+                  transactionHandlers,
+                )
+                .catch((error: unknown) => {
+                  onRequestError?.(error);
+                  throw error;
+                });
+            return [command, method];
+          }),
+        );
+        return [table.name, handlers];
+      }),
+    );
+
   const clientSql = ((query: string, params?: AnyObject, options?: SQLOptions) => {
     if (scope && !scope.allowSql) {
-      throw new Error("SQL is dissallowed by PermissionScope");
+      throw new Error("SQL is disallowed by PermissionScope");
     }
 
     return sqlHandler(query, params, options);
   }) as SQLHandler;
-  const clientDb = {
-    ...tableHandlers,
-    ...txNotAllowed,
-  } as DBOFullyTypedClient<S>;
+
+  const clientDb = getTableHandlers() as unknown as DBOFullyTypedClient<S>;
+
+  const withClientDbTx: ClientHandlers<S>["withClientDbTx"] = async (callback) => {
+    prostgles.checkNotDestroyed();
+    if (!prostgles.opts.transactions) {
+      throw new Error("Transactions are not enabled");
+    }
+    return prostgles.dboBuilder.getTX(async (transactionHandlers) => {
+      /**
+       * runClientRequest throws authorization errors.
+       * Prevent cached authorization errors from committing the transaction.
+       */
+      let failure: { error: unknown } | undefined;
+      const result = await callback({
+        ...getTableHandlers(transactionHandlers, (error) => {
+          failure ??= { error };
+        }),
+      } as unknown as DBOFullyTypedClient<S>);
+      if (failure) throw failure.error;
+      return result;
+    });
+  };
 
   const clientMethods: Record<string, ServerFunctionDefinition> = Object.fromEntries(
     clientSchema.methods.map(({ name, input, description, output }) => {
@@ -81,7 +115,7 @@ export const getClientHandlers = async <S = void>(
     }),
   );
 
-  return { clientDb, clientSql, clientMethods, clientSchema };
+  return { clientDb, clientSql, clientMethods, clientSchema, withClientDbTx };
 };
 
 const tableMethods = getKeys({

package/lib/index.ts

@@ -3,6 +3,7 @@ import type { SessionUser } from "./Auth/AuthTypes";
 import type { InitResult, OnReadyCallbackBasic } from "./initProstgles";
 import { Prostgles } from "./Prostgles";
 import type { ProstglesInitOptions } from "./ProstglesTypes";
+export { DB_GENERATED_NAMES } from "./DBSchemaBuilder/constants";
 
 function prostgles<
   S = void,
@@ -22,9 +23,8 @@ export const createProstgles = <
   SUser extends SessionUser = SessionUser,
   ClientSchema = S,
 >() => {
-  return <Context = undefined>(
-    params: ProstglesInitOptions<S, SUser, Context>,
-  ) => prostgles<S, SUser, Context, ClientSchema>(params);
+  return <Context = undefined>(params: ProstglesInitOptions<S, SUser, Context>) =>
+    prostgles<S, SUser, Context, ClientSchema>(params);
 };
 export * from "./PublishParser/defineServerFunction";
 export * from "./Auth/AuthTypes";

package/lib/runClientRequest.ts

@@ -9,6 +9,7 @@ import {
 import type { AuthClientRequest } from "./Auth/AuthTypes";
 import { getSessionUser } from "./Auth/utils/getSessionUser";
 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 type { Prostgles } from "./Prostgles";
@@ -64,6 +65,7 @@ export const runClientRequest = async function (
   nonValidatedArgs: Args,
   clientReq: AuthClientRequest,
   scope: PermissionScope | undefined,
+  transactionHandlers?: DbTxTableHandlers,
 ) {
   this.checkNotDestroyed();
   /* Channel name will only include client-sent params so we ignore table_rules enforced params */
@@ -102,7 +104,9 @@ export const runClientRequest = async function (
     );
   }
 
-  const tableHandler = this.dboBuilder.dboMap.get(tableName);
+  const tableHandler = transactionHandlers ?
+    (Object.hasOwn(transactionHandlers, tableName) ? transactionHandlers[tableName] : undefined)
+  : this.dboBuilder.dboMap.get(tableName);
   if (!tableHandler) {
     throw `tableName ${tableName} is invalid or not allowed`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.642",
+  "version": "4.2.643",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,8 +11,10 @@
     "prepare": "npm run build",
     "start": "tsc --watch",
     "build": "tsc",
-    "lint": "eslint . --ext .ts --quiet --fix",
-    "test:lib": "rm -rf ./node_modules/* && rm -rf ./dist/* && npm i && npm run lint && tsc && node --trace-uncaught --test dist/**/*.spec.js",
+    "typecheck": "tsc --noEmit && npm run typecheck:tests",
+    "typecheck:tests": "tsc --noEmit -p tests/server && tsc --noEmit -p tests/client",
+    "lint": "eslint . --ext .ts --quiet",
+    "test:lib": "rm -rf ./node_modules/* && rm -rf ./dist/* && npm i && npm run lint -- --ignore-pattern tests && tsc && node --trace-uncaught --test dist/**/*.spec.js",
     "test-only": "cd tests/ && ./test.sh",
     "test-quick": "cd tests/ && ./test.sh -quick",
     "test": "npm run test:lib && npm run test-only",