prostgles-server 4.2.567 → 4.2.570

package/lib/FileManager/setupFileServeHandler.ts

@@ -0,0 +1,102 @@
+import type e from "express";
+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 { 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: e.Express,
+  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/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,7 @@ export class Prostgles {
       onLog: 1,
       restApi: 1,
       testRulesOnConnect: 1,
+      modifyClientSchema: 1,
     };
     const unknownParams = Object.keys(params).filter(
       (key: string) => !Object.keys(config).includes(key),
@@ -157,10 +161,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 +195,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 +283,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 +330,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,23 +1,28 @@
-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 { 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";
 
+import type e from "express";
 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,15 +42,16 @@ 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}
    */
   fileServePath?: string;
 
+  expressApp: e.Express;
+
   /**
    * If defined the the files will not be deleted immediately
    * Instead, the "deleted" field will be updated to the current timestamp and after the day interval provided in "deleteAfterNDays" the files will be deleted
@@ -57,16 +63,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 +79,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 +95,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
@@ -189,7 +189,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 +307,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);

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -60,6 +60,7 @@ export type ValidateBeforeRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> =
   tx: pgPromise.ITask<{}> | DB;
   command: "insert" | "update";
   data: Partial<R>;
+  filter: AnyObject | undefined;
 };
 export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
   row: R;

package/lib/RestApi.ts

@@ -6,6 +6,7 @@ import type { Prostgles } from "./Prostgles";
 import { runClientMethod, runClientRequest, runClientSqlRequest } from "./runClientRequest";
 import type { VoidFunction } from "./SchemaWatch/SchemaWatch";
 import { isDefined } from "prostgles-types";
+import type e from "express";
 
 type ExpressInternalRouter = {
   stack?: {
@@ -31,10 +32,7 @@ export type ExpressApp = {
 } & Omit<Express, "_router" | "router">;
 
 export type RestApiConfig = {
-  /**
-   * Express server instance
-   */
-  expressApp: Express;
+  expressApp: e.Express;
 
   /**
    * Defaults to "/api"
@@ -50,9 +48,9 @@ export class RestApi {
     methods: string;
     schema: string;
   };
-  expressApp: ExpressApp;
+  expressApp: e.Express;
   path = "/api";
-  constructor({ expressApp, path, prostgles }: RestApiConfig & { prostgles: Prostgles }) {
+  constructor({ path, prostgles, expressApp }: RestApiConfig & { prostgles: Prostgles }) {
     if (isDefined(path) && !path.trim()) {
       throw new Error("path cannot be empty");
     }
@@ -64,19 +62,21 @@ export class RestApi {
       methods: `${path}/methods/:name`,
       schema: `${path}/schema`,
     };
-    this.expressApp = expressApp as ExpressApp;
+
+    this.expressApp = expressApp;
     /** Must check if json parser is loaded */
 
-    expressApp.post(this.routes.db, this.onPostTableCommand);
-    expressApp.post(this.routes.sql, this.onPostSql);
-    expressApp.post(this.routes.methods, this.onPostMethod);
-    expressApp.post(this.routes.schema, this.onPostSchema);
+    this.expressApp.post(this.routes.db, this.onPostTableCommand);
+    this.expressApp.post(this.routes.sql, this.onPostSql);
+    this.expressApp.post(this.routes.methods, this.onPostMethod);
+    this.expressApp.post(this.routes.schema, this.onPostSchema);
   }
 
   destroy = () => {
     this.expressApp.removeListener(this.routes.db, this.onPostTableCommand);
     this.expressApp.removeListener(this.routes.sql, this.onPostSql);
     this.expressApp.removeListener(this.routes.methods, this.onPostMethod);
+    this.expressApp.removeListener(this.routes.schema, this.onPostSchema);
     removeExpressRoute(this.expressApp, [this.path]);
   };
   onPostMethod = async (req: ExpressReq, res: ExpressRes) => {
@@ -120,7 +120,7 @@ export class RestApi {
   onPostSql = async (req: ExpressReq, res: ExpressRes) => {
     const [query, params, options] = req.body || [];
     try {
-      const data = await runClientSqlRequest.bind(this.prostgles)(
+      const data: unknown = await runClientSqlRequest.bind(this.prostgles)(
         {
           query,
           params,