prostgles-server 4.2.566 → 4.2.569

package/lib/FileManager/getLocalStorageClient.ts

@@ -0,0 +1,118 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import stream from "stream";
+import type {
+  FileUploadArgs,
+  LocalConfig,
+  LocalStorageClient,
+  UploadedCloudFile,
+} from "./FileManager";
+
+export const getLocalStorageClient = (localConfig: LocalConfig): LocalStorageClient => {
+  const { localFolderPath, minFreeBytes = 100 * 1024 * 1024 } = localConfig; // Default 100MB
+
+  // Helper to ensure we have enough free disk space (Requires Node >= 18.17.0)
+  const checkFreeSpace = async () => {
+    try {
+      const stats = await fs.promises.statfs(localFolderPath);
+      const freeSpace = stats.bavail * stats.bsize;
+
+      if (freeSpace < minFreeBytes) {
+        throw new Error(
+          `Insufficient disk space. Required: ${minFreeBytes} bytes, Available: ${freeSpace} bytes`,
+        );
+      }
+    } catch (error: any) {
+      // If the directory doesn't exist yet, statfs will throw. We'll ignore and let mkdir handle it.
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  };
+
+  return {
+    type: "local",
+    localFolderPath: localConfig.localFolderPath,
+    upload: async (args: FileUploadArgs): Promise<UploadedCloudFile> => {
+      // Ensure the target directory exists
+      await fs.promises.mkdir(localFolderPath, { recursive: true });
+      await checkFreeSpace();
+
+      const filePath = path.join(localFolderPath, args.fileName);
+      const hash = crypto.createHash("md5");
+      let contentLength = 0;
+
+      return new Promise((resolve, reject) => {
+        const writeStream = fs.createWriteStream(filePath);
+
+        writeStream.on("error", reject);
+        writeStream.on("finish", () => {
+          resolve({
+            cloud_url: filePath,
+            etag: hash.digest("hex"),
+            content_length: contentLength,
+          });
+        });
+
+        // Handle raw string or Buffer
+        if (typeof args.file === "string" || Buffer.isBuffer(args.file)) {
+          const buffer = Buffer.isBuffer(args.file) ? args.file : Buffer.from(args.file);
+
+          contentLength = buffer.length;
+          hash.update(buffer);
+
+          if (args.onProgress) {
+            args.onProgress(contentLength);
+          }
+
+          writeStream.write(buffer);
+          writeStream.end();
+        } else if (
+          args.file instanceof stream.Readable ||
+          (args.file as unknown) instanceof stream.PassThrough
+        ) {
+          let lastProgress = Date.now();
+          const throttle = 1000; // 1 second
+          args.file.on("data", (chunk: Buffer) => {
+            contentLength += chunk.length;
+            hash.update(chunk);
+            if (args.onProgress && Date.now() - lastProgress > throttle) {
+              lastProgress = Date.now();
+              args.onProgress(contentLength);
+            }
+          });
+
+          args.file.on("error", reject);
+          args.file.pipe(writeStream);
+        } else {
+          reject(new Error("Unsupported file type provided to upload."));
+        }
+      });
+    },
+
+    downloadAsStream: async (name: string) => {
+      const filePath = path.join(localFolderPath, name);
+
+      try {
+        await fs.promises.access(filePath, fs.constants.R_OK);
+      } catch (err) {
+        throw new Error(`File not found or unreadable: ${name}`);
+      }
+
+      return fs.createReadStream(filePath);
+    },
+
+    delete: async (fileName: string) => {
+      const filePath = path.join(localFolderPath, fileName);
+      try {
+        await fs.promises.unlink(filePath);
+      } catch (err: any) {
+        // Ignore error if file doesn't exist
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+    },
+  };
+};

package/lib/FileManager/getValidatedFileType.ts

@@ -1,13 +1,7 @@
-import type {
-  ALLOWED_CONTENT_TYPE} from "prostgles-types";
-import {
-  ALLOWED_EXTENSION,
-  CONTENT_TYPE_TO_EXT,
-  getKeys,
-  isObject,
-} from "prostgles-types";
+import type { ALLOWED_CONTENT_TYPE } from "prostgles-types";
+import { CONTENT_TYPE_TO_EXT, getKeys, isObject } from "prostgles-types";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
-import type { FileManager} from "./FileManager";
+import type { FileTableConfig } from "../ProstglesTypes";
 import { getFileType, getFileTypeFromFilename } from "./FileManager";
 
 type Args = {
@@ -16,19 +10,17 @@ type Args = {
   colName?: string;
   tableName?: string;
 };
-export async function getValidatedFileType(
-  this: FileManager,
-  args: Args
+export const getValidatedFileType = async (
+  config: FileTableConfig,
+  args: Args,
 ): Promise<{
   mime: ALLOWED_CONTENT_TYPE;
-  ext: string; //| ALLOWED_EXTENSION;
+  ext: string;
 
   /** File name is not returned because we fail if the extensions do not match */
   // fileName: string;
-}> {
+}> => {
   const { file, fileName, tableName, colName } = args;
-  const config = this.prostgles?.opts.fileTable;
-  if (!config) throw new Error("File table config missing");
 
   const buffer = typeof file === "string" ? Buffer.from(file, "utf8") : file;
 
@@ -55,7 +47,7 @@ export async function getValidatedFileType(
         const allowedContent = parseFieldFilter(colConfig.acceptedContent, false, CONTENTS);
         if (!allowedContent.some((c) => mime.mime.startsWith(c))) {
           throw new Error(
-            `Dissallowed content type provided: ${mime.mime.split("/")[0]}. Allowed content types: ${allowedContent} `
+            `Disallowed content type provided: ${mime.mime.split("/")[0]}. Allowed content types: ${allowedContent} `,
           );
         }
       } else if (
@@ -67,12 +59,12 @@ export async function getValidatedFileType(
         const allowedContentTypes = parseFieldFilter(
           colConfig.acceptedContentType,
           false,
-          getKeys(CONTENT_TYPE_TO_EXT)
+          getKeys(CONTENT_TYPE_TO_EXT),
         );
 
         if (!allowedContentTypes.some((c) => c === mime.mime)) {
           throw new Error(
-            `Dissallowed MIME provided: ${mime.mime}. Allowed MIME values: ${allowedContentTypes} `
+            `Disallowed MIME provided: ${mime.mime}. Allowed MIME values: ${allowedContentTypes} `,
           );
         }
       } else if (
@@ -84,12 +76,12 @@ export async function getValidatedFileType(
         const allowedExtensions = parseFieldFilter(
           colConfig.acceptedFileTypes,
           false,
-          Object.values(CONTENT_TYPE_TO_EXT).flat()
+          Object.values(CONTENT_TYPE_TO_EXT).flat(),
         );
 
         if (!allowedExtensions.some((c) => c === mime.ext)) {
           throw new Error(
-            `Dissallowed extension provided: ${mime.ext}. Allowed extension values: ${allowedExtensions} `
+            `Disallowed extension provided: ${mime.ext}. Allowed extension values: ${allowedExtensions} `,
           );
         }
       }
@@ -97,4 +89,4 @@ export async function getValidatedFileType(
   }
   if (!result?.mime) throw `File MIME type not found for the provided extension: ${result?.ext}`;
   return result;
-}
+};

package/lib/FileManager/setupFileServeHandler.ts

@@ -0,0 +1,102 @@
+import * as fs from "fs";
+import { join } from "path";
+import { HTTP_FAIL_CODES, removeExpressRoute } from "../Auth/AuthHandler";
+import type { DB } from "../initProstgles";
+import type { Prostgles } from "../Prostgles";
+import type { FileTableConfig } from "../ProstglesTypes";
+import type { ExpressApp } from "../RestApi";
+import { runClientRequest } from "../runClientRequest";
+import type { StorageClient } from "./FileManager";
+import { HOUR } from "./FileManager";
+import type { FileTableRow } from "./getFileTableConfig";
+
+export const setupFileServeHandler = (
+  db: DB,
+  config: FileTableConfig,
+  storageClient: StorageClient,
+  app: ExpressApp,
+  prg: Prostgles,
+) => {
+  const fileTableName = config.tableName;
+  const fileServeRoute = config.fileServePath ?? `/${fileTableName}`;
+  if (fileServeRoute.endsWith("/")) {
+    throw `fileServeRoute must not end with a '/'`;
+  }
+  const fileRouteExpress = fileServeRoute + "/:name";
+
+  app.get(fileRouteExpress, async (req, res) => {
+    try {
+      const { name } = req.params;
+      if (typeof name !== "string" || !name) {
+        throw "Invalid media name";
+      }
+      const id = name.slice(0, 36);
+      const selectParams = {
+        select: {
+          id: 1,
+          name: 1,
+          signed_url: 1,
+          signed_url_expires: 1,
+          content_type: 1,
+        },
+      };
+      const file = (await runClientRequest.bind(prg)(
+        {
+          command: "findOne",
+          tableName: fileTableName,
+          param1: { id },
+          param2: selectParams,
+          param3: undefined,
+        },
+        {
+          res,
+          httpReq: req,
+        },
+        undefined,
+      )) as FileTableRow | undefined;
+
+      if (!file) {
+        res.status(HTTP_FAIL_CODES.NOT_FOUND).send("File not found or not allowed");
+        return;
+      }
+
+      if (storageClient.type === "cloud") {
+        let url = file.signed_url;
+        const expires = +(file.signed_url_expires || 0);
+
+        const EXPIRES = Date.now() + HOUR;
+        if (!url || expires < EXPIRES) {
+          url = await storageClient.getSignedUrlForDownload(file.name, 60 * 60);
+
+          await db.any(
+            "UPDATE ${fileTableName:name} SET signed_url = ${signed_url}, signed_url_expires = ${signed_url_expires} WHERE id = ${id}",
+            {
+              fileTableName,
+              id: file.id,
+              signed_url: url,
+              signed_url_expires: EXPIRES,
+            },
+          );
+        }
+
+        res.redirect(url);
+      } else {
+        const localFilePath = join(storageClient.localFolderPath, file.name);
+        if (!fs.existsSync(localFilePath)) {
+          throw new Error("File not found");
+        }
+        res.contentType(file.content_type);
+        res.sendFile(localFilePath);
+      }
+    } catch (e) {
+      console.log(e);
+      res.status(HTTP_FAIL_CODES.BAD_REQUEST).send("Invalid/disallowed file");
+    }
+  });
+
+  const destroy = () => {
+    removeExpressRoute(app, [fileRouteExpress]);
+  };
+
+  return { destroy };
+};

package/lib/JSONBSchemaValidation/validateJSONBSchemaSQL.ts

@@ -329,7 +329,46 @@ BEGIN
     END LOOP;
 
     ${raiseException(`E'No oneOf schemas matching:\n  % ), %', v_one_of_errors, path`)}  
+    
+  /* tuple: [FieldType, FieldType, ...] */
+  ELSIF schema ? 'tuple' THEN
+
+    IF jsonb_typeof(schema->'tuple') != 'array' THEN
+      ${raiseException(`'Invalid tuple schema. Expected tuple to be an array, got: %. %', jsonb_typeof(schema->'tuple'), path`)}
+    END IF;
 
+    IF jsonb_typeof(data) != 'array' THEN
+      ${raiseException(`'Tuple data is not an array. %', path`)}
+    END IF;
+
+    IF jsonb_array_length(data) != jsonb_array_length(schema->'tuple') THEN
+      ${raiseException(`'Tuple length does not match schema. Expected %, got %. %',
+        jsonb_array_length(schema->'tuple'),
+        jsonb_array_length(data),
+        path`)}
+    END IF;
+
+    FOR array_element IN
+      SELECT
+        data_item.value AS data_value,
+        tuple_item.value AS schema_value,
+        data_item.ordinality - 1 AS idx
+      FROM jsonb_array_elements(data) WITH ORDINALITY AS data_item(value, ordinality)
+      INNER JOIN jsonb_array_elements(schema->'tuple') WITH ORDINALITY AS tuple_item(value, ordinality)
+        ON data_item.ordinality = tuple_item.ordinality
+    LOOP
+      IF NOT ${VALIDATE_SCHEMA_FUNCNAME}(
+        array_element.schema_value::TEXT,
+        array_element.data_value,
+        context,
+        checked_path || array_element.idx::TEXT
+      ) THEN
+        RETURN FALSE;
+      END IF;
+    END LOOP;
+
+    RETURN TRUE;
+ 
   /* arrayOfType: { key_name: { type: "string" } } */
   ELSIF (schema ? 'arrayOf' OR schema ? 'arrayOfType') THEN
 

package/lib/Logging.ts

@@ -164,7 +164,6 @@ export namespace EventTypes {
           type: "debug";
           command:
             | "applyTableConfig"
-            | "initFileTable"
             | "initTableConfig"
             | "runSQLFile"
             | "schemaChangeNotif"
@@ -174,8 +173,6 @@ export namespace EventTypes {
             | "refreshDBO.end"
             | "tableConfigurator.init.start"
             | "tableConfigurator.init.end"
-            | "initFileTable.start"
-            | "initFileTable.end"
             | "initFileManager.runQuery"
             | "DboBuilder.getTablesForSchemaPostgresSQL"
             | "PubSubManager.create";

package/lib/Prostgles.ts

@@ -1,6 +1,5 @@
 import type pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
-import { FileManager } from "./FileManager/FileManager";
 import type { OnInitReason } from "./initProstgles";
 import { initProstgles } from "./initProstgles";
 import type { SchemaWatch } from "./SchemaWatch/SchemaWatch";
@@ -10,7 +9,7 @@ import pg = require("pg-promise/typescript/pg-subset");
 
 import type { ProstglesInitOptions } from "./ProstglesTypes";
 import { RestApi } from "./RestApi";
-import TableConfigurator from "./TableConfig/TableConfig";
+import { TableConfigurator } from "./TableConfig/TableConfigurator";
 
 import type { PRGLIOSocket } from "./DboBuilder/DboBuilder";
 import { DBHandlerServer, DboBuilder } from "./DboBuilder/DboBuilder";
@@ -59,8 +58,9 @@ const DEFAULT_KEYWORDS = {
 
 import { randomUUID } from "crypto";
 import * as fs from "fs";
-import type { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 import type { getAdminClient } from "./DboBuilder/runSql/getAdminClient";
+import type { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
+import { getFileTableConfig } from "./FileManager/getFileTableConfig";
 
 export class Prostgles {
   /**
@@ -108,11 +108,14 @@ export class Prostgles {
   dbEventsManager?: DBEventsManager;
   schemaAge = "0";
 
-  fileManager?: FileManager;
   restApi?: RestApi;
 
   tableConfigurator?: TableConfigurator;
 
+  get mergedTableConfig() {
+    return getFileTableConfig(this);
+  }
+
   isMedia(tableName: string) {
     return this.opts.fileTable?.tableName === tableName;
   }
@@ -147,6 +150,8 @@ export class Prostgles {
       onLog: 1,
       restApi: 1,
       testRulesOnConnect: 1,
+      modifyClientSchema: 1,
+      expressApp: 1,
     };
     const unknownParams = Object.keys(params).filter(
       (key: string) => !Object.keys(config).includes(key),
@@ -157,10 +162,6 @@ export class Prostgles {
 
     this.opts = { ...this.opts, ...params };
 
-    /* set defaults */
-    if (this.opts.fileTable) {
-      this.opts.fileTable.tableName ??= "media";
-    }
     this.opts.schemaFilter ??= { public: 1 };
 
     this.keywords = {
@@ -195,10 +196,8 @@ export class Prostgles {
     if (this.opts.tsGeneratedTypesDir) {
       const { fullPath, fileName } = this.getTSFileName();
       const { tsSchema: fileContent } = this.dboBuilder.getTsDefinitions();
-      // eslint-disable-next-line security/detect-non-literal-fs-filename
       fs.readFile(fullPath, "utf8", function (err, data) {
         if (err || force || data !== fileContent) {
-          // eslint-disable-next-line security/detect-non-literal-fs-filename
           fs.writeFileSync(fullPath, fileContent);
           console.log("Prostgles: Created typescript schema definition file: \n " + fileName);
         }
@@ -285,39 +284,6 @@ export class Prostgles {
     return res.data;
   };
 
-  /* Create media table if required */
-  initFileTable = async () => {
-    const res = await tryCatchV2(async () => {
-      if (this.opts.fileTable) {
-        const { cloudClient, localConfig, imageOptions } = this.opts.fileTable;
-        await this.refreshDBO();
-        if (!cloudClient && !localConfig)
-          throw "fileTable missing param: Must provide awsS3Config OR localConfig";
-
-        this.fileManager = new FileManager(cloudClient || localConfig!, imageOptions);
-
-        try {
-          await this.fileManager.init(this);
-        } catch (e) {
-          console.error("FileManager: ", e);
-          this.fileManager = undefined;
-        }
-      } else {
-        this.fileManager?.destroy();
-        this.fileManager = undefined;
-      }
-      await this.refreshDBO();
-      return { data: {} };
-    });
-    await this.opts.onLog?.({
-      type: "debug",
-      command: "initFileTable",
-      ...res,
-    });
-    if (res.error !== undefined) throw res.error;
-    return res.data;
-  };
-
   isSuperUser = false;
 
   init = initProstgles.bind(this);
@@ -365,7 +331,6 @@ export async function getIsSuperUser(db: DBorTx): Promise<boolean> {
 
 export const getFileText = (fullPath: string, _format = "utf8"): Promise<string> => {
   return new Promise((resolve, reject) => {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
     fs.readFile(fullPath, "utf8", function (err, data) {
       if (err) reject(err);
       else resolve(data);

package/lib/ProstglesTypes.ts

@@ -1,14 +1,18 @@
-import type { FileColumnConfig } from "prostgles-types";
-import type { AuthConfig, AuthRequestParams, SessionUser } from "./Auth/AuthTypes";
+import type { DBSchemaTable, FileColumnConfig, MaybePromise } from "prostgles-types";
+import type {
+  AuthConfig,
+  AuthRequestParams,
+  AuthResultWithSID,
+  SessionUser,
+} from "./Auth/AuthTypes";
 import type { EventTriggerTagFilter } from "./Event_Trigger_Tags";
-import type { CloudClient, ImageOptions, LocalConfig } from "./FileManager/FileManager";
+import type { StorageClient } from "./FileManager/FileManager";
 import type { DbConnection, OnReadyCallback } from "./initProstgles";
 import type { EventInfo } from "./Logging";
 import type { ExpressApp, RestApiConfig } from "./RestApi";
 import type { OnSchemaChangeCallback } from "./SchemaWatch/SchemaWatch";
 import type { PGConstraint } from "./TableConfig/fetchTableConstraints";
-import type { TableConfig } from "./TableConfig/TableConfig";
-import type { Express } from "express";
+import type { TableConfig } from "./TableConfig/TableConfigTypes";
 
 import type { PRGLIOSocket } from "./DboBuilder/DboBuilder";
 
@@ -16,8 +20,8 @@ import type pgPromise from "pg-promise";
 import type pg from "pg-promise/typescript/pg-subset";
 import type { AnyObject } from "prostgles-types";
 import type { Server } from "socket.io";
-import type { Awaitable, Publish, PublishParams } from "./PublishParser/PublishParser";
 import type { ServerFunctionDefinitions } from "./PublishParser/defineServerFunction";
+import type { Awaitable, Publish, PublishParams } from "./PublishParser/PublishParser";
 
 /**
  * Allows uploading and downloading files.
@@ -37,9 +41,8 @@ import type { ServerFunctionDefinitions } from "./PublishParser/defineServerFunc
 export type FileTableConfig = {
   /**
    * Name of the table that will contain the file metadata.
-   * Defaults to "files"
    */
-  tableName?: string;
+  tableName: string;
 
   /**
    * GET path used in serving media. defaults to /${tableName}
@@ -57,16 +60,11 @@ export type FileTableConfig = {
      */
     deleteAfterNDays: number;
     /**
-     * How freuquently the files will be checked for deletion delay
+     * How frequently the files will be checked for deletion delay
      */
     checkIntervalHours?: number;
   };
 
-  /**
-   * Express server instance
-   */
-  expressApp: ExpressApp | Express;
-
   /**
    * Specifying referencedTables with referenceColumns allows restricting the
    * allowed file types that can be inserted and referenced in the specified tables.
@@ -78,18 +76,12 @@ export type FileTableConfig = {
      * */
     { type: "column"; referenceColumns: Record<string, FileColumnConfig> };
   };
-  imageOptions?: ImageOptions;
 
   /**
    * Callbacks for file upload and download.
    * Used for custom file handling.
    */
-  cloudClient?: CloudClient;
-
-  /**
-   * Local file storage configuration.
-   */
-  localConfig?: LocalConfig;
+  storageClient: StorageClient;
 };
 
 export const JOIN_TYPES = ["one-many", "many-one", "one-one", "many-many"] as const;
@@ -100,6 +92,11 @@ export type Join = {
 };
 type Joins = Join[] | "inferred";
 
+type ModifyClientSchema<SUser extends SessionUser = SessionUser> = (
+  tables: DBSchemaTable,
+  userData: AuthResultWithSID<SUser> | undefined,
+) => MaybePromise<DBSchemaTable>;
+
 export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUser> = {
   /**
    * Database connection details and options
@@ -129,6 +126,14 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
    */
   io?: Server;
 
+  /**
+   * Express server instance used for:
+   * - Auth
+   * - REST API
+   * - Serving files through the file manager
+   */
+  expressApp?: ExpressApp;
+
   /**
    * Rest API configuration.
    * The REST API allows interacting with the database similarly to the websocket connection.
@@ -189,7 +194,7 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
 
   /**
    * Allows defining table relationships that can then be used in filters and data inserts:
-   *  - `infered` - uses the foreign keys to infer the joins
+   *  - `inferred` - uses the foreign keys to infer the joins
    *  - `Join[]` - specifies the joins manually
    */
   joins?: Joins;
@@ -307,9 +312,15 @@ export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUs
   tableConfigMigrations?: TableConfigMigrations;
 
   /**
-   * Usefull for logging or debugging
+   * Useful for logging or debugging
    */
   onLog?: (evt: EventInfo) => Promise<void> | void;
+
+  /**
+   * Used to add custom metadata to the table and column schemas.
+   * This metadata is then available in the client schema and can be used for custom logic on the client side.
+   */
+  modifyClientSchema?: ModifyClientSchema<SUser>;
 };
 
 export type TableConfigMigrations = {

package/lib/PubSubManager/notifListener.ts

@@ -15,8 +15,6 @@ export async function notifListener(this: PubSubManager, data: { payload: string
   const dataArr = str.split(DELIMITER);
   const notifType = dataArr[0] as NotifTypeName;
 
-  log(str);
-
   const commonLog = {
     triggers: this._triggers,
     sid: undefined,

package/lib/PublishParser/getDBSchemaTable.ts

@@ -1,5 +1,5 @@
 import { getObjectEntries, includes, type DBSchemaTable } from "prostgles-types";
-import type { AuthClientRequest } from "../Auth/AuthTypes";
+import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
 import { getErrorAsObject } from "../DboBuilder/dboBuilderUtils";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { TABLE_METHODS } from "../Prostgles";
@@ -11,6 +11,7 @@ export const getDBSchemaTable = async (
   tableHandler: TableHandler,
   parsedTableRule: ParsedTableRule,
   clientReq: AuthClientRequest,
+  clientInfo: AuthResultWithSID | undefined,
   scope: PermissionScope | undefined,
 ): Promise<DBSchemaTable> => {
   const tableName = tableHandler.name;
@@ -20,11 +21,13 @@ export const getDBSchemaTable = async (
   }
   const info = await tableHandler.getInfo(undefined, undefined, undefined, parsedTableRule, {
     ...clientReq,
-    isRemoteRequest: {},
+    isRemoteRequest: {
+      clientInfo,
+    },
   });
   const columns = await tableHandler.getColumns(undefined, undefined, undefined, parsedTableRule, {
     ...clientReq,
-    isRemoteRequest: {},
+    isRemoteRequest: { clientInfo },
   });
   const allowedCommands = getAllowedTableMethods(info);
   for (const method of allowedCommands) {

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -45,7 +45,7 @@ export async function getSchemaFromPublish(
      * 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;
+    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)),
@@ -83,6 +83,7 @@ export async function getSchemaFromPublish(
           tableHandler,
           parsedTableRule,
           clientReq,
+          clientInfo,
           scope,
         );
         tables.push(tableSchema);