prostgles-server 4.2.598 → 4.2.600

package/lib/ProstglesContext.spec.ts

@@ -0,0 +1,76 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import type { DboBuilder } from "./DboBuilder/DboBuilder";
+import { Prostgles } from "./Prostgles";
+
+void describe("Prostgles context", async () => {
+  await test("recreates context and runs cleanups in reverse order", async () => {
+    const events: string[] = [];
+    let contextId = 0;
+    const prostgles = new Prostgles({
+      dbConnection: "postgres://unused",
+      onReady: () => {},
+      createContext: ({ onCleanup }) => {
+        const id = ++contextId;
+        events.push(`create:${id}`);
+        onCleanup(() => {
+          events.push(`cleanup:first:${id}`);
+        });
+        onCleanup(() => {
+          events.push(`cleanup:second:${id}`);
+        });
+        return { id };
+      },
+    });
+    prostgles.db = {} as typeof prostgles.db;
+    prostgles.dboBuilder = {
+      build: async () => {},
+      dbo: {},
+      sql: {},
+      tables: [],
+    } as unknown as DboBuilder;
+
+    await prostgles.refreshDBO();
+    assert.deepEqual(prostgles.context, { id: 1 });
+    await prostgles.refreshDBO();
+    assert.deepEqual(prostgles.context, { id: 2 });
+    await prostgles.cleanupContext();
+
+    assert.deepEqual(events, [
+      "create:1",
+      "cleanup:second:1",
+      "cleanup:first:1",
+      "create:2",
+      "cleanup:second:2",
+      "cleanup:first:2",
+    ]);
+    assert.equal(prostgles.context, undefined);
+  });
+
+  await test("cleans partially-created context after an error", async () => {
+    const events: string[] = [];
+    const prostgles = new Prostgles({
+      dbConnection: "postgres://unused",
+      onReady: () => {},
+      createContext: ({ onCleanup }) => {
+        onCleanup(() => {
+          events.push("cleanup");
+        });
+        throw new Error("create failed");
+      },
+    });
+    prostgles.db = {} as typeof prostgles.db;
+    prostgles.dbo = {};
+    prostgles.dboBuilder = {
+      sql: {},
+      tables: [],
+    } as unknown as DboBuilder;
+
+    await assert.rejects(
+      prostgles.createContext({ type: "init" }),
+      /create failed/,
+    );
+    assert.deepEqual(events, ["cleanup"]);
+    assert.equal(prostgles.context, undefined);
+  });
+});

package/lib/ProstglesTypes.ts

@@ -6,7 +6,7 @@ import type {
   SessionUser,
 } from "./Auth/AuthTypes";
 import type { EventTriggerTagFilter } from "./Event_Trigger_Tags";
-import type { DbConnection, OnReadyCallback } from "./initProstgles";
+import type { CreateContext, DbConnection, OnReadyCallback } from "./initProstgles";
 import type { EventInfo } from "./Logging";
 import type { RestApiConfig } from "./RestApi";
 import type { OnSchemaChangeCallback } from "./SchemaWatch/SchemaWatch";
@@ -102,7 +102,11 @@ type ModifyClientSchema<SUser extends SessionUser = SessionUser> = (
   userData: AuthResultWithSID<SUser> | undefined,
 ) => MaybePromise<DBSchemaTable>;
 
-export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUser> = {
+export type ProstglesInitOptions<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+> = {
   /**
    * Database connection details and options
    */
@@ -112,7 +116,14 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
    * Called when the prostgles server is ready to accept connections.
    * It waits for auth, tableConfig and other async configurations to complete before executing
    */
-  onReady: OnReadyCallback<S, SUser>;
+  onReady: OnReadyCallback<S, SUser, Context>;
+
+  /**
+   * Creates instance-scoped dependencies after the database object is ready.
+   * The returned context is available to onReady, server functions, and table hooks.
+   * Registered cleanups run in reverse order before context replacement and destruction.
+   */
+  createContext?: CreateContext<S, Context>;
 
   /**
    * Path to the directory where the generated types (`DBGeneratedSchema.d.ts`) will be saved.
@@ -181,7 +192,7 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
   /**
    * Server-side functions that can be invoked by the client
    */
-  functions?: ServerFunctionDefinitions<S, SUser>;
+  functions?: ServerFunctionDefinitions<S, SUser, Context>;
 
   /**
    * If true then will test all table methods on each socket connect.
@@ -311,7 +322,7 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
   /**
    * Allows defining hooks for table events such as insert, update, delete and select.
    */
-  tableHooks?: TableHooks<S>;
+  tableHooks?: TableHooks<S, Context>;
 
   /**
    * Useful for logging or debugging

package/lib/PublishParser/PublishParser.ts

@@ -1,6 +1,6 @@
 import { getObjectEntries, includes, SQL_COMMAND_TABLE_METHODS } from "prostgles-types";
 import { getClientRequestIPsInfo } from "../Auth/AuthHandler";
-import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
+import type { AuthClientRequest, AuthResultWithSID, SessionUser } from "../Auth/AuthTypes";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 import type { ProstglesInitOptions } from "../ProstglesTypes";
@@ -27,7 +27,7 @@ import {
 } from "./publishTypesAndUtils";
 
 export class PublishParser {
-  publish: ProstglesInitOptions["publish"];
+  publish: ProstglesInitOptions<void, SessionUser, any>["publish"];
   publishRawSQL?: any;
   dbo: DBHandlerServer;
   db: DB;
@@ -106,20 +106,22 @@ export class PublishParser {
         const runWithContext = async (args: Record<string, unknown> | undefined) => {
           const ctx = await (async () => {
             if (method.unrestrictedDbAccess) {
-              const unrestrictedCtx: UnrestrictedFunctionContext = {
+              const unrestrictedCtx: UnrestrictedFunctionContext<void, SessionUser, unknown> = {
                 ...publishParams,
                 user,
+                context: this.prostgles.context,
               };
               return unrestrictedCtx;
             }
             const { clientDb } = await publishParams.getClientDBHandlers(undefined);
             const { clientInfo, clientReq, tables } = publishParams;
-            const restrictedCtx: RestrictedFunctionContext = {
+            const restrictedCtx: RestrictedFunctionContext<void, SessionUser, unknown> = {
               dbo: clientDb as unknown as DBOFullyTyped<void>,
               user,
               clientInfo,
               clientReq,
               tables,
+              context: this.prostgles.context,
             };
             return restrictedCtx;
           })();

package/lib/PublishParser/defineServerFunction.spec.ts

@@ -2,8 +2,11 @@ import { describe, test } from "node:test";
 import {
   defineFunction,
   createFunctionGroupDefiner,
+  createFunctionGroupDefinerWithContext,
   createFunctionsDefiner,
 } from "./defineServerFunction";
+import type { TableHooks } from "../TableHooks/TableHooks";
+import { createProstgles } from "../index";
 
 type TestSchema = {
   items: {
@@ -58,5 +61,50 @@ void describe("defineFunction type test", async () => {
 
     // @ts-expect-error A group must have a user filter.
     defineTestFunctionGroup({ functions });
+
+    type AppContext = {
+      serviceManager: { getService: (name: string) => string };
+    };
+    const defineContextFunctions =
+      createFunctionGroupDefinerWithContext<TestSchema, AppContext>();
+    defineContextFunctions({
+      userFilter: { type: "public" },
+      functions: {
+        getContextItem: defineFunction({
+          run: (_args, { context, dbo }) => {
+            void dbo.items.find();
+            return context.serviceManager.getService("documents");
+          },
+        }),
+      },
+    });
+
+    const contextualHooks: TableHooks<TestSchema, AppContext> = {
+      items: {
+        afterEach: [
+          {
+            commands: { insert: 1 },
+            validate: ({ context }) => {
+              context.serviceManager.getService("documents");
+              return Promise.resolve();
+            },
+          },
+        ],
+      },
+    };
+    contextualHooks satisfies TableHooks<TestSchema, AppContext>;
+
+    const startTestProstgles = createProstgles<TestSchema>();
+    const inferredContextTypeTest = () =>
+      startTestProstgles({
+        dbConnection: "postgres://unused",
+        createContext: () => ({
+          serviceManager: { getService: (name: string) => name },
+        }),
+        onReady: ({ context }) => {
+          context.serviceManager.getService("documents");
+        },
+      });
+    void inferredContextTypeTest;
   });
 });

package/lib/PublishParser/defineServerFunction.ts

@@ -12,10 +12,11 @@ import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB } from "../initProstgles";
 import type { PublishParams } from "./publishTypesAndUtils";
 
-type FunctionContextBase<S, SUser extends SessionUser> = Pick<
+type FunctionContextBase<S, SUser extends SessionUser, Context> = Pick<
   PublishParams<S, SUser>,
   "tables" | "clientReq" | "clientInfo"
 > & {
+  context: Context;
   dbo: DBOFullyTyped<S>;
   user: S extends DBSchema ?
     S["users"]["columns"] extends AnyObject ?
@@ -27,18 +28,22 @@ type FunctionContextBase<S, SUser extends SessionUser> = Pick<
 export type RestrictedFunctionContext<
   S = void,
   SUser extends SessionUser = SessionUser,
-> = FunctionContextBase<S, SUser>;
+  Context = undefined,
+> = FunctionContextBase<S, SUser, Context>;
 
 export type UnrestrictedFunctionContext<
   S = void,
   SUser extends SessionUser = SessionUser,
-> = FunctionContextBase<S, SUser> & {
+  Context = undefined,
+> = FunctionContextBase<S, SUser, Context> & {
   db: DB;
   sql: SQLHandler;
   getClientDBHandlers: PublishParams<S, SUser>["getClientDBHandlers"];
 };
 
-export type ServerFunctionContext = RestrictedFunctionContext | UnrestrictedFunctionContext;
+export type ServerFunctionContext =
+  | RestrictedFunctionContext<void, SessionUser, unknown>
+  | UnrestrictedFunctionContext<void, SessionUser, unknown>;
 
 export type ServerFunctionDefinition = {
   input?: Record<string, JSONB.FieldType>;
@@ -48,8 +53,12 @@ export type ServerFunctionDefinition = {
 };
 
 declare const serverFunctionContext: unique symbol;
-export type ServerFunctionContextMarker<S, SUser extends SessionUser> = {
-  [serverFunctionContext]?: [S, SUser];
+export type ServerFunctionContextMarker<
+  S,
+  SUser extends SessionUser,
+  Context = undefined,
+> = {
+  [serverFunctionContext]?: [S, SUser, Context];
 };
 
 type DefineFunctionArgs<
@@ -67,22 +76,24 @@ export function defineFunction<
   S = void,
   SUser extends SessionUser = SessionUser,
   Return = unknown,
+  Context = undefined,
 >(
-  args: DefineFunctionArgs<TInput, UnrestrictedFunctionContext<S, SUser>, Return> & {
+  args: DefineFunctionArgs<TInput, UnrestrictedFunctionContext<S, SUser, Context>, Return> & {
     unrestrictedDbAccess: true;
   },
-): typeof args & ServerFunctionContextMarker<S, SUser>;
+): typeof args & ServerFunctionContextMarker<S, SUser, Context>;
 
 export function defineFunction<
   TInput extends Record<string, JSONB.FieldType> | undefined = undefined,
   S = void,
   SUser extends SessionUser = SessionUser,
   Return = unknown,
+  Context = undefined,
 >(
-  args: DefineFunctionArgs<TInput, RestrictedFunctionContext<S, SUser>, Return> & {
+  args: DefineFunctionArgs<TInput, RestrictedFunctionContext<S, SUser, Context>, Return> & {
     unrestrictedDbAccess?: undefined;
   },
-): typeof args & ServerFunctionContextMarker<S, SUser>;
+): typeof args & ServerFunctionContextMarker<S, SUser, Context>;
 export function defineFunction(args: unknown) {
   return args;
 }
@@ -99,30 +110,59 @@ type ValidDbSchema<S> = S extends DBSchema ? S : void;
 export type ServerFunctionGroupFunctions<
   S = void,
   SUser extends SessionUser = SessionUser,
-> = Record<string, ServerFunctionDefinition & ServerFunctionContextMarker<S, SUser>>;
+  Context = undefined,
+> = Record<string, ServerFunctionDefinition & ServerFunctionContextMarker<S, SUser, Context>>;
 
-export type ServerFunctionGroup<S = void, SUser extends SessionUser = SessionUser> = {
+export type ServerFunctionGroup<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+> = {
   userFilter: FullFilter<UsersTableRow<S>, ValidDbSchema<S>>;
-  functions: ServerFunctionGroupFunctions<S, SUser>;
+  functions: ServerFunctionGroupFunctions<S, SUser, Context>;
 };
 
-export type ServerFunctionDefinitions<S = void, SUser extends SessionUser = SessionUser> = Record<
-  string,
-  ServerFunctionGroup<S, SUser>
->;
+export type ServerFunctionDefinitions<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+> = Record<string, ServerFunctionGroup<S, SUser, Context>>;
 
 /**
  * Creates a schema-aware identity helper for defining a server function group
  * while preserving its inferred function names and return types.
  */
-export const createFunctionGroupDefiner = <S = void, SUser extends SessionUser = SessionUser>() => {
-  return <const T extends ServerFunctionGroup<S, SUser>>(group: T): T => group;
+export const createFunctionGroupDefiner = <
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+>() => {
+  return <const T extends ServerFunctionGroup<S, SUser, Context>>(group: T): T => group;
 };
 
+/** Creates a schema-aware function group definer with application context. */
+export const createFunctionGroupDefinerWithContext = <
+  S,
+  Context,
+  SUser extends SessionUser = SessionUser,
+>() => createFunctionGroupDefiner<S, SUser, Context>();
+
 /**
  * Creates a schema-aware identity helper for function maps that are composed
  * into a server function group elsewhere.
  */
-export const createFunctionsDefiner = <S = void, SUser extends SessionUser = SessionUser>() => {
-  return <const T extends ServerFunctionGroupFunctions<S, SUser>>(functions: T): T => functions;
+export const createFunctionsDefiner = <
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+>() => {
+  return <const T extends ServerFunctionGroupFunctions<S, SUser, Context>>(functions: T): T =>
+    functions;
 };
+
+/** Creates a schema-aware function-map definer with application context. */
+export const createFunctionsDefinerWithContext = <
+  S,
+  Context,
+  SUser extends SessionUser = SessionUser,
+>() => createFunctionsDefiner<S, SUser, Context>();

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -81,7 +81,7 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
     }
 );
 
-export type BeforeEachTsTrigger<R, DBX> = {
+export type BeforeEachTsTrigger<R, DBX, Context = undefined> = {
   commands: Partial<Record<"insert" | "update", 1>>;
   /**
    * Will only run this trigger if the insert/update provides non null values for these fields.
@@ -91,11 +91,12 @@ export type BeforeEachTsTrigger<R, DBX> = {
     params: ValidateBeforeRowArgsCommon<R, DBX> & {
       localParams: undefined | LocalParams;
       hookContext: AnyObject | undefined;
+      context: Context;
     },
   ) => MaybePromise<void | { row: Partial<R>; hookContext?: AnyObject; onInserted?: () => void }>;
 };
 
-export type AfterEachTsTrigger<R, DBX> = {
+export type AfterEachTsTrigger<R, DBX, Context = undefined> = {
   commands: Partial<Record<"insert" | "update" | "delete", 1>>;
   /**
    * Will only run this trigger if the insert/update provides non null values for these fields.
@@ -104,6 +105,7 @@ export type AfterEachTsTrigger<R, DBX> = {
   validate: (
     params: ValidateRowArgsCommon<R, DBX> & {
       localParams: undefined | LocalParams;
+      context: Context;
     },
   ) => Promise<void>;
 };
@@ -139,12 +141,13 @@ export type ValidateRowsArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
     }
 );
 
-export type AfterAllTsTrigger<R, DBX> = {
+export type AfterAllTsTrigger<R, DBX, Context = undefined> = {
   commands: Partial<Record<"insert" | "update" | "delete", 1>>;
   changedFields?: string[];
   validate: (
     params: ValidateRowsArgsCommon<R, DBX> & {
       localParams: undefined | LocalParams;
+      context: Context;
     },
   ) => Promise<void>;
 };

package/lib/StorageClient/getFileTableConfig.ts

@@ -44,7 +44,7 @@ export type FileTableRow = {
 
 export const getFileTableConfig = (
   prg: Prostgles,
-): { tableConfig: TableConfig | undefined; tableHooks: TableHooks | undefined } => {
+): { tableConfig: TableConfig | undefined; tableHooks: TableHooks<void, any> | undefined } => {
   const { fileTable, tableConfig, tableHooks } = prg.opts;
   if (!fileTable) {
     return { tableConfig, tableHooks };
@@ -102,7 +102,7 @@ export const getFileTableConfig = (
   };
 
   const userFileTableHooks = tableHooks?.[fileTableName];
-  const mergedTableHooks: TableHooks = {
+  const mergedTableHooks: TableHooks<void, any> = {
     [fileTableName]: {
       ...userFileTableHooks,
       beforeEach: [

package/lib/TableConfig/TableConfigTypes.ts

@@ -1,24 +1,13 @@
-import type pgPromise from "pg-promise";
 import type {
   ALLOWED_CONTENT_TYPE,
   ALLOWED_EXTENSION,
-  AnyObject,
-  DBSchema,
   JSONB,
   MaybePromise,
   StrictUnion,
 } from "prostgles-types";
-import type { JoinInfo, LocalParams } from "../DboBuilder/DboBuilder";
-import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { JoinInfo } from "../DboBuilder/DboBuilder";
 import type { DB, DBHandlerServer } from "../Prostgles";
-import type {
-  AfterAllTsTrigger,
-  AfterEachTsTrigger,
-  BeforeEachTsTrigger,
-  InsertRule,
-  SyncConfig,
-  ValidateRowArgsCommon,
-} from "../PublishParser/PublishParser";
+import type { SyncConfig } from "../PublishParser/PublishParser";
 
 export type ColExtraInfo = {
   min?: string | number;

package/lib/TableConfig/initTableConfig.ts

@@ -153,7 +153,7 @@ export const initTableConfig = async function (this: TableConfigurator) {
 
   if (queries.length) {
     await runQueries(queries);
-    await this.prostgles.refreshDBO();
+    await this.prostgles.rebuildDBO();
   }
 
   /* Create/Alter columns */
@@ -348,8 +348,8 @@ export const initTableConfig = async function (this: TableConfigurator) {
     console.error("Table config failed queries: ", failedQueries);
   }
 
-  await this.prostgles.refreshDBO();
+  await this.prostgles.rebuildDBO();
   await this.setTableOnMounts();
   /** Needed in case some onMounts change schema */
-  await this.prostgles.refreshDBO();
+  await this.prostgles.rebuildDBO();
 };

package/lib/TableHooks/TableHooks.ts

@@ -1,38 +1,56 @@
 import type pgPromise from "pg-promise";
 import type { AnyObject, DBSchema } from "prostgles-types";
 
-import type { DbTxTableHandlers, LocalParams } from "../DboBuilder/DboBuilderTypes";
+import type { DbTxTableHandlers } from "../DboBuilder/DboBuilderTypes";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type {
   AfterAllTsTrigger,
   AfterEachTsTrigger,
   BeforeEachTsTrigger,
-  InsertRule,
-  ValidateRowArgsCommon,
 } from "../PublishParser/PublishParser";
 
-export type TableHooks<S = void> =
+export type TableHooks<S = void, Context = undefined> =
   S extends DBSchema ?
     Partial<{
       [tableName in keyof S]: TableHooksDefinition<
         Required<S[tableName]["columns"]>,
-        DBOFullyTyped<S>
+        DBOFullyTyped<S>,
+        Context
       >;
     }>
-  : Record<string, TableHooksDefinition>;
+  : Record<string, TableHooksDefinition<AnyObject, DbTxTableHandlers, Context>>;
 
-export type TableHooksDefinition<R = AnyObject, DBX = DbTxTableHandlers> = {
+export type TableHooksDefinition<
+  RowDataType = AnyObject,
+  DBX = DbTxTableHandlers,
+  Context = undefined,
+> = {
   /**
-   * Hook used to run custom logic before inserting a row.
-   * The returned row must satisfy the table schema.
+   * Runs sequentially before validation and SQL for each insert row, or once per update request.
+   * May replace the pending data and pass `hookContext` to the next hook.
+   * `onInserted` also runs for updates, is not awaited, and runs before the transaction commits.
+   */
+  beforeEach?: BeforeEachTsTrigger<RowDataType, DBX, Context>[];
+
+  /**
+   * Runs once per affected row after SQL, inside the same transaction.
+   * `row` is the inserted/updated row or the deleted row's pre-delete state. Throwing rolls back.
+   */
+  afterEach?: AfterEachTsTrigger<RowDataType, DBX, Context>[];
+
+  /**
+   * Runs once after all applicable `afterEach` hooks, inside the same transaction.
+   * Receives all affected `rows`; throwing rolls back the operation.
+   * Same-table, same-command writes from after-hooks do not retrigger after-hooks.
+   */
+  afterAll?: AfterAllTsTrigger<RowDataType, DBX, Context>[];
+
+  /**
+   * Replaces the generated DELETE. Must perform the mutation and shape its return value using
+   * the prepared filter and returning arguments. Delete `afterEach`/`afterAll` hooks do not run.
    */
-  getPreInsertRow?: (
-    args: PreInsertRowArgs,
-  ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
-  beforeEach?: BeforeEachTsTrigger<R, DBX>[];
-  afterEach?: AfterEachTsTrigger<R, DBX>[];
-  afterAll?: AfterAllTsTrigger<R, DBX>[];
   onInsteadOfDelete?: (args: {
+    context: Context;
     dbx: DBX;
     tx: pgPromise.ITask<{}>;
     returningQuery: string;
@@ -44,8 +62,3 @@ export type TableHooksDefinition<R = AnyObject, DBX = DbTxTableHandlers> = {
     };
   }) => Promise<AnyObject[] | undefined>;
 };
-
-type PreInsertRowArgs = Omit<ValidateRowArgsCommon, "localParams"> & {
-  validate: InsertRule["validate"];
-  localParams: LocalParams | undefined;
-};

package/lib/index.ts

@@ -3,14 +3,26 @@ import type { InitResult, OnReadyCallbackBasic } from "./initProstgles";
 import { Prostgles } from "./Prostgles";
 import type { ProstglesInitOptions } from "./ProstglesTypes";
 
-function prostgles<S = void, SUser extends SessionUser = SessionUser>(
-  params: ProstglesInitOptions<S, SUser>,
+function prostgles<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+  Context = undefined,
+>(
+  params: ProstglesInitOptions<S, SUser, Context>,
 ) {
-  const prgl = new Prostgles(params as ProstglesInitOptions);
+  const prgl = new Prostgles(
+    params as unknown as ProstglesInitOptions<void, SessionUser, any>,
+  );
   return prgl.init(params.onReady as unknown as OnReadyCallbackBasic, {
     type: "init",
-  }) as unknown as Promise<InitResult<S, SUser>>;
+  }) as unknown as Promise<InitResult<S, SUser, Context>>;
 }
+
+/** Creates a schema-bound Prostgles initializer while allowing context inference. */
+export const createProstgles = <S = void, SUser extends SessionUser = SessionUser>() => {
+  return <Context = undefined>(params: ProstglesInitOptions<S, SUser, Context>) =>
+    prostgles<S, SUser, Context>(params);
+};
 export * from "./PublishParser/defineServerFunction";
 export * from "./Auth/AuthTypes";
 export type { PublishParams } from "./PublishParser/publishTypesAndUtils";
@@ -18,7 +30,15 @@ export type { DBOFullyTyped } from "./DBSchemaBuilder/DBSchemaBuilder";
 export type { DBHandlerServer } from "./Prostgles";
 export type { StorageClient as CloudClient } from "./StorageClient/StorageClientTypes";
 export * from "./StorageClient/getLocalStorageClient";
-export type { DB } from "./initProstgles";
+export type {
+  ContextCleanup,
+  CreateContext,
+  CreateContextParams,
+  DB,
+  InitResult,
+  OnReadyParams,
+} from "./initProstgles";
+export type { ProstglesInitOptions } from "./ProstglesTypes";
 export type * from "./TableConfig/TableConfigTypes";
 export type * from "./TableHooks/TableHooks";
 export * from "./Auth/utils/upsertNamedExpressMiddleware";