prostgles-server 4.2.587 → 4.2.588

package/lib/PublishParser/defineServerFunction.ts

@@ -1,111 +1,99 @@
-import type { JSONB, JSONBObjectTypeIfDefined, MaybePromise } from "prostgles-types";
+import type {
+  AnyObject,
+  DBSchema,
+  FullFilter,
+  JSONB,
+  JSONBObjectTypeIfDefined,
+  MaybePromise,
+  SQLHandler,
+} from "prostgles-types";
 import type { SessionUser } from "../Auth/AuthTypes";
+import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { DB } from "../initProstgles";
 import type { PublishParams } from "./publishTypesAndUtils";
 
-export type ServerFunctionDefinition = {
-  input?: Record<string, JSONB.FieldType> | undefined;
-  description?: string;
-  /**
-   * undefined if not allowed
-   */
-  run: undefined | ((args: Record<string, unknown> | undefined) => MaybePromise<unknown>);
+type FunctionContextBase<S, SUser extends SessionUser> = Pick<
+  PublishParams<S, SUser>,
+  "tables" | "clientReq" | "clientInfo"
+> & {
+  dbo: DBOFullyTyped<S>;
+  user: S extends DBSchema ?
+    S["users"]["columns"] extends AnyObject ?
+      Required<S["users"]["columns"]>
+    : SUser["user"]
+  : SUser["user"];
 };
 
-export const defineServerFunction = <
-  TInput extends Record<string, JSONB.FieldType> | undefined = undefined,
->(args: {
-  input?: TInput;
-  description?: string;
-  /**
-   * undefined if not allowed
-   */
-  run: undefined | ((args: JSONBObjectTypeIfDefined<TInput>) => MaybePromise<unknown>);
-}) => args as unknown as ServerFunctionDefinition;
-
-export type ServerFunctionDefinitions<S = void, SUser extends SessionUser = SessionUser> = (
-  /**
-   * params will be undefined on first run to generate the definitions
-   */
-  params: undefined | PublishParams<S, SUser>,
-) => MaybePromise<Record<string, ServerFunctionDefinition>>;
+export type RestrictedFunctionContext<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+> = FunctionContextBase<S, SUser>;
 
-export const createServerFunctionWithContext = <Context>(
-  /**
-   * undefined if not allowed
-   */
-  context: Context | undefined,
-) => {
-  return <
-    Input extends Record<string, JSONB.FieldType> | undefined,
-    Run extends (args: JSONBObjectTypeIfDefined<Input>, context: Context) => MaybePromise<any>,
-  >(args: {
-    input?: Input;
-    description?: string;
-    run: Run;
-  }) =>
-    ({
-      ...args,
-      run:
-        context === undefined ? undefined : (
-          (validatedArgs: any) => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return args.run(validatedArgs, context) as Run;
-          }
-        ),
-    }) satisfies ServerFunctionDefinition;
+export type UnrestrictedFunctionContext<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+> = FunctionContextBase<S, SUser> & {
+  db: DB;
+  sql: SQLHandler;
 };
 
-type InputOf<T> = T extends { input?: infer I } ? I : undefined;
-
-// if inference fails or is invalid → fall back to undefined
-type SafeInput<I> = I extends Record<string, JSONB.FieldType> ? I : undefined;
+export type ServerFunctionContext = RestrictedFunctionContext | UnrestrictedFunctionContext;
 
-type ServerFunctionArgsFrom<Context, Def> = {
-  input?: InputOf<Def>;
+export type ServerFunctionDefinition = {
+  input?: Record<string, JSONB.FieldType>;
   description?: string;
-  run: (
-    args: JSONBObjectTypeIfDefined<SafeInput<InputOf<Def>>>,
-    context: Context,
-  ) => MaybePromise<any>;
+  unrestrictedDbAccess?: true;
+  run: (...args: any[]) => MaybePromise<unknown>;
 };
 
-type ServerFunctionBlock<Context, Defs> = {
-  [K in keyof Defs]: ServerFunctionArgsFrom<Context, Defs[K]>;
+type DefineFunctionArgs<
+  TInput extends Record<string, JSONB.FieldType> | undefined,
+  Context,
+  Return,
+> = {
+  input?: TInput;
+  description?: string;
+  run: (args: JSONBObjectTypeIfDefined<TInput>, context: Context) => MaybePromise<Return>;
 };
 
-type WrappedDef<Context, Def> =
-  Def extends (
-    {
-      input?: infer I;
-      description?: infer D;
-      run: (a: any, c: Context) => infer R;
-    }
-  ) ?
-    {
-      input?: SafeInput<I>;
-      description?: D extends string ? D : string | undefined;
-      run: undefined | ((a: any) => R); // keep return type, widen args
-    }
-  : never;
+export function defineFunction<
+  TInput extends Record<string, JSONB.FieldType> | undefined = undefined,
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Return = unknown,
+>(
+  args: DefineFunctionArgs<TInput, UnrestrictedFunctionContext<S, SUser>, Return> & {
+    unrestrictedDbAccess: true;
+  },
+): typeof args;
 
-type WrappedBlock<Context, Defs> = {
-  [K in keyof Defs]: WrappedDef<Context, Defs[K]>;
-};
+export function defineFunction<
+  TInput extends Record<string, JSONB.FieldType> | undefined = undefined,
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Return = unknown,
+>(
+  args: DefineFunctionArgs<TInput, RestrictedFunctionContext<S, SUser>, Return> & {
+    unrestrictedDbAccess?: undefined;
+  },
+): typeof args;
+export function defineFunction(args: unknown) {
+  return args;
+}
 
-export const createServerFunctionBlockWithContext = <Context>(context: Context | undefined) => {
-  return <const Defs extends Record<string, any>>(
-    defs: Defs & ServerFunctionBlock<Context, Defs>,
-  ): WrappedBlock<Context, Defs> => {
-    const wrapped = {} as WrappedBlock<Context, Defs>;
+type UsersTableRow<S> =
+  S extends DBSchema ?
+    S extends { users: { columns: infer UserRow extends AnyObject } } ?
+      UserRow
+    : AnyObject
+  : AnyObject;
 
-    for (const key in defs) {
-      const def = defs[key];
-      wrapped[key] = {
-        ...def,
-        run: context === undefined ? undefined : (args: any) => def.run(args, context),
-      };
-    }
+type ValidDbSchema<S> = S extends DBSchema ? S : void;
 
-    return wrapped satisfies Record<string, ServerFunctionDefinition>;
-  };
-};
+export type ServerFunctionDefinitions<S = void> = Record<
+  string,
+  {
+    userFilter: FullFilter<UsersTableRow<S>, ValidDbSchema<S>>;
+    functions: Record<string, ServerFunctionDefinition>;
+  }
+>;

package/lib/runClientRequest.ts

@@ -280,7 +280,8 @@ export const runClientMethod = async function (
     throw message;
   }
 
-  const res = await functionDefinition.run(input as never);
+  /** Allowed functions are wrapped with their request context by PublishParser. */
+  const res = await functionDefinition.run(input as never, undefined);
 
   return res;
 };

package/package.json

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