prostgles-server 4.0.16 → 4.0.18

package/lib/FileManager/initFileManager.ts

@@ -0,0 +1,236 @@
+import { asName, getKeys } from "prostgles-types";
+import { canCreateTables } from "../DboBuilder/runSQL";
+import { TableHandler } from "../DboBuilder/TableHandler";
+import { Prostgles } from "../Prostgles";
+import { FileManager, HOUR, LocalConfig } from "./FileManager";
+import * as fs from 'fs';
+import { PubSubManager } from "../PubSubManager/PubSubManager";
+
+export async function initFileManager(this: FileManager, prg: Prostgles){
+  this.prostgles = prg;
+  
+  // const { dbo, db, opts } = prg;
+  
+  const { fileTable } = prg.opts;
+  if(!fileTable) throw "fileTable missing";
+  const { tableName = "media", referencedTables = {} } = fileTable;
+  this.tableName = tableName;
+
+  const maxBfSizeMB = (prg.opts.io?.engine?.opts?.maxHttpBufferSize || 1e6)/1e6;
+  console.log(`Prostgles: Initiated file manager. Max allowed file size: ${maxBfSizeMB}MB (maxHttpBufferSize = 1e6). To increase this set maxHttpBufferSize in socket.io server init options`);
+
+  // throw `this.db.tx(d => do everything in a transaction pls!!!!`;
+
+  const canCreate = await canCreateTables(this.db);
+  const runQuery = (q: string): Promise<any[]> => {
+    if(!canCreate) throw "File table creation failed. Your postgres user does not have CREATE table privileges";
+    return this.db.any(`
+      ${q}
+    `);
+    /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+  }
+  /**
+   * 1. Create media table
+   */
+  if(!this.dbo[tableName]){
+    
+    console.log(`Creating fileTable ${asName(tableName)} ...`);
+    await runQuery(`CREATE EXTENSION IF NOT EXISTS pgcrypto `);
+    await runQuery(`CREATE TABLE IF NOT EXISTS ${asName(tableName)} (
+        name                  TEXT NOT NULL,
+        extension             TEXT NOT NULL,
+        content_type          TEXT NOT NULL,
+        content_length        BIGINT NOT NULL DEFAULT 0,
+        added                 TIMESTAMP NOT NULL DEFAULT NOW(),
+        url                   TEXT NOT NULL,
+        id                    UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        original_name         TEXT NOT NULL,
+        description           TEXT,
+        s3_url                TEXT,
+        signed_url            TEXT,
+        signed_url_expires    BIGINT,
+        etag                  TEXT,
+        deleted               BIGINT,
+        deleted_from_storage  BIGINT,
+        UNIQUE(id),
+        UNIQUE(name)
+    )`);
+    console.log(`Created fileTable ${asName(tableName)}`);
+    await prg.refreshDBO();
+  }
+
+  /**
+   * 2. Create media lookup tables 
+   */
+  for(const refTable in referencedTables){
+
+    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 tableConfig = referencedTables[refTable]!;
+    if(typeof tableConfig !== "string"){
+      
+      for (const colName of getKeys(tableConfig.referenceColumns)){
+        
+        const existingCol = cols.find(c => c.name === colName);
+        if(existingCol){
+          if(existingCol.references?.some(({ ftable }) => ftable === tableName)){
+            // All ok
+          } else {
+            if(existingCol.udt_name === "uuid"){
+              try {
+                const query = `ALTER TABLE ${asName(refTable)} ADD FOREIGN KEY (${asName(colName)}) REFERENCES ${asName(tableName)} (id);`;
+                console.log(`Referenced file column ${refTable} (${colName}) exists but is not referencing file table. Trying to add REFERENCE constraing...\n${query}`);
+                await runQuery(query);
+                console.log("SUCCESS: " + query);
+              } catch(e){
+                console.error(`Could not add constraing. Err: ${e instanceof Error? e.message : JSON.stringify(e)}`)
+              }
+            } else {
+              console.error(`Referenced file column ${refTable} (${colName}) exists but is not of required type (UUID). Choose a different column name or ALTER the existing column to match the type and the data found in file table ${tableName}(id)`);
+            }
+          }
+        } else {
+          try {
+            const query = `ALTER TABLE ${asName(refTable)} ADD COLUMN ${asName(colName)} UUID REFERENCES ${asName(tableName)} (id);`
+            console.log(`Creating referenced file column ${refTable} (${colName})...\n${query}`);
+            await runQuery(query);
+            console.log("SUCCESS: " + query);
+          } catch(e){
+            console.error(`FAILED. Err: ${e instanceof Error? e.message : JSON.stringify(e)}`)
+          }
+        }
+        
+      }
+    } else {
+
+      const lookupTableName = await this.parseSQLIdentifier(`prostgles_lookup_${tableName}_${refTable}`);
+      const pKeyFields = cols.filter(f => f.is_pkey);
+
+      if(pKeyFields.length !== 1) {
+        console.error(`Could not make link table for ${refTable}. ${pKeyFields} must have exactly one primary key column. Current pkeys: ${pKeyFields.map(f => f.name)}`);
+      }
+
+      const pkField = pKeyFields[0]!;
+      const refType = referencedTables[refTable];
+
+      if(!this.dbo[lookupTableName]){
+        // if(!(await dbo[lookupTableName].count())) await db.any(`DROP TABLE IF EXISTS  ${lookupTableName};`);
+        const action = ` (${tableName} <-> ${refTable}) join table ${lookupTableName}`; //  PRIMARY KEY
+        const query = `        
+        CREATE TABLE ${lookupTableName} (
+          foreign_id  ${pkField.udt_name} ${refType === "one"? " PRIMARY KEY " : ""} REFERENCES ${asName(refTable)}(${asName(pkField.name)}),
+          media_id    UUID NOT NULL REFERENCES ${asName(tableName)}(id)
+        )
+        `;
+        console.log(`Creating ${action} ...`, lookupTableName);
+        await runQuery(query);
+        console.log(`Created ${action}`);
+
+      } else {
+        const cols = await this.dbo[lookupTableName]!.getColumns!();
+        const badCols = cols.filter(c => !c.references);
+        await Promise.all(badCols.map(async badCol => {
+          console.error(
+            `Prostgles: media ${lookupTableName} joining table has lost a reference constraint for column ${badCol.name}.` + 
+            ` This may have been caused by a DROP TABLE ... CASCADE.`
+          );
+          let q = ` ALTER TABLE ${asName(lookupTableName)} ADD FOREIGN KEY (${badCol.name}) `;
+          console.log("Trying to add the missing constraint back");
+          if(badCol.name === "foreign_id"){
+            q += `REFERENCES ${asName(refTable)}(${asName(pkField.name)}) `;
+          } else if(badCol.name === "media_id"){
+            q += `REFERENCES ${asName(tableName)}(id) `;
+          }
+
+          if(q){
+
+            try {
+              await runQuery(q)
+              console.log("Added missing constraint back");
+
+            } catch(e){
+              console.error("Failed to add missing constraint", e)
+            }
+          }
+
+        }));
+      }
+    }
+
+
+    await prg.refreshDBO();
+  }
+
+  /**
+   * 4. Serve media through express
+   */
+  const { 
+    fileServeRoute = `/${tableName}`, 
+    expressApp: app 
+  } = fileTable;
+
+  if(fileServeRoute.endsWith("/")){
+    throw `fileServeRoute must not end with a '/'`
+  }
+  this.fileRoute = fileServeRoute;
+
+  if(app){
+    app.get(this.fileRouteExpress, async (req, res) => {
+      if(!this.dbo[tableName]){
+        res.status(500).json({ err: `Internal error: media table (${tableName}) not valid` });
+        return false;
+      }
+
+      const mediaTable = this.dbo[tableName] as unknown as TableHandler;
+
+      try {
+
+        const { name } = req.params;
+        if(typeof name !== "string" || !name) throw "Invalid media name";
+  
+        const media = await mediaTable.findOne({ name }, { select: { id: 1, name: 1, signed_url: 1, signed_url_expires: 1, content_type: 1 } }, { httpReq: req } as any);
+  
+        if(!media) {
+          /**
+           * Redirect to login !??
+           */
+          // const mediaExists = await mediaTable.count({ name });
+          // if(mediaExists && this.prostgles.authHandler){
+
+          // } else {
+          //   throw "Invalid media";
+          // }
+          throw "Invalid media";
+        }
+        
+        if(this.s3Client){
+          let url = media.signed_url;
+          const expires = +(media.signed_url_expires || 0);
+          
+          const EXPIRES = Date.now() + HOUR;
+          if(!url || expires < EXPIRES){
+            url = await this.getFileS3URL(media.name, 60 * 60);
+            await mediaTable.update({ name }, { signed_url: url, signed_url_expires: EXPIRES });
+          }
+
+          res.redirect(url);
+
+        } else {
+          const pth = `${(this.config as LocalConfig).localFolderPath}/${media.name}`;
+          if(!fs.existsSync(pth)){
+            throw new Error("File not found");
+          }
+          res.contentType(media.content_type);
+          res.sendFile(pth);
+        }
+
+      } catch(e){
+        console.log(e)
+        res.status(404).json({ err: "Invalid/missing media" });
+      }
+    });
+  }
+}

package/lib/FileManager/parseFile.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION } from "prostgles-types";
+import { FileManager } from "./FileManager";
+type Args = {
+    file: Buffer | string;
+    fileName: string;
+    colName?: string;
+    tableName?: string;
+};
+export declare function parseFile(this: FileManager, args: Args): Promise<{
+    mime: string | ALLOWED_CONTENT_TYPE;
+    ext: string | ALLOWED_EXTENSION;
+}>;
+export {};
+//# sourceMappingURL=parseFile.d.ts.map

package/lib/FileManager/parseFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFile.d.ts","sourceRoot":"","sources":["parseFile.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAA0C,MAAM,iBAAiB,CAAC;AAElH,OAAO,EAAE,WAAW,EAAwC,MAAM,eAAe,CAAC;AAElF,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,wBAAsB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IACtE,IAAI,EAAE,MAAM,GAAG,oBAAoB,CAAC;IACpC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC;CAIjC,CAAC,CAoDD"}

package/lib/FileManager/parseFile.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const ViewHandler_1 = require("../DboBuilder/ViewHandler");
+const FileManager_1 = require("./FileManager");
+async function parseFile(args) {
+    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;
+    const result = await (0, FileManager_1.getFileTypeFromFilename)(fileName);
+    if (tableName && colName) {
+        const tableConfig = config.referencedTables?.[tableName];
+        if (tableConfig && (0, prostgles_types_1.isObject)(tableConfig) && tableConfig.referenceColumns[colName]) {
+            const colConfig = tableConfig.referenceColumns[colName];
+            if (colConfig.maxFileSizeMB) {
+                const actualBufferSize = Buffer.byteLength(buffer);
+                if ((actualBufferSize / 1e6) > colConfig.maxFileSizeMB) {
+                    throw new Error(`Provided file is larger than the ${colConfig.maxFileSizeMB}MB limit`);
+                }
+            }
+            if ("acceptedContent" in colConfig && colConfig.acceptedContent && colConfig.acceptedContent !== "*") {
+                const mime = await (0, FileManager_1.getFileType)(buffer, fileName);
+                const CONTENTS = [
+                    "image",
+                    "audio",
+                    "video",
+                    "text",
+                    "application",
+                ];
+                const allowedContent = ViewHandler_1.ViewHandler._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} `);
+                }
+            }
+            else if ("acceptedContentType" in colConfig && colConfig.acceptedContentType && colConfig.acceptedContentType !== "*") {
+                const mime = await (0, FileManager_1.getFileType)(buffer, fileName);
+                const allowedContentTypes = ViewHandler_1.ViewHandler._parseFieldFilter(colConfig.acceptedContentType, false, (0, prostgles_types_1.getKeys)(prostgles_types_1.CONTENT_TYPE_TO_EXT));
+                if (!allowedContentTypes.some(c => c === mime.mime)) {
+                    throw new Error(`Dissallowed MIME provided: ${mime.mime}. Allowed MIME values: ${allowedContentTypes} `);
+                }
+            }
+            else if ("acceptedFileTypes" in colConfig && colConfig.acceptedFileTypes && colConfig.acceptedFileTypes !== "*") {
+                const mime = await (0, FileManager_1.getFileType)(buffer, fileName);
+                const allowedExtensions = ViewHandler_1.ViewHandler._parseFieldFilter(colConfig.acceptedFileTypes, false, Object.values(prostgles_types_1.CONTENT_TYPE_TO_EXT).flat());
+                if (!allowedExtensions.some(c => c === mime.ext)) {
+                    throw new Error(`Dissallowed extension provided: ${mime.ext}. Allowed extension values: ${allowedExtensions} `);
+                }
+            }
+        }
+    }
+    if (!result?.mime)
+        throw `File MIME type not found for the provided extension: ${result?.ext}`;
+    return result;
+}
+exports.parseFile = parseFile;

package/lib/FileManager/parseFile.ts

@@ -0,0 +1,69 @@
+import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, CONTENT_TYPE_TO_EXT, getKeys, isObject } from "prostgles-types";
+import { ViewHandler } from "../DboBuilder/ViewHandler";
+import { FileManager, getFileType, getFileTypeFromFilename } from "./FileManager";
+
+type Args = {
+  file: Buffer | string;
+  fileName: string;
+  colName?: string;
+  tableName?: string;
+};
+export async function parseFile(this: FileManager, args: Args): Promise<{
+  mime: string | ALLOWED_CONTENT_TYPE;
+  ext: string | ALLOWED_EXTENSION;
+
+  /** 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;
+
+  const result = await getFileTypeFromFilename(fileName);
+  if(tableName && colName){
+    const tableConfig = config.referencedTables?.[tableName];
+
+    if(tableConfig && isObject(tableConfig) && tableConfig.referenceColumns[colName]){
+      const colConfig = tableConfig.referenceColumns[colName]!;
+      if(colConfig.maxFileSizeMB){
+        const actualBufferSize = Buffer.byteLength(buffer);
+        if((actualBufferSize/1e6) > colConfig.maxFileSizeMB){
+          throw new Error(`Provided file is larger than the ${colConfig.maxFileSizeMB}MB limit`);
+        }
+      }
+      
+      if("acceptedContent" in colConfig && colConfig.acceptedContent && colConfig.acceptedContent !== "*"){
+        const mime = await getFileType(buffer, fileName);
+        const CONTENTS = [ 
+          "image",
+          "audio",
+          "video",
+          "text",
+          "application",
+        ];
+        const allowedContent = ViewHandler._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} `)
+        }
+      } else if("acceptedContentType" in colConfig && colConfig.acceptedContentType && colConfig.acceptedContentType !== "*"){
+        const mime = await getFileType(buffer, fileName);
+        const allowedContentTypes = ViewHandler._parseFieldFilter(colConfig.acceptedContentType, false, getKeys(CONTENT_TYPE_TO_EXT));
+        
+        if(!allowedContentTypes.some(c => c === mime.mime)){
+          throw new Error(`Dissallowed MIME provided: ${mime.mime}. Allowed MIME values: ${allowedContentTypes} `)
+        }
+      } else if("acceptedFileTypes" in colConfig && colConfig.acceptedFileTypes && colConfig.acceptedFileTypes !== "*"){
+        const mime = await getFileType(buffer, fileName);
+        const allowedExtensions = ViewHandler._parseFieldFilter(colConfig.acceptedFileTypes, false, 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} `)
+        }
+      }
+    } 
+  }
+  if(!result?.mime) throw `File MIME type not found for the provided extension: ${result?.ext}`;
+  return result;
+}

package/lib/FileManager/upload.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FileManager, OnProgress, UploadedItem } from "./FileManager";
+import * as stream from 'stream';
+export declare function upload(this: FileManager, file: Buffer | string | stream.PassThrough, name: string, mime: string, onProgress?: OnProgress): Promise<UploadedItem>;
+//# sourceMappingURL=upload.d.ts.map

package/lib/FileManager/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["upload.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,WAAW,EAAe,UAAU,EAAY,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7F,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAIjC,wBAAsB,MAAM,CAC1B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,WAAW,EAC1C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,YAAY,CAAC,CAuErB"}

package/lib/FileManager/upload.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = void 0;
+const stream = __importStar(require("stream"));
+const fs = __importStar(require("fs"));
+async function upload(file, name, mime, onProgress) {
+    return new Promise(async (resolve, reject) => {
+        if (!file) {
+            throw "No file. Expecting: Buffer | String | stream";
+        }
+        if (!name) {
+            throw "No name. Expecting: String";
+        }
+        // let type = await this.getMIME(file, name, allowedExtensions);
+        const url = this.getLocalFileUrl(name);
+        if (!this.s3Client) {
+            if (file instanceof stream.PassThrough) {
+                throw new Error("S3 config missing. Can only upload streams to S3");
+            }
+            const config = this.config;
+            try {
+                await fs.promises.mkdir(config.localFolderPath, { recursive: true });
+                const filePath = `${config.localFolderPath}/${name}`;
+                fs.writeFileSync(filePath, file);
+                resolve({
+                    url,
+                    etag: `none`,
+                    content_length: fs.statSync(filePath).size
+                });
+            }
+            catch (err) {
+                console.error("Error saving file locally", err);
+                reject("Internal error");
+            }
+        }
+        else {
+            /* S3 Upload */
+            // ACL: "public-read", 
+            /* ACL needs this permission:
+                "s3:PutObject",
+                "s3:PutObjectAcl",
+                "s3:GetObject",
+                "s3:GetObjectAcl",
+              */
+            const params = {
+                Bucket: this.config.bucket,
+                Key: name,
+                ContentType: mime,
+                Body: file
+            };
+            let content_length = 0;
+            const manager = this.s3Client.upload(params, (err, res) => {
+                // const manager = this.s3Client.send(new PutObjectCommand(params), (err: Error, res) => {
+                if (err) {
+                    reject(err.toString());
+                    console.error(err);
+                }
+                else {
+                    // console.log("Uploaded file:", res)
+                    resolve({
+                        url,
+                        etag: res.ETag,
+                        s3_url: res.Location,
+                        content_length // await fileMgr.s3Client?.headObject({ Bucket: ..., Key: ... }).promise() ).ContentLength;
+                    });
+                }
+            });
+            manager.on('httpUploadProgress', prog => {
+                content_length = prog.total;
+                onProgress?.(prog);
+            });
+        }
+    });
+}
+exports.upload = upload;

package/lib/FileManager/upload.ts

@@ -0,0 +1,83 @@
+import { FileManager, LocalConfig, OnProgress, S3Config, UploadedItem } from "./FileManager";
+import * as stream from 'stream'; 
+import * as fs from 'fs';
+import { ManagedUpload } from "aws-sdk/clients/s3";
+
+export async function upload(
+  this: FileManager,
+  file: Buffer | string | stream.PassThrough, 
+  name: string,
+  mime: string,
+  onProgress?: OnProgress
+): Promise<UploadedItem> {
+
+    return new Promise(async (resolve, reject) => {
+      if(!file){
+        throw "No file. Expecting: Buffer | String | stream";
+      }
+      if(!name){
+        throw "No name. Expecting: String";
+      }
+
+      // let type = await this.getMIME(file, name, allowedExtensions);
+      const url = this.getLocalFileUrl(name)
+      if(!this.s3Client){
+        if(file instanceof stream.PassThrough){
+          throw new Error("S3 config missing. Can only upload streams to S3");
+        }
+        const config = this.config as LocalConfig;
+        try {
+          await fs.promises.mkdir(config.localFolderPath, { recursive: true });
+          const filePath = `${config.localFolderPath}/${name}`;
+          fs.writeFileSync(filePath, file);
+          resolve({
+            url,
+            etag: `none`,
+            content_length: fs.statSync(filePath).size
+          })
+        } catch(err){
+          console.error("Error saving file locally", err);
+          reject("Internal error")
+        }
+      } else {
+
+        /* S3 Upload */
+        // ACL: "public-read", 
+        /* ACL needs this permission: 
+            "s3:PutObject",
+            "s3:PutObjectAcl",
+            "s3:GetObject",
+            "s3:GetObjectAcl",
+          */
+        const params = {
+          Bucket: (this.config as S3Config).bucket, 
+          Key: name,
+          ContentType: mime,
+          Body: file
+        };
+        
+        let content_length = 0;
+        const manager = this.s3Client.upload(params, (err: Error, res: ManagedUpload.SendData) => {
+        // const manager = this.s3Client.send(new PutObjectCommand(params), (err: Error, res) => {
+          
+          if(err){
+            reject(err.toString());
+            console.error(err)
+          } else {
+            // console.log("Uploaded file:", res)
+            resolve({
+              url,
+              etag: res.ETag,
+              s3_url: res.Location,
+              content_length // await fileMgr.s3Client?.headObject({ Bucket: ..., Key: ... }).promise() ).ContentLength;
+            });
+          }
+        });
+        manager.on('httpUploadProgress', prog => { 
+          content_length = prog.total;
+          onProgress?.(prog);
+        });
+      }
+
+    });
+  }

package/lib/FileManager/uploadStream.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { FileManager, OnProgress, UploadedItem } from "./FileManager";
+import * as stream from 'stream';
+export declare function uploadStream(this: FileManager, name: string, mime: string, onProgress?: OnProgress, onError?: (error: any) => void, onEnd?: (item: UploadedItem) => void, expectedSizeBytes?: number): stream.PassThrough;
+//# sourceMappingURL=uploadStream.d.ts.map

package/lib/FileManager/uploadStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadStream.d.ts","sourceRoot":"","sources":["uploadStream.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEtE,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAGjC,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,UAAU,EACvB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAG,IAAI,EAC5B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAG,IAAI,EAClC,iBAAiB,CAAC,EAAE,MAAM,sBAmE3B"}

package/lib/FileManager/uploadStream.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadStream = void 0;
+const fs = __importStar(require("fs"));
+const stream = __importStar(require("stream"));
+const path = __importStar(require("path"));
+function uploadStream(name, mime, onProgress, onError, onEnd, expectedSizeBytes) {
+    const passThrough = new stream.PassThrough();
+    if (!this.s3Client && "localFolderPath" in this.config) {
+        // throw new Error("S3 config missing. Can only upload streams to S3");
+        try {
+            this.checkFreeSpace(this.config.localFolderPath, expectedSizeBytes).catch(err => {
+                onError?.(err);
+                passThrough.end();
+            });
+            const url = this.getLocalFileUrl(name);
+            fs.mkdirSync(this.config.localFolderPath, { recursive: true });
+            const filePath = path.resolve(`${this.config.localFolderPath}/${name}`);
+            const writeStream = fs.createWriteStream(filePath);
+            let errored = false;
+            let loaded = 0;
+            writeStream.on('error', err => {
+                errored = true;
+                onError?.(err);
+            });
+            let lastProgress = Date.now();
+            const throttle = 1000;
+            if (onProgress) {
+                passThrough.on('data', function (chunk) {
+                    loaded += chunk.length;
+                    const now = Date.now();
+                    if (now - lastProgress > throttle) {
+                        lastProgress = now;
+                        onProgress?.({ loaded, total: 0 });
+                    }
+                });
+            }
+            if (onEnd) {
+                writeStream.on('finish', () => {
+                    if (errored)
+                        return;
+                    let content_length = 0;
+                    try {
+                        content_length = fs.statSync(filePath).size;
+                        onEnd?.({
+                            url,
+                            filePath,
+                            etag: `none`,
+                            content_length
+                        });
+                    }
+                    catch (err) {
+                        onError?.(err);
+                    }
+                });
+            }
+            passThrough.pipe(writeStream);
+        }
+        catch (err) {
+            onError?.(err);
+        }
+    }
+    else {
+        this.upload(passThrough, name, mime, onProgress).then(onEnd)
+            .catch(onError);
+    }
+    return passThrough;
+}
+exports.uploadStream = uploadStream;