prostgles-server 4.0.16 → 4.0.18

package/lib/FileManager/FileManager.ts

@@ -0,0 +1,378 @@
+
+import { S3, IAM } from 'aws-sdk'; 
+// 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, CONTENT_TYPE_TO_EXT, getKeys, isDefined, ValidatedColumnInfo } from 'prostgles-types';
+
+import AWS from 'aws-sdk'; 
+import * as path from "path";
+import { initFileManager } from "./initFileManager";
+import { parseFile } from "./parseFile";
+import { upload } from "./upload";
+import { uploadStream } from "./uploadStream";
+
+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: 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;
+};
+
+export 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;
+
+  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
+  }
+
+  parseFile = parseFile.bind(this);
+
+  getLocalFileUrl = (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 = 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);
+
+    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);
+  }
+
+  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 = 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 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"]);
+    // }
+
+
+
+ */

package/lib/FileManager/initFileManager.d.ts

@@ -0,0 +1,4 @@
+import { Prostgles } from "../Prostgles";
+import { FileManager } from "./FileManager";
+export declare function initFileManager(this: FileManager, prg: Prostgles): Promise<void>;
+//# sourceMappingURL=initFileManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initFileManager.d.ts","sourceRoot":"","sources":["initFileManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,WAAW,EAAqB,MAAM,eAAe,CAAC;AAI/D,wBAAsB,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,SAAS,iBAmOtE"}

package/lib/FileManager/initFileManager.js

@@ -0,0 +1,231 @@
+"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.initFileManager = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const runSQL_1 = require("../DboBuilder/runSQL");
+const FileManager_1 = require("./FileManager");
+const fs = __importStar(require("fs"));
+async function initFileManager(prg) {
+    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 (0, runSQL_1.canCreateTables)(this.db);
+    const runQuery = (q) => {
+        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 ${(0, prostgles_types_1.asName)(tableName)} ...`);
+        await runQuery(`CREATE EXTENSION IF NOT EXISTS pgcrypto `);
+        await runQuery(`CREATE TABLE IF NOT EXISTS ${(0, prostgles_types_1.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 ${(0, prostgles_types_1.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].getColumns();
+        const tableConfig = referencedTables[refTable];
+        if (typeof tableConfig !== "string") {
+            for (const colName of (0, prostgles_types_1.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 ${(0, prostgles_types_1.asName)(refTable)} ADD FOREIGN KEY (${(0, prostgles_types_1.asName)(colName)}) REFERENCES ${(0, prostgles_types_1.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 ${(0, prostgles_types_1.asName)(refTable)} ADD COLUMN ${(0, prostgles_types_1.asName)(colName)} UUID REFERENCES ${(0, prostgles_types_1.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 ${(0, prostgles_types_1.asName)(refTable)}(${(0, prostgles_types_1.asName)(pkField.name)}),
+          media_id    UUID NOT NULL REFERENCES ${(0, prostgles_types_1.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 ${(0, prostgles_types_1.asName)(lookupTableName)} ADD FOREIGN KEY (${badCol.name}) `;
+                    console.log("Trying to add the missing constraint back");
+                    if (badCol.name === "foreign_id") {
+                        q += `REFERENCES ${(0, prostgles_types_1.asName)(refTable)}(${(0, prostgles_types_1.asName)(pkField.name)}) `;
+                    }
+                    else if (badCol.name === "media_id") {
+                        q += `REFERENCES ${(0, prostgles_types_1.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];
+            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 });
+                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() + FileManager_1.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.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" });
+            }
+        });
+    }
+}
+exports.initFileManager = initFileManager;