prostgles-server 4.2.507 → 4.2.508

package/lib/FileManager/initFileManager.ts

@@ -117,7 +117,7 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
     if (!this.dbo[refTable]) {
       throw `Referenced table (${refTable}) from fileTable.referencedTables prostgles init config does not exist`;
     }
-    const cols = await (this.dbo[refTable] as TableHandler).getColumns();
+    const cols = await (this.dbo[refTable]).getColumns();
 
     for (const [colName] of Object.entries(tableConfig.referenceColumns)) {
       const existingCol = cols.find((c) => c.name === colName);

package/lib/Prostgles.ts

@@ -27,7 +27,15 @@ import { pushSocketSchema } from "./WebsocketAPI/pushSocketSchema";
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
 export type DBorTx = DB | pgPromise.ITask<{}>;
 
-export const TABLE_METHODS = ["update", "find", "findOne", "insert", "delete", "upsert"] as const;
+export const TABLE_METHODS = [
+  "update",
+  "find",
+  "findOne",
+  "insert",
+  "insertMany",
+  "delete",
+  "upsert",
+] as const satisfies (keyof TableHandler)[];
 
 /*
     1. Connect to db
@@ -51,6 +59,7 @@ const DEFAULT_KEYWORDS = {
 
 import { randomUUID } from "crypto";
 import * as fs from "fs";
+import type { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 
 export class Prostgles {
   /**

package/lib/PubSubManager/PubSubManager.ts

@@ -3,13 +3,7 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import type {
-  DBHandlerServer,
-  DboBuilder,
-  PRGLIOSocket,
-  TableInfo,
-  TableOrViewInfo,
-} from "../DboBuilder/DboBuilder";
+import type { DBHandlerServer, DboBuilder, PRGLIOSocket } from "../DboBuilder/DboBuilder";
 import type { PostgresNotifListenManager } from "../PostgresNotifListenManager";
 import type { DB } from "../Prostgles";
 import { addSync } from "./addSync";
@@ -19,7 +13,14 @@ import { initPubSubManager } from "./init/initPubSubManager";
 import { initialiseEventTriggers } from "./initialiseEventTriggers";
 import { refreshTriggers } from "./refreshTriggers";
 
-import type { AnyObject, FieldFilter, SelectParams, WAL } from "prostgles-types";
+import type {
+  AnyObject,
+  FieldFilter,
+  SelectParams,
+  SyncTableInfo,
+  TableSchema,
+  WAL,
+} from "prostgles-types";
 import { CHANNELS, getSerialisableError, type SubscribeOptions } from "prostgles-types";
 
 import { find, pickKeys } from "prostgles-types";
@@ -56,13 +57,11 @@ export type SyncParams = {
   is_syncing: boolean;
 };
 
-export type AddSyncParams = {
+export type AddSyncParams = SyncTableInfo & {
   socket: PRGLIOSocket;
-  table_info: TableInfo;
+  table_info: TableSchema;
   table_rules: ParsedTableRule;
-  synced_field: string;
   allow_delete?: boolean;
-  id_fields: string[];
   filter: object;
   params: {
     select: FieldFilter;
@@ -99,7 +98,7 @@ export type SubscriptionParams = {
   viewOptions?: ViewSubscriptionOptions;
   parentSubParams: Omit<SubscriptionParams, "parentSubParams"> | undefined;
 
-  table_info: TableOrViewInfo;
+  table_info: TableSchema;
 
   /* Used as input */
   table_rules?: ParsedTableRule;

package/lib/PubSubManager/PubSubManagerUtils.ts

@@ -27,6 +27,7 @@ export const EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID =
 type PGP = pgPromise.IMain<{}, pg.IClient>;
 export const pgp: PGP = pgPromise({});
 export const asValue = (v: any, castAs?: ":csv") => pgp.as.format(`$1${castAs ?? ""}`, [v]);
+export const DEFAULT_SYNC_THROTTLE = 100;
 export const DEFAULT_SYNC_BATCH_SIZE = 50;
 
 let lastLog: { count: number; msg: string } | undefined;

package/lib/PubSubManager/addSync.ts

@@ -1,6 +1,6 @@
 import { find, tryCatchV2 } from "prostgles-types";
 import type { AddSyncParams, BasicCallback, PubSubManager } from "./PubSubManager";
-import { DEFAULT_SYNC_BATCH_SIZE, parseCondition } from "./PubSubManagerUtils";
+import { parseCondition } from "./PubSubManagerUtils";
 
 /**
  * Returns a sync channel
@@ -17,11 +17,9 @@ export async function addSync(
       table_info = null,
       table_rules,
       synced_field = null,
-      id_fields = [],
       filter = {},
       params,
       condition = "",
-      throttle = 0,
     } = syncParams;
     const conditionParsed = parseCondition(condition);
     if (!socket || !table_info) throw "socket or table_info missing";
@@ -33,18 +31,17 @@ export async function addSync(
 
     this.upsertSocket(socket);
 
+    const syncConfig = this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(table_name);
+    if (!syncConfig) throw `Sync not configured for table ${table_name}`;
     const upsertSync = () => {
       const newSync = {
         channel_name: channelName,
         table_name,
         filter,
         condition: conditionParsed,
-        synced_field,
         sid,
-        id_fields,
         table_rules,
-        throttle: Math.max(throttle || 0, table_rules.sync?.throttle || 0),
-        batch_size: table_rules.sync?.batch_size || DEFAULT_SYNC_BATCH_SIZE,
+        ...syncConfig,
         socket_id: socket.id,
         is_sync: true,
         last_synced: 0,

package/lib/PubSubManager/addTrigger.ts

@@ -26,7 +26,7 @@ export async function addTrigger(
       condition = "TRUE";
     }
 
-    if (this.dbo[table_name]?.tableOrViewInfo?.isHyperTable) {
+    if (this.dbo[table_name]?.tableOrViewInfo.isHyperTable) {
       throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084";
     }
 

package/lib/PublishParser/PublishParser.ts

@@ -1,4 +1,4 @@
-import { includes } from "prostgles-types";
+import { getObjectEntries, includes, SQL_COMMAND_TABLE_METHODS } from "prostgles-types";
 import { getClientRequestIPsInfo } from "../Auth/AuthHandler";
 import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
@@ -17,7 +17,6 @@ import type {
   PublishParams,
 } from "./publishTypesAndUtils";
 import {
-  RULE_TO_METHODS,
   parsePublishTableRule,
   type PermissionScope,
   type PublishObject,
@@ -37,7 +36,9 @@ export class PublishParser {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     this.publishRawSQL = prostgles.opts.publishRawSQL;
     const { dbo, db } = prostgles;
-    if (!dbo || !db) throw "INTERNAL ERROR: dbo and/or db missing";
+    if (!dbo || !db) {
+      throw "INTERNAL ERROR: dbo and/or db missing";
+    }
     this.dbo = dbo;
     this.db = db;
   }
@@ -83,14 +84,14 @@ export class PublishParser {
   /**
    * Parses the first level of publish. (If false then nothing if * then all tables and views)
    */
-  async getPublishAsObject(
+  async getPublishObject(
     clientReq: AuthClientRequest,
     clientInfo: AuthResultWithSID | undefined,
   ): Promise<PublishObject | undefined> {
     const publishParams = await this.getPublishParams(clientReq, clientInfo);
-    const _publish = await applyParamsIfFunc(this.publish, publishParams);
+    const publish = await applyParamsIfFunc(this.publish, publishParams);
 
-    if (_publish === "*") {
+    if (publish === "*") {
       const publish: PublishObject = {};
       this.prostgles.dboBuilder.tablesOrViews?.map((tov) => {
         publish[tov.name] = "*";
@@ -98,7 +99,7 @@ export class PublishParser {
       return publish;
     }
 
-    return _publish || undefined;
+    return publish || undefined;
   }
 
   async getValidatedRequestRuleWusr(
@@ -124,13 +125,12 @@ export class PublishParser {
 
     /* Must be local request -> allow everything */
     if (!clientReq) {
-      return RULE_TO_METHODS.reduce(
-        (a, v) => ({
-          ...a,
-          [v.rule]: v.no_limits,
-        }),
-        {},
-      );
+      return {
+        select: { fields: "*", filterFields: "*", orderByFields: "*" },
+        insert: { returningFields: "*", fields: "*" },
+        update: { fields: "*", returningFields: "*", filterFields: "*" },
+        delete: { returningFields: "*", filterFields: "*" },
+      };
     }
 
     /* Must be from socket. Must have a publish */
@@ -160,7 +160,10 @@ export class PublishParser {
   ) {
     if (!command || !tableName) throw "command OR tableName are missing";
 
-    const rule = RULE_TO_METHODS.find(({ methods }) => includes(methods, command));
+    const [rule] =
+      getObjectEntries(SQL_COMMAND_TABLE_METHODS).find(([_, methods]) =>
+        includes(methods, command),
+      ) ?? [];
     if (!rule) {
       throw "Invalid command: " + command;
     }
@@ -170,7 +173,15 @@ export class PublishParser {
         // Allow all commands
       } else {
         const tableScope = scope.tables;
-        if (!tableScope?.[tableName] || !tableScope[tableName][rule.sqlRule]) {
+        const tableScopeCommands = tableScope?.[tableName];
+        const methodAllowedInScope =
+          tableScopeCommands &&
+          (rule === "schema" ?
+            getObjectEntries(tableScopeCommands).some(([_, value]) => {
+              return value;
+            })
+          : tableScopeCommands[rule]);
+        if (!methodAllowedInScope) {
           throw `Invalid or disallowed command: ${tableName}.${command}. The PermissionsScope does not allow this command.`;
         }
       }
@@ -185,7 +196,9 @@ export class PublishParser {
       }
     }
 
-    if (!tableRule[rule.rule]) {
+    const isAllowed =
+      rule === "schema" ? getObjectEntries(tableRule).some(([_, value]) => value) : tableRule[rule];
+    if (!isAllowed) {
       throw {
         stack: ["getValidatedRequestRule()"],
         message: `Invalid or disallowed command: ${tableName}.${command}`,

package/lib/PublishParser/getDBSchemaTable.ts

@@ -0,0 +1,73 @@
+import { getObjectEntries, includes, type DBSchemaTable } from "prostgles-types";
+import type { AuthClientRequest } from "../Auth/AuthTypes";
+import { getErrorAsObject } from "../DboBuilder/dboBuilderUtils";
+import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+import { TABLE_METHODS } from "../Prostgles";
+import type { ParsedTableRule, PermissionScope, PublishParser } from "./PublishParser";
+import { getAllowedTableMethods } from "prostgles-types";
+
+export const getDBSchemaTable = async (
+  publishParser: PublishParser,
+  tableHandler: TableHandler,
+  parsedTableRule: ParsedTableRule,
+  clientReq: AuthClientRequest,
+  scope: PermissionScope | undefined,
+): Promise<DBSchemaTable> => {
+  const tableName = tableHandler.name;
+
+  if (getObjectEntries(parsedTableRule).every(([_ruleName, ruleOptions]) => !ruleOptions)) {
+    throw new Error("At least one of the rules must be defined for " + tableName);
+  }
+  const info = await tableHandler.getInfo(undefined, undefined, undefined, parsedTableRule, {
+    ...clientReq,
+    isRemoteRequest: {},
+  });
+  const columns = await tableHandler.getColumns(undefined, undefined, undefined, parsedTableRule, {
+    ...clientReq,
+    isRemoteRequest: {},
+  });
+  const allowedCommands = getAllowedTableMethods(info);
+  for (const method of allowedCommands) {
+    if (method === "getInfo" || method === "getColumns") {
+      continue;
+    }
+    try {
+      publishParser.validateRequestRule(
+        {
+          tableName,
+          command: method,
+          clientReq,
+        },
+        parsedTableRule,
+        scope,
+      );
+    } catch (e) {
+      console.error(`${tableName}.${method}`, e);
+      throw {
+        ...getErrorAsObject(e),
+        publishPath: `publish.${tableName}.${method}`,
+      };
+    }
+    /** Crucial in ensuring the published client tableHandler methods work without issues */
+    if (publishParser.prostgles.opts.testRulesOnConnect && includes(TABLE_METHODS, method)) {
+      await tableHandler.dboBuilder.dboMap.get(tableName)?.[method](
+        //@ts-expect-error
+        method === "insertMany" ? [] : {},
+        {},
+        undefined,
+        parsedTableRule,
+        {
+          ...clientReq,
+          isRemoteRequest: {},
+          testRule: true,
+        },
+      );
+    }
+  }
+
+  return {
+    ...info,
+    name: tableHandler.name,
+    columns,
+  } satisfies DBSchemaTable;
+};

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -1,16 +1,10 @@
-import type {
-  DBSchemaTable,
-  TableInfo,
-  TableSchemaErrors,
-  TableSchemaForClient,
-} from "prostgles-types";
-import { getKeys, includes, isEmpty, isObject, pickKeys, type AnyObject } from "prostgles-types";
+import type { DBSchemaTable, TableSchemaErrors } from "prostgles-types";
+import { isEmpty, isObject } from "prostgles-types";
 import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
-import { getErrorAsObject } from "../DboBuilder/DboBuilder";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
-import { TABLE_METHODS } from "../Prostgles";
 import type { PublishParser } from "./PublishParser";
 import { type PermissionScope, type PublishObject } from "./PublishParser";
+import { getDBSchemaTable } from "./getDBSchemaTable";
 
 type Args = AuthClientRequest & {
   userData: AuthResultWithSID | undefined;
@@ -22,13 +16,13 @@ export async function getSchemaFromPublish(
   { userData, ...clientReq }: Args,
   scope: PermissionScope | undefined,
 ): Promise<{
-  schema: TableSchemaForClient;
   tables: DBSchemaTable[];
   tableSchemaErrors: TableSchemaErrors;
 }> {
-  const schema: TableSchemaForClient = {};
   const tableSchemaErrors: TableSchemaErrors = {};
-  let tables: DBSchemaTable[] = [];
+  const tables: DBSchemaTable[] = [];
+
+  const txKey = !this.prostgles.opts.transactions ? "" : "tx";
 
   try {
     /* Publish tables and views based on socket */
@@ -37,156 +31,71 @@ export async function getSchemaFromPublish(
     if (clientInfo === "new-session-redirect") {
       throw "new-session-redirect";
     }
-    let _publish: PublishObject | undefined;
+    let publish: PublishObject | undefined;
     try {
-      _publish = await this.getPublishAsObject(clientReq, clientInfo);
+      publish = await this.getPublishObject(clientReq, clientInfo);
     } catch (err) {
       console.error("Error within then Publish function ", err);
       throw err;
     }
 
-    if (_publish && Object.keys(_publish).length) {
-      let txKey = "tx";
-      if (!this.prostgles.opts.transactions) txKey = "";
-      if (typeof this.prostgles.opts.transactions === "string")
-        txKey = this.prostgles.opts.transactions;
-
-      const tableNames = Object.keys(_publish).filter((k) => !txKey || txKey !== k);
+    if (!publish || !Object.keys(publish).length) {
+      return { tables, tableSchemaErrors };
+    }
+    const tableNames = Object.keys(publish).filter((k) => !txKey || txKey !== k);
 
-      const fileTableName = this.prostgles.fileManager?.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);
-        }
+    /**
+     * 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.fileManager?.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);
       }
-      await Promise.all(
-        tableNames.map(async (tableName) => {
-          const { canSubscribe, tablesOrViews } = this.prostgles.dboBuilder;
-          if (!this.dbo[tableName]) {
-            const errMsg = [
-              `Table ${tableName} does not exist`,
-              `Expecting one of: ${JSON.stringify(tablesOrViews?.map((tov) => tov.name))}`,
-            ].join("\n");
-            throw errMsg;
-          }
-
-          const parsedTableRule = await this.getTableRules(
-            { clientReq, tableName },
-            clientInfo,
-            scope,
-          );
-
-          if (!parsedTableRule || isEmpty(parsedTableRule)) return;
-          if (!isObject(parsedTableRule)) {
-            throw `Invalid tableRules for table ${tableName}. Expecting an object`;
-          }
-
-          schema[tableName] = {};
-          const tableSchema = schema[tableName];
-          const methods = getKeys(parsedTableRule).filter(
-            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m),
-          );
-          let tableInfo: TableInfo | undefined;
-          let tableColumns: DBSchemaTable["columns"] | undefined;
-
-          await Promise.all(
-            methods
-              .filter((m) => m !== "select")
-              .map(async (method) => {
-                if (method === "sync") {
-                  /* Pass sync info */
-                  tableSchema[method] = parsedTableRule[method];
-                } else if (includes(getKeys(parsedTableRule), method) && parsedTableRule[method]) {
-                  //@ts-ignore
-                  tableSchema[method] =
-                    method === "insert" ?
-                      pickKeys(parsedTableRule[method], ["allowedNestedInserts"])
-                    : ({} as AnyObject);
+    }
 
-                  /* Test for issues with the common table CRUD methods () */
-                  if (includes(TABLE_METHODS, method)) {
-                    try {
-                      this.validateRequestRule(
-                        {
-                          tableName,
-                          command: method,
-                          clientReq,
-                        },
-                        parsedTableRule,
-                        scope,
-                      );
-                      if (this.prostgles.opts.testRulesOnConnect) {
-                        await (this.dbo[tableName] as TableHandler)[method](
-                          {},
-                          {},
-                          undefined,
-                          parsedTableRule,
-                          {
-                            ...clientReq,
-                            isRemoteRequest: {},
-                            testRule: true,
-                          },
-                        );
-                      }
-                    } catch (e) {
-                      console.error(`${tableName}.${method}`, e);
-                      tableSchemaErrors[tableName] ??= {};
-                      tableSchemaErrors[tableName][method] = {
-                        error: "Internal publish error. Check server logs",
-                      };
+    await Promise.all(
+      tableNames.map(async (tableName) => {
+        const { tablesOrViews } = this.prostgles.dboBuilder;
+        const tableHandler = this.dbo[tableName];
+        if (!tableHandler) {
+          const errMsg = [
+            `Table ${tableName} does not exist`,
+            `Expecting one of: ${JSON.stringify(tablesOrViews?.map((tov) => tov.name))}`,
+          ].join("\n");
+          throw errMsg;
+        }
 
-                      throw {
-                        ...getErrorAsObject(e),
-                        publish_path: `publish.${tableName}.${method}`,
-                      };
-                    }
-                  }
+        const parsedTableRule = await this.getTableRules(
+          { clientReq, tableName },
+          clientInfo,
+          scope,
+        );
 
-                  if (method === "getInfo" || method === "getColumns") {
-                    this.validateRequestRule(
-                      { tableName, command: method, clientReq },
-                      parsedTableRule,
-                      scope,
-                    );
-                    const res = await (this.dbo[tableName] as TableHandler)[method](
-                      undefined,
-                      undefined,
-                      undefined,
-                      parsedTableRule,
-                      { ...clientReq, isRemoteRequest: {} },
-                    );
-                    if (method === "getInfo") {
-                      tableInfo = res as TableInfo;
-                    } else {
-                      tableColumns = res as DBSchemaTable["columns"];
-                    }
-                  }
-                }
-              }),
-          );
+        if (!parsedTableRule || isEmpty(parsedTableRule)) return;
+        if (!isObject(parsedTableRule)) {
+          throw `Invalid tableRules for table ${tableName}. Expecting an object`;
+        }
 
-          if (tableInfo && tableColumns) {
-            tables.push({
-              name: tableName,
-              info: tableInfo,
-              columns: tableColumns,
-            });
-          }
-        }),
-      );
-    }
+        const tableSchema = await getDBSchemaTable(
+          this,
+          tableHandler,
+          parsedTableRule,
+          clientReq,
+          scope,
+        );
+        tables.push(tableSchema);
+      }),
+    );
   } catch (error) {
     console.error("Publish error", error);
     throw error;
   }
 
-  tables = tables.sort((a, b) => a.name.localeCompare(b.name));
-  return { schema, tables, tableSchemaErrors };
+  // tables = tables.sort((a, b) => a.name.localeCompare(b.name));
+  return { tables, tableSchemaErrors };
 }