prostgles-server 4.2.618 → 4.2.620

package/lib/DboBuilder/DboBuilder.ts

@@ -35,6 +35,7 @@ import { prepareShortestJoinPaths } from "./joins/prepareShortestJoinPaths";
 import { cacheDBTypes, runSQL } from "./runSql/runSQL";
 import { getDetailedFieldInfo, type getDbTypes } from "./runSql/runSqlUtils";
 import { getTablesForSchemaPostgresSQL } from "./schema/getTablesForSchemaPostgresSQL";
+import { getPublishSchemas } from "../DBSchemaBuilder/getPublishSchemas";
 
 export * from "./DboBuilderTypes";
 export * from "./dboBuilderUtils";
@@ -208,8 +209,8 @@ export class DboBuilder {
     return this.shortestJoinPaths;
   }
 
-  prepareShortestJoinPaths = async () => {
-    const { joins, shortestJoinPaths, joinGraph } = await prepareShortestJoinPaths(this);
+  prepareShortestJoinPaths = () => {
+    const { joins, shortestJoinPaths, joinGraph } = prepareShortestJoinPaths(this);
     this.joinGraph = joinGraph;
     this.joins = joins;
     this.shortestJoinPaths = shortestJoinPaths;
@@ -276,7 +277,7 @@ export class DboBuilder {
       this.prostgles.dbForSchema!,
       this.prostgles.opts.schemaFilter,
     );
-    await this.prepareShortestJoinPaths();
+    this.prepareShortestJoinPaths();
 
     this.dbo = {};
     this.tablesOrViews.map((tov) => {
@@ -349,7 +350,7 @@ export class DboBuilder {
     }
     return this.tablesOrViews;
   };
-  getTsDefinitions = <DDL extends string | undefined = undefined>({
+  getTsDefinitions = async ({
     excludeFunctions,
     extraTables = [],
     ddlWithRollback,
@@ -362,12 +363,13 @@ export class DboBuilder {
      * This is useful for generating an updated TypeScript schema after running a migration SQL file, for example.
      * Note that this will be run within a transaction that is rolled back, so it SHOULD not affect the actual database schema.
      */
-    ddlWithRollback?: DDL;
-  } = {}): DDL extends string ? Promise<{ tsSchema: string; tablesOrViews: TableSchema[] }>
-  : { tsSchema: string; tablesOrViews: TableSchema[] } => {
+    ddlWithRollback?: string;
+  } = {}): Promise<{ tsSchema: string; tablesOrViews: TableSchema[] }> => {
+    const clientSchemas = this.publishParser && (await getPublishSchemas(this.publishParser));
     const getSchema = (tablesOrViews: TableSchema[]) => {
       const tableTsDefinitions = getDBGeneratedSchema({
         config: this.prostgles.mergedTableConfig.tableConfig,
+        clientSchemas,
         tablesOrViews: [
           ...tablesOrViews,
           ...extraTables.filter(
@@ -386,26 +388,17 @@ export class DboBuilder {
       return { tsSchema, tablesOrViews };
     };
     if (ddlWithRollback) {
-      return new Promise<{ tsSchema: string; tablesOrViews: TableSchema[] }>((resolve, reject) => {
-        getTablesForSchemaPostgresSQL(this, {
-          schemaFilter: this.prostgles.opts.schemaFilter,
-          ddlWithRollback,
-        })
-          .then((res) => {
-            const tablesOrViews = res.result;
-            resolve(getSchema(tablesOrViews));
-          })
-          .catch(reject);
-      }) as DDL extends string ? Promise<{ tsSchema: string; tablesOrViews: TableSchema[] }>
-      : { tsSchema: string; tablesOrViews: TableSchema[] };
+      const { result } = await getTablesForSchemaPostgresSQL(this, {
+        schemaFilter: this.prostgles.opts.schemaFilter,
+        ddlWithRollback,
+      });
+      return getSchema(result);
     }
     const tablesOrViews = this.tablesOrViews;
     if (!tablesOrViews) {
       throw new Error("Unexpected error: tablesOrViews is undefined");
     }
-    return getSchema(tablesOrViews) as DDL extends string ?
-      Promise<{ tsSchema: string; tablesOrViews: TableSchema[] }>
-    : { tsSchema: string; tablesOrViews: TableSchema[] };
+    return getSchema(tablesOrViews);
   };
 
   getShortestJoinPath = (

package/lib/Prostgles.ts

@@ -1,3 +1,4 @@
+import { DB_GENERATED_SCHEMA_NAME } from "./DBSchemaBuilder/constants";
 import type pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
 import type { SessionUser } from "./Auth/AuthTypes";
@@ -21,7 +22,7 @@ export { applyTableConfig } from "./TableConfig/applyTableConfig";
 
 import { CHANNELS, tryCatchV2 } from "prostgles-types";
 import type { DBEventsManager } from "./DBEventsManager";
-import type { PublishParser } from "./PublishParser/PublishParser";
+import { PublishParser } from "./PublishParser/PublishParser";
 import { pushSocketSchema } from "./WebsocketAPI/pushSocketSchema";
 
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
@@ -229,7 +230,7 @@ export class Prostgles {
   }
 
   getTSFileName() {
-    const fileName = "DBGeneratedSchema.ts";
+    const fileName = `${DB_GENERATED_SCHEMA_NAME}.ts`;
     const _dir = this.opts.tsGeneratedTypesDir || "";
     const dir = _dir.endsWith("/") ? _dir : `${_dir}/`;
     const fullPath = dir + fileName;
@@ -240,10 +241,10 @@ export class Prostgles {
    * Will write the Schema Typescript definitions to file (tsGeneratedTypesDir)
    * force is used for hotReloadMode to trigger a restart
    */
-  writeDBSchema(force = false) {
+  async writeDBSchema(force = false) {
     if (this.opts.tsGeneratedTypesDir) {
+      const { tsSchema: fileContent } = await this.dboBuilder.getTsDefinitions();
       const { fullPath, fileName } = this.getTSFileName();
-      const { tsSchema: fileContent } = this.dboBuilder.getTsDefinitions();
       fs.mkdirSync(dirname(fullPath), { recursive: true });
 
       const existingContent =
@@ -348,6 +349,11 @@ export class Prostgles {
     this.restApi = this.opts.restApi && new RestApi({ prostgles: this, ...this.opts.restApi });
   };
 
+  initPublishParser = () => {
+    this.publishParser = new PublishParser(this);
+    this.dboBuilder.publishParser = this.publishParser;
+  };
+
   initAuthHandler = () => {
     this.authHandler.destroy();
     this.authHandler = new AuthHandler(this);

package/lib/PublishParser/PublishParser.ts

@@ -25,9 +25,12 @@ import {
   type PermissionScope,
   type PublishObject,
 } from "./publishTypesAndUtils";
+import { validatePublishProfiles } from "./validatePublishProfiles";
 
 export class PublishParser {
-  publish: ProstglesInitOptions<void, SessionUser, any>["publish"];
+  publish:
+    | Exclude<ProstglesInitOptions<void, SessionUser, any>["publish"], unknown[]>
+    | ReturnType<typeof validatePublishProfiles>;
   publishRawSQL?: any;
   dbo: DBHandlerServer;
   db: DB;
@@ -35,7 +38,8 @@ export class PublishParser {
 
   constructor(prostgles: Prostgles) {
     this.prostgles = prostgles;
-    this.publish = prostgles.opts.publish;
+    const { publish } = prostgles.opts;
+    this.publish = Array.isArray(publish) ? validatePublishProfiles(publish) : publish;
 
     // eslint-disable-next-line @typescript-eslint/unbound-method
     this.publishRawSQL = prostgles.opts.publishRawSQL;
@@ -146,7 +150,17 @@ export class PublishParser {
     clientInfo: AuthResultWithSID | undefined,
   ): Promise<PublishObject | undefined> {
     const publishParams = await this.getPublishParams(clientReq, clientInfo);
-    const publish = await applyParamsIfFunc(this.publish, publishParams);
+
+    const publish = await (() => {
+      if (Array.isArray(this.publish)) {
+        const { user } = publishParams;
+        if (!user) return undefined;
+        return this.publish.find((publishRule) => publishRule.userTypes.includes(user.type))
+          ?.publish;
+      }
+
+      return applyParamsIfFunc(this.publish, publishParams);
+    })();
 
     if (publish === "*") {
       const publish: PublishObject = {};
@@ -271,13 +285,18 @@ export class PublishParser {
     args: DboTable,
     clientInfo: AuthResultWithSID | undefined,
     scope: PermissionScope | undefined,
+    overriddenPublish?: PublishObject,
   ): Promise<ParsedTableRule | undefined> {
     const { tableName } = args;
     const tableHandler = this.dbo[tableName];
     if (!tableHandler) {
       throw "INTERNAL ERROR: table handler not found for " + args.tableName;
     }
-    const fileTablePublishRules = await this.getTableRulesWithoutFileTable(args, clientInfo);
+    const fileTablePublishRules = await this.getTableRulesWithoutFileTable(
+      args,
+      clientInfo,
+      overriddenPublish,
+    );
     if (this.dbo[args.tableName]?.is_media) {
       const { rules: fileTableRules } = await getFileTableRules.bind(this)(
         args.tableName,
@@ -285,6 +304,7 @@ export class PublishParser {
         args.clientReq,
         clientInfo,
         scope,
+        overriddenPublish,
       );
       return applyScopeToTableRules(
         tableName,

package/lib/PublishParser/getFileTableRules.ts

@@ -3,7 +3,7 @@ import { includes, isDefined } from "prostgles-types";
 import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import type { PublishParser } from "./PublishParser";
-import type { ParsedPublishTable, UpdateRule } from "./publishTypesAndUtils";
+import type { ParsedPublishTable, PublishObject, UpdateRule } from "./publishTypesAndUtils";
 import type { LocalParams } from "../DboBuilder/DboBuilder";
 
 /**
@@ -21,6 +21,7 @@ export async function getFileTableRules(
   clientReq: AuthClientRequest | undefined,
   clientInfo: AuthResultWithSID | undefined,
   scope: LocalParams["scope"],
+  overriddenPublish?: PublishObject,
 ) {
   const forcedDeleteFilters: FullFilter<AnyObject, void>[] = [];
   const forcedSelectFilters: FullFilter<AnyObject, void>[] = [];
@@ -42,7 +43,7 @@ export async function getFileTableRules(
     .filter(isDefined);
   if (referencedColumns?.length) {
     for (const { tableName, fileColumns, allColumns } of referencedColumns) {
-      const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo, scope);
+      const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo, scope, overriddenPublish);
       if (tableRules) {
         fileColumns.map((column) => {
           const path = [{ table: tableName, on: [{ id: column }] }];

package/lib/PublishParser/getPublishedTableNames.ts

@@ -0,0 +1,29 @@
+import type { PublishParser } from "./PublishParser";
+import { type PublishObject } from "./PublishParser";
+
+export const getPublishedTableNames = (
+  publishParserInstance: PublishParser,
+  publishObject: PublishObject,
+) => {
+  const txKey = !publishParserInstance.prostgles.opts.transactions ? "" : "tx";
+  const tableNames = Object.keys(publishObject).filter((k) => !txKey || txKey !== k);
+
+  /**
+   * Add file table to the list of published tables if it's referenced by other published tables.
+   * Access to the file table is controlled through the publish rules of the tables referencing it.
+   */
+  const fileTableName = publishParserInstance.prostgles.opts.fileTable?.tableName;
+  if (
+    fileTableName &&
+    publishParserInstance.dbo[fileTableName]?.is_media &&
+    !tableNames.includes(fileTableName)
+  ) {
+    const isReferenced = publishParserInstance.prostgles.dboBuilder.tablesOrViews?.some((t) =>
+      t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
+    );
+    if (isReferenced) {
+      tableNames.unshift(fileTableName);
+    }
+  }
+  return tableNames;
+};

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -4,6 +4,7 @@ import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import type { PublishParser } from "./PublishParser";
 import { type PermissionScope, type PublishObject } from "./PublishParser";
 import { getDBSchemaTable } from "./getDBSchemaTable";
+import { getPublishedTableNames } from "./getPublishedTableNames";
 
 type Args = AuthClientRequest & {
   userData: AuthResultWithSID | undefined;
@@ -19,8 +20,6 @@ export async function getSchemaFromPublish(
   const tableSchemaErrors: TableSchemaErrors = {};
   const tables: DBSchemaTable[] = [];
 
-  const txKey = !this.prostgles.opts.transactions ? "" : "tx";
-
   try {
     /* Publish tables and views based on socket */
     const clientInfo =
@@ -39,21 +38,7 @@ export async function getSchemaFromPublish(
     if (!publish || !Object.keys(publish).length) {
       return { tables, tableSchemaErrors };
     }
-    const tableNames = Object.keys(publish).filter((k) => !txKey || txKey !== k);
-
-    /**
-     * Add file table to the list of published tables if it's referenced by other published tables.
-     * Access to the file table is controlled through the publish rules of the tables referencing it.
-     */
-    const fileTableName = this.prostgles.opts.fileTable?.tableName;
-    if (fileTableName && this.dbo[fileTableName]?.is_media && !tableNames.includes(fileTableName)) {
-      const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some((t) =>
-        t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
-      );
-      if (isReferenced) {
-        tableNames.unshift(fileTableName);
-      }
-    }
+    const tableNames = getPublishedTableNames(this, publish);
 
     await Promise.all(
       tableNames.map(async (tableName) => {

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -556,6 +556,13 @@ export type ParsedPublishTables = {
 
 type PublishAllOrNothingRoot = Exclude<PublishAllOrNothing, boolean>;
 export type PublishedResult<Schema = void> = PublishAllOrNothingRoot | PublishFullyTyped<Schema>;
+export type PublishProfile<Schema = void> = {
+  /** Exported schema type name; defaults to Publish1Schema, Publish2Schema, etc. */
+  name?: string;
+  userTypes: string[];
+  publish: PublishedResult<Schema>;
+};
 export type Publish<Schema = void, SUser extends SessionUser = SessionUser> =
+  | PublishProfile<Schema>[]
   | PublishedResult<Schema>
   | ((params: PublishParams<Schema, SUser>) => Awaitable<PublishedResult<Schema>>);

package/lib/PublishParser/validatePublishProfiles.ts

@@ -0,0 +1,22 @@
+import { validateClientSchemaName } from "../DBSchemaBuilder/getClientDBGeneratedSchemas";
+import type { PublishProfile } from "./publishTypesAndUtils";
+
+export const validatePublishProfiles = (profiles: PublishProfile[]) => {
+  const names = new Set<string>();
+  const userTypes = new Set<string>();
+  const entries = profiles.map((profile, index) => {
+    const name = profile.name ?? `Publish${index + 1}Schema`;
+    validateClientSchemaName(name);
+    if (names.has(name)) throw new Error(`Duplicate publish schema name: ${name}`);
+    names.add(name);
+    if (!profile.userTypes.length) {
+      throw new Error(`Publish ${name}: userTypes must not be empty`);
+    }
+    for (const userType of profile.userTypes) {
+      if (userTypes.has(userType)) throw new Error(`Duplicate publish user type: ${userType}`);
+      userTypes.add(userType);
+    }
+    return { ...profile, name };
+  });
+  return entries;
+};

package/lib/SchemaWatch/SchemaWatch.ts

@@ -81,7 +81,7 @@ export class SchemaWatch {
           console.log("watchSchema: Re-writing TS schema");
 
           await this.dboBuilder.prostgles.refreshDBO();
-          this.dboBuilder.prostgles.writeDBSchema(true);
+          await this.dboBuilder.prostgles.writeDBSchema(true);
         }
       } else {
         /* Full re-init. Sockets must reconnect */

package/lib/index.ts

@@ -1,18 +1,13 @@
+import { defineJoin } from "prostgles-types";
 import type { SessionUser } from "./Auth/AuthTypes";
 import type { InitResult, OnReadyCallbackBasic } from "./initProstgles";
 import { Prostgles } from "./Prostgles";
 import type { ProstglesInitOptions } from "./ProstglesTypes";
 
-function prostgles<
-  S = void,
-  SUser extends SessionUser = SessionUser,
-  Context = undefined,
->(
+function prostgles<S = void, SUser extends SessionUser = SessionUser, Context = undefined>(
   params: ProstglesInitOptions<S, SUser, Context>,
 ) {
-  const prgl = new Prostgles(
-    params as unknown as ProstglesInitOptions<void, SessionUser, any>,
-  );
+  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, Context>>;
@@ -25,7 +20,7 @@ export const createProstgles = <S = void, SUser extends SessionUser = SessionUse
 };
 export * from "./PublishParser/defineServerFunction";
 export * from "./Auth/AuthTypes";
-export type { PublishParams } from "./PublishParser/publishTypesAndUtils";
+export type { PublishParams, PublishProfile } from "./PublishParser/publishTypesAndUtils";
 export type { DBOFullyTyped } from "./DBSchemaBuilder/DBSchemaBuilder";
 export type { DBHandlerServer } from "./Prostgles";
 export type { StorageClient as CloudClient } from "./StorageClient/StorageClientTypes";
@@ -46,5 +41,9 @@ export * from "./Auth/utils/upsertNamedExpressMiddleware";
 export type { RequestWithUser } from "./Auth/middleware/userContextMiddleware";
 export default prostgles;
 export type { FileTableRow } from "./StorageClient/getFileTableConfig";
-
-export { AUDIT_TABLE_COLUMN_DEFINITIONS, AUDIT_TABLE_COLUMNS, type AuditTableRow } from "./Audit/AuditTable";
+export { defineJoin };
+export {
+  AUDIT_TABLE_COLUMN_DEFINITIONS,
+  AUDIT_TABLE_COLUMNS,
+  type AuditTableRow,
+} from "./Audit/AuditTable";

package/lib/initProstgles.ts

@@ -12,7 +12,7 @@ import { getDbConnection } from "./getDbConnection";
 import type { DBHandlerServer, Prostgles } from "./Prostgles";
 import { getIsSuperUser } from "./Prostgles";
 import type { ProstglesInitOptions } from "./ProstglesTypes";
-import { PublishParser, type PermissionScope } from "./PublishParser/PublishParser";
+import type { PermissionScope } from "./PublishParser/PublishParser";
 import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { runSQLFile } from "./TableConfig/runSQLFile";
 import { updateConfiguration, type clientOnlyUpdateKeys } from "./updateConfiguration";
@@ -92,15 +92,9 @@ export type CreateContextParams<S> = OnReadyParamsCommon & {
   dbo: DBOFullyTyped<S>;
   onCleanup: (cleanup: ContextCleanup) => void;
 };
-export type CreateContext<S, Context> = (
-  params: CreateContextParams<S>,
-) => MaybePromise<Context>;
+export type CreateContext<S, Context> = (params: CreateContextParams<S>) => MaybePromise<Context>;
 
-export type OnReadyCallback<
-  S,
-  SUser extends SessionUser,
-  Context = undefined,
-> = (
+export type OnReadyCallback<S, SUser extends SessionUser, Context = undefined> = (
   params: OnReadyParams<S, Context>,
   update: (newOpts: UpdatableOptions<S, SUser, Context>, force?: true) => Promise<void>,
 ) => void | Promise<void>;
@@ -109,11 +103,7 @@ export type OnReadyCallbackBasic = (
   update: (newOpts: UpdatableOptions<void, SessionUser, any>, force?: true) => Promise<void>,
 ) => void | Promise<void>;
 
-export type InitResult<
-  S = void,
-  SUser extends SessionUser = SessionUser,
-  Context = undefined,
-> = {
+export type InitResult<S = void, SUser extends SessionUser = SessionUser, Context = undefined> = {
   db: DBOFullyTyped<S>;
   context: Context;
   sql: SQLHandler;
@@ -126,7 +116,7 @@ export type InitResult<
    */
   getTSSchema: typeof DboBuilder.prototype.getTsDefinitions;
   getSchema: typeof DboBuilder.prototype.getSchema;
-  reWriteDBSchema: () => void;
+  reWriteDBSchema: () => Promise<void>;
   update: (newOpts: UpdatableOptions<S, SUser, Context>, force?: true) => Promise<void>;
   restart: () => Promise<InitResult<S, SUser, Context>>;
   options: ProstglesInitOptions<S, SUser, Context>;
@@ -259,10 +249,8 @@ export const initProstgles = async function (
       /* 3.9 Check auth config */
       this.initAuthHandler();
 
-      this.publishParser = new PublishParser(this);
-      this.dboBuilder.publishParser = this.publishParser;
-
       /* 4. Set publish and auth listeners */
+      this.initPublishParser();
       this.setupSocketIO();
     } else if (this.opts.auth) {
       throw "Auth config does not work without publish";
@@ -270,7 +258,7 @@ export const initProstgles = async function (
 
     this.dbEventsManager = new DBEventsManager(db, pgp);
 
-    this.writeDBSchema();
+    await this.writeDBSchema();
 
     /* 5. Finish init and provide DBO object */
     try {

package/lib/updateConfiguration.ts

@@ -32,6 +32,9 @@ export const updateConfiguration = async (
   if (includes(optionsThatChanged, "schema")) {
     await prgl.refreshDBO();
   }
+  if (includes(optionsThatChanged, "publish")) {
+    prgl.initPublishParser();
+  }
   if (includes(optionsThatChanged, "auth")) {
     prgl.initAuthHandler();
   }
@@ -42,10 +45,11 @@ export const updateConfiguration = async (
   }
 
   if (
+    includes(optionsThatChanged, "publish") ||
     includes(optionsThatChanged, "tsGeneratedTypesDir") ||
     includes(optionsThatChanged, "tsGeneratedTypesFunctionsPath")
   ) {
-    prgl.writeDBSchema();
+    await prgl.writeDBSchema();
   }
 
   if (isEmpty(newOpts)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.618",
+  "version": "4.2.620",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.23.0",
     "pg-cursor": "^2.22.0",
     "pg-promise": "^12.7.1",
-    "prostgles-types": "^4.0.282"
+    "prostgles-types": "^4.0.283"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",