prostgles-server 4.2.157 → 4.2.159

package/lib/FileManager/FileManager.ts

@@ -1,358 +0,0 @@
-
-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

@@ -1,69 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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 });
-        }
-      });
-    }
-
-  });
-}