prostgles-server 4.0.16 → 4.0.18

package/lib/FileManager.ts

@@ -1,811 +0,0 @@
-
-import { S3, IAM } from 'aws-sdk';
-import { ManagedUpload } from 'aws-sdk/clients/s3';
-// import { PutObjectCommand, S3 } from "@aws-sdk/client-s3";
-import * as fs from 'fs';
-import * as stream from 'stream';
-
-import * as sharp from "sharp";
-import checkDiskSpace from 'check-disk-space';
-
-import { DB, DBHandlerServer, ExpressApp, Prostgles } from './Prostgles';
-import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, asName, CONTENT_TYPE_TO_EXT, getKeys, isDefined, isObject, ValidatedColumnInfo } from 'prostgles-types';
-
-
-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
-}
-
-type OnProgress = (progress: S3.ManagedUpload.Progress) => 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 S3Config = {
-  region: string;
-  bucket: string;
-  accessKeyId: string;
-  secretAccessKey: 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;
-
-  /**
-   * S3 url of the resource
-   */
-  s3_url?: string;
-
-  /**
-   * Total uploaded file size in bytes
-   */
-  content_length: number;
-};
-import AWS from 'aws-sdk';
-import { canCreateTables } from "./DboBuilder/runSQL";
-import * as path from "path";
-import { TableHandler } from "./DboBuilder/TableHandler";
-import { ViewHandler } from "./DboBuilder/ViewHandler";
-export default class FileManager {
-
-  static testCredentials = async (accessKeyId: string, secretAccessKey: string) => {
-    const sts = new AWS.STS();
-    AWS.config.credentials = {
-      accessKeyId,
-      secretAccessKey
-    }
-
-    const ident = await sts.getCallerIdentity({}).promise();
-    return ident;
-  }
-  
-  s3Client?: S3;
-
-  config: S3Config | LocalConfig;
-  imageOptions?: ImageOptions;
-
-  prostgles?: Prostgles;
-  get dbo(): DBHandlerServer { 
-    if(!this.prostgles?.dbo) {
-      // this.prostgles?.refreshDBO();
-      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;
-
-  private 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("region" in config){
-      const { region, accessKeyId, secretAccessKey } = config;
-      this.s3Client = new S3({ 
-        region, 
-        credentials: { accessKeyId, secretAccessKey },
-      });
-    }
-
-    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("bucket" in this.config && this.s3Client){
-      return this.s3Client.getObject({ Key: name, Bucket: this.config.bucket }).createReadStream()
-    } 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("bucket" in this.config && this.s3Client){
-      const res = await this.s3Client?.deleteObject({ Bucket: this.config.bucket, Key: name }).promise();
-      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
-  }
-
-  async parseFile(args: {
-    file: Buffer | string;
-    fileName: string;
-    colName?: string;
-    tableName?: string;
-  }): 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;
-  }
-
-  getFileUrl = (name: string) => this.fileRoute? `${this.fileRoute}/${name}` : "";
-
-  checkFreeSpace = async (folderPath: string, fileSize = 0) => {
-    if(!this.s3Client && "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 = (
-    name: string,
-    mime: string,
-    onProgress?: OnProgress,
-    onError?: (error: any)=>void,
-    onEnd?: (item: UploadedItem)=>void,
-    expectedSizeBytes?: number
-  ) => {
-    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.getFileUrl(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;
-  }
-
-  private async upload(
-    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.getFileUrl(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);
-        });
-      }
-
-    });
-  }
-
-  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);
-
-    let _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 getFileS3URL(fileName: string, expiresInSeconds: number = 30 * 60){
-    const params = {
-      Bucket: (this.config as S3Config).bucket, 
-      Key: fileName,
-      Expires: Math.round(expiresInSeconds || 30 * 60) // Error if float
-    };
-    return await this.s3Client?.getSignedUrlPromise("getObject", params);
-  }
-
-  private 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 ));
-    if(isReferencingFileTable){
-      if(tableConfig && typeof tableConfig !== "string"){
-        return tableConfig.referenceColumns[colName];
-      }
-      return { acceptedContent: "*" };
-    }
-    return undefined;
-  }
-
-  init = async (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)
-    }
-    /**
-     * 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 
-     */
-    await Promise.all(getKeys(referencedTables).map(async refTable => {
-
-      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 await (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();
-      return true;
-    }));
-
-    /**
-     * 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" });
-        }
-      });
-    }
-  }
-
-  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 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];
-}
-
-
-/**
- *
- 
-
-    // if(content_type && typeof content_type !== "string") throw "Invalid content_type provided";
-    // if(title && typeof title !== "string") throw "Invalid title provided";
-    // let fExt = name.split(".").pop()
-    // if(content_type && name.split(".").length > 1 && fExt && fExt.length <= 4){
-    //   type = {
-    //     mime: content_type,
-    //     ext: fExt,
-    //     fileName: name,
-    //   }
-    // } else {
-    //   type = await this.getMIME(data, name);//, ["png", "jpg", "ogg", "webm", "pdf", "doc"]);
-    // }
-
-
-
- */