prostgles-server 4.2.159 → 4.2.161

package/lib/FileManager/FileManager.ts

@@ -0,0 +1,358 @@
+
+import * as fs from 'fs';
+import * as stream from 'stream';
+
+// import * as sharp from "sharp";
+import checkDiskSpace from 'check-disk-space';
+
+import { DB, DBHandlerServer, Prostgles } from '../Prostgles';
+import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, CONTENT_TYPE_TO_EXT, getKeys, isDefined, ValidatedColumnInfo } from 'prostgles-types';
+
+import * as path from "path";
+import { initFileManager } from "./initFileManager";
+import { getValidatedFileType } from "./getValidatedFileType";
+import { upload } from "./upload";
+import { uploadStream } from "./uploadStream";
+import { ExpressApp } from "../RestApi";
+
+export const HOUR = 3600 * 1000;
+
+export const asSQLIdentifier = async (name: string, db: DB): Promise<string> => {
+  return (await db.one("select format('%I', $1) as name", [name]))?.name
+}
+
+export type OnProgress = (progress: { total: number; loaded: number; }) => void
+
+export type ImageOptions = {
+  keepMetadata?: boolean;
+  compression?:
+    /**
+     * Will resize image maintaing scale ratio
+     */
+    | { inside: { width: number; height: number } }
+    | { contain: 
+        | { width: number }
+        | { height: number }
+      }
+}
+
+export type UploadedCloudFile = { 
+  cloud_url: string; 
+  etag: string; 
+  content_length: number; 
+};
+export type FileUploadArgs = {
+  fileName: string;
+  contentType: string;
+  file: string | Buffer | stream.PassThrough; 
+  onFinish: (...args: [error: Error, result: undefined] | [error: undefined, result: UploadedCloudFile]) => void;
+  onProgress?: (bytesUploaded: number) => void;
+}
+export type CloudClient = {
+  upload: (file: FileUploadArgs) => Promise<void>;
+  downloadAsStream: (name: string) => Promise<stream.Readable>;
+  delete: (fileName: string) => Promise<void>;
+  getSignedUrlForDownload: (fileName: string, expiresInSeconds: number) => Promise<string>;
+}
+
+export type LocalConfig = {
+  /**
+   * example: path.join(__dirname+'/media')
+   * note that this location will be relative to the compiled file location
+   */
+  localFolderPath: string;
+
+  /**
+   * Minimum amount of free bytes available to allow saving files
+   * Defaults to 100MB
+   */
+  minFreeBytes?: number;
+}
+
+export type UploadItem = {
+  name: string;
+  content_type: string;
+  data: Buffer;
+  extension: string;
+};
+export type UploadedItem = {
+  /**
+   * Url that is passed to client
+   */
+  url: string;
+  filePath?: string;
+  etag: string;
+
+  /**
+   * Cloud url of the resource
+   */
+  cloud_url?: string;
+
+  /**
+   * Total uploaded file size in bytes
+   */
+  content_length: number;
+};
+
+export class FileManager {
+
+  cloudClient?: CloudClient;
+
+  config: CloudClient | LocalConfig;
+  imageOptions?: ImageOptions;
+
+  prostgles?: Prostgles;
+  get dbo(): DBHandlerServer { 
+    if(!this.prostgles?.dbo) {
+      throw "this.prostgles.dbo missing";
+    }
+    return this.prostgles.dbo 
+  }
+  
+  get db(): DB { 
+    if(!this.prostgles?.db) throw "this.prostgles.db missing"
+    return this.prostgles.db 
+  }
+  
+  tableName?: string;
+
+  fileRoute?: string;
+  get fileRouteExpress (){
+    return this.fileRoute + "/:name";
+  }
+  private checkInterval?: NodeJS.Timeout;
+
+  constructor(config: FileManager["config"], imageOptions?: ImageOptions){
+    this.config = config;
+    this.imageOptions = imageOptions;
+
+    if("upload" in config){
+      this.cloudClient = config;
+    }
+
+    const fullConfig = this.prostgles?.opts.fileTable;
+    if(fullConfig?.delayedDelete){
+      this.checkInterval = setInterval(async () => {
+        const fileTable = fullConfig.tableName;
+        const daysDelay = fullConfig.delayedDelete?.deleteAfterNDays ?? 0;
+        if(fileTable && this.dbo[fileTable]?.delete && daysDelay){
+          const filesToDelete = await this.dbo[fileTable]?.find?.({ deleted_from_storage: null, deleted: { ">": Date.now() - (daysDelay * HOUR * 24) } }) ?? [];
+          for await(const file of filesToDelete){
+            await this.deleteFile(file.name)
+          }
+        } else {
+          console.error("FileManager checkInterval delayedDelete FAIL: Could not access file table tableHandler.delete()")
+        }
+      }, Math.max(10000, (fullConfig.delayedDelete.checkIntervalHours || 0) * HOUR))
+    }
+  }
+
+  async getFileStream(name: string): Promise<stream.Readable> {
+    if(this.cloudClient){
+      return this.cloudClient.downloadAsStream(name)
+    } else if("localFolderPath" in this.config){
+      const filePath = path.resolve(`${this.config.localFolderPath}/${name}`);
+      if(!fs.existsSync(filePath)){
+        throw `File ${filePath} could not be found`;
+      }
+      return fs.createReadStream(filePath, { encoding: undefined })
+    } else throw new Error("Not expected");
+  }
+
+  async deleteFile(name: string) {
+    if(this.cloudClient){
+      const res = await this.cloudClient?.delete(name);
+      return res;
+    } else if("localFolderPath" in this.config){
+      const path = `${this.config.localFolderPath}/${name}`;
+      if(!fs.existsSync(path)){
+        throw `File ${path} could not be found`;
+      }
+      fs.unlinkSync(path);
+      if(fs.existsSync(path)) throw new Error("Could not delete file");
+    }
+    return true
+  }
+
+  getValidatedFileType = getValidatedFileType.bind(this);
+
+  getLocalFileUrl = (name: string) => this.fileRoute? `${this.fileRoute}/${name}` : "";
+
+  checkFreeSpace = async (folderPath: string, fileSize = 0) => {
+    if(!this.cloudClient && "localFolderPath" in this.config) {
+      const { minFreeBytes = 1.048e6 } = this.config;
+      const required = Math.max(fileSize, minFreeBytes)
+      if(required){
+        const diskSpace = await checkDiskSpace(folderPath);
+        if(diskSpace.free < required){
+          const err =  `There is not enough space on the server to save files.\nTotal: ${bytesToSize(diskSpace.size)} \nRemaning: ${bytesToSize(diskSpace.free)} \nRequired: ${bytesToSize(required)}`
+          throw new Error(err);
+        }
+      }
+    }
+  }
+  
+  uploadStream = uploadStream.bind(this);
+
+  upload = upload.bind(this);
+
+  uploadAsMedia = async (params: {
+    item: UploadItem;
+    allowedExtensions?: Array<ALLOWED_EXTENSION>;
+    dissallowedExtensions?: Array<ALLOWED_EXTENSION>;
+    imageOptions?: ImageOptions;
+  }): Promise<UploadedItem> => {
+    const { item, imageOptions } = params;
+    const { name, data, content_type, extension } = item;
+    if(!data) throw "No file provided";
+    if(!name || typeof name !== "string") throw "Expecting a string name";
+    
+    // const type = await this.getMIME(data, name, allowedExtensions, dissallowedExtensions);
+
+    const _data = data;
+    
+    /** Resize/compress/remove exif from photos */
+    // if(content_type.startsWith("image") && extension.toLowerCase() !== "gif"){
+
+    //   const compression = imageOptions?.compression
+    //   if(compression){
+    //     console.log("Resizing image")
+    //     let opts;
+    //     if("contain" in compression){
+    //       opts = {
+    //         fit: sharp.fit.contain,
+    //         ...compression.contain
+    //       }
+    //     } else if("inside" in compression){
+    //       opts = {
+    //         fit: sharp.fit.inside,
+    //         ...compression.inside
+    //       }
+    //     }
+    //     _data = await sharp(data)
+    //       .resize(opts as any)
+    //       .withMetadata(Boolean(imageOptions?.keepMetadata) as any)
+    //       // .jpeg({ quality: 80 })
+    //       .toBuffer()
+    //   } else if(!imageOptions?.keepMetadata) {
+    //     /**
+    //      * Remove exif
+    //      */
+    //     // const metadata = await simg.metadata();
+    //     // const simg = await sharp(data);
+
+    //     _data = await sharp(data).clone().withMetadata({
+    //         exif: {}
+    //       })
+    //       .toBuffer()
+    //   }
+    // }
+
+    const res = await this.upload(_data, name, content_type);
+
+    return res
+  }
+
+  async getFileCloudDownloadURL(fileName: string, expiresInSecondsRaw: number = 30 * 60){
+    const expiresInSeconds = Math.max(1, Math.round(expiresInSecondsRaw));
+    return await this.cloudClient?.getSignedUrlForDownload(fileName, expiresInSeconds);
+  }
+
+  parseSQLIdentifier = async (name: string ) => asSQLIdentifier(name, this.prostgles!.db!);//  this.prostgles.dbo.sql<"value">("select format('%I', $1)", [name], { returnType: "value" } )
+
+  getColInfo = (args: { tableName: string; colName: string }): ValidatedColumnInfo["file"] | undefined => {
+    const { colName, tableName } = args;
+    const tableConfig = this.prostgles?.opts.fileTable?.referencedTables?.[tableName];
+    const isReferencingFileTable = this.dbo[tableName]?.columns?.some(c => c.name === colName && c.references && c.references?.some(({ ftable }) => ftable === this.tableName ));
+    const allowAllFiles = { acceptedContent: "*" } as const;
+    if(isReferencingFileTable){
+      if(tableConfig && typeof tableConfig !== "string"){
+        return tableConfig.referenceColumns[colName] ?? allowAllFiles;
+      }
+      return allowAllFiles;
+    }
+    return undefined;
+  }
+
+  init = initFileManager.bind(this);
+
+  destroy = () => {
+    removeExpressRoute(this.prostgles?.opts.fileTable?.expressApp, [this.fileRouteExpress]);
+  }
+}
+
+export const removeExpressRoute = (app: ExpressApp | undefined, routePaths: (string | undefined)[]) => {
+
+  const routes = app?._router?.stack;
+  if(routes){
+    routes.forEach((route, i) => {
+      if(routePaths.filter(isDefined).includes(route.route?.path as any)){
+        routes.splice(i, 1);
+      }
+    })
+  }
+}
+
+export const removeExpressRouteByName = (app: ExpressApp | undefined, name: string) => {
+  const routes = app?._router?.stack;
+  if(routes){
+    routes.forEach((route, i) => {
+      if(route.name === name){
+        routes.splice(i, 1);
+      }
+    })
+  }
+}
+
+export const getFileTypeFromFilename = (fileName: string): { mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION | string } | undefined => {
+
+  const nameParts = fileName.split(".");
+
+  if(nameParts.length < 2) return undefined;
+
+  const nameExt = nameParts.at(-1)!.toLowerCase(),
+    mime = getKeys(CONTENT_TYPE_TO_EXT).find(k => (CONTENT_TYPE_TO_EXT[k] as readonly string[]).includes(nameExt));
+
+  if(!mime) return undefined;
+
+  return {
+    mime,
+    ext: nameExt as ALLOWED_EXTENSION,
+  }
+}
+
+// const fileType = require("file-type");
+// const res = await fileType.fromBuffer(typeof file === "string"? Buffer.from(file, 'utf8') : file);
+
+export const getFileType = async (file: Buffer | string, fileName: string): Promise<{ mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION }> => {
+
+  const { fileTypeFromBuffer } = await (eval('import("file-type")') as Promise<typeof import('file-type')>);
+  
+  const fileNameMime = getFileTypeFromFilename(fileName);
+  if(!fileNameMime?.ext) throw new Error("File name must contain extenion")
+  const res = await fileTypeFromBuffer(typeof file === "string"? Buffer.from(file, 'utf8') : file);
+  
+  if(!res) {
+
+    /* Set correct/missing extension */
+    const nameExt = fileNameMime?.ext;
+    if(["xml", "txt", "csv", "tsv", "svg", "sql"].includes(nameExt) && fileNameMime.mime){
+      return fileNameMime as any;
+    }
+    
+    throw new Error("Could not get the file type from file buffer");
+  } else {
+
+    if(!res.ext || fileNameMime?.ext.toLowerCase() !== res.ext.toLowerCase()){
+      throw new Error(`There is a mismatch between file name extension and actual buffer extension: ${fileNameMime?.ext } vs ${res.ext}`)
+    }
+  }
+  return res as any;
+}
+
+export function bytesToSize(bytes: number) {
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  if (bytes == 0) return '0 Byte';
+  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)) + "");
+  return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + sizes[i];
+}

package/lib/FileManager/getValidatedFileType.ts

@@ -0,0 +1,69 @@
+import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, CONTENT_TYPE_TO_EXT, getKeys, isObject } from "prostgles-types";
+import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
+import { FileManager, getFileType, getFileTypeFromFilename } from "./FileManager";
+
+type Args = {
+  file: Buffer | string;
+  fileName: string;
+  colName?: string;
+  tableName?: string;
+};
+export async function getValidatedFileType(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 = 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 = 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 = 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/initFileManager.ts

@@ -0,0 +1,187 @@
+import * as fs from 'fs';
+import { asName, tryCatch } from "prostgles-types";
+import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+import { canCreateTables } from "../DboBuilder/runSQL";
+import { Prostgles } from "../Prostgles";
+import { FileManager, HOUR, LocalConfig } from "./FileManager";
+import { runClientRequest } from "../runClientRequest";
+import { HTTPCODES } from "../Auth/AuthHandler";
+
+export async function initFileManager(this: FileManager, prg: Prostgles){
+  this.prostgles = prg;
+
+  const { fileTable } = prg.opts;
+  if(!fileTable) {
+    throw "fileTable missing";
+  }
+  const { tableName = "files", 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`);
+
+  const canCreate = await canCreateTables(this.db);
+  const runQuery = async (q: string, debugInfo: string): Promise<void> => {
+    const res = await tryCatch(async () => {
+      if(!canCreate) throw "File table creation failed. Your postgres user does not have CREATE table privileges";
+      await this.db.any(q);
+    });
+    await this.prostgles?.opts.onLog?.({ type: "debug", command: "initFileManager.runQuery", ...res, data: { debugInfo } });
+    if(res.error) {
+      throw res.error;
+    }
+  }
+  /**
+   * 1. Create media table
+   */
+  if(!this.dbo[tableName]){
+    await runQuery(`
+      CREATE EXTENSION IF NOT EXISTS pgcrypto;
+      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,
+        cloud_url             TEXT,
+        signed_url            TEXT,
+        signed_url_expires    BIGINT,
+        etag                  TEXT,
+        deleted               BIGINT,
+        deleted_from_storage  BIGINT,
+        UNIQUE(id),
+        UNIQUE(name)
+    )`, `Create 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]!;
+
+    for (const [colName] of Object.entries(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) ;`;
+              const msg = `Referenced file column ${refTable} (${colName}) exists but is not referencing file table. Add REFERENCE constraint...\n${query}`;
+              await runQuery(query, msg);
+            } 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 {
+        const query = `ALTER TABLE ${asName(refTable)} ADD COLUMN ${asName(colName)} UUID REFERENCES ${asName(tableName)} (id);`
+        // const createColumn = async () => {
+        //   try {
+        //     const msg = `Create referenced file column ${refTable} (${colName})...\n${query}`;
+        //     await runQuery(query, msg);
+        //   } catch(e){
+        //     console.error(`FAILED. Err: ${e instanceof Error? e.message : JSON.stringify(e)}`)
+        //   }
+        // }
+        // await createColumn();
+        console.error(`Referenced file column ${refTable} (${colName}) does not exist. Create it using this query:\n${query}`);
+      }
+      
+    } 
+
+
+    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(HTTPCODES.INTERNAL_SERVER_ERROR).json(`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";
+        }
+        if(!this.prostgles) {
+          throw "Prostgles instance missing";
+        }
+        const id = name.slice(0, 36);
+        const selectParams = { select: { id: 1, name: 1, signed_url: 1, signed_url_expires: 1, content_type: 1 } }
+        const media = await runClientRequest.bind(this.prostgles)({ 
+          type: "http", 
+          httpReq: req, 
+          command: "findOne", 
+          tableName, 
+          param1: { id }, 
+          param2: selectParams, 
+          param3: undefined 
+        });
+        
+        if(!media) {
+          res.status(HTTPCODES.NOT_FOUND).send("File not found or not allowed");
+          return;
+        }
+        
+        if(this.cloudClient){
+          let url = media.signed_url;
+          const expires = +(media.signed_url_expires || 0);
+          
+          const EXPIRES = Date.now() + HOUR;
+          if(!url || expires < EXPIRES){
+            url = await this.getFileCloudDownloadURL(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(HTTPCODES.BAD_REQUEST).send("Invalid/disallowed file");
+      }
+    });
+  }
+}

package/lib/FileManager/upload.ts

@@ -0,0 +1,62 @@
+import { FileManager, LocalConfig, OnProgress, UploadedItem } from "./FileManager";
+import * as stream from 'stream'; 
+import * as fs from 'fs';
+
+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.PassThrough";
+    }
+    if(!name){
+      throw "No file name. Expecting: String";
+    }
+
+    const url = this.getLocalFileUrl(name);
+    if(!this.cloudClient){
+      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 {
+
+      let content_length = 0;
+      this.cloudClient.upload({
+        fileName: name,
+        contentType: mime,
+        file,
+        onFinish: (err, uploaded) => {
+          if(err){
+            reject(err.toString());
+          } else {
+            resolve({ ...uploaded, url });
+          }
+        },
+        onProgress: loaded => {
+          content_length = loaded;
+          onProgress?.({ loaded, total: content_length });
+        }
+      });
+    }
+
+  });
+}