prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/uploadFile.ts

@@ -4,61 +4,97 @@ import { ValidateRowBasic } from "../PublishParser/PublishParser";
 import { TableHandler } from "./TableHandler/TableHandler";
 
 export const isFile = (row: AnyObject) => {
-  return Boolean(row && isObject(row) && getKeys(row).sort().join() === ["name", "data"].sort().join() && row.data && (typeof row.data === "string" || Buffer.isBuffer(row.data)) && typeof row.name === "string")
-}
+  return Boolean(
+    row &&
+      isObject(row) &&
+      getKeys(row).sort().join() === ["name", "data"].sort().join() &&
+      row.data &&
+      (typeof row.data === "string" || Buffer.isBuffer(row.data)) &&
+      typeof row.name === "string",
+  );
+};
 
 type UploadFileArgs = {
   row: AnyObject;
-  validate: ValidateRowBasic | undefined; 
+  validate: ValidateRowBasic | undefined;
   localParams: LocalParams | undefined;
   /**
    * Used to update an existing file
    */
   mediaId?: string;
-}
+};
 
-export async function uploadFile(this: TableHandler, { row, localParams, validate, mediaId }: UploadFileArgs): Promise<Media> {
+export async function uploadFile(
+  this: TableHandler,
+  { row, localParams, validate, mediaId }: UploadFileArgs,
+): Promise<Media> {
   if (!this.dboBuilder.prostgles?.fileManager) throw "fileManager not set up";
 
-  if (!isFile(row)) throw "Expecting only two properties for file upload: { name: string; data: File | string | Buffer }; but got: " + Object.entries(row).map(([k, v]) => `${k}: ${typeof v}`).join(", ");
+  if (!isFile(row))
+    throw (
+      "Expecting only two properties for file upload: { name: string; data: File | string | Buffer }; but got: " +
+      Object.entries(row)
+        .map(([k, v]) => `${k}: ${typeof v}`)
+        .join(", ")
+    );
   const { data, name } = row;
 
-  const media_id = mediaId ?? (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
+  const media_id =
+    mediaId ??
+    (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
   const nestedInsert = localParams?.nestedInsert;
-  const type = await this.dboBuilder.prostgles.fileManager.getValidatedFileType({  file: data, fileName: name, tableName: nestedInsert?.previousTable, colName: nestedInsert?.referencingColumn });
+  const type = await this.dboBuilder.prostgles.fileManager.getValidatedFileType(
+    {
+      file: data,
+      fileName: name,
+      tableName: nestedInsert?.previousTable,
+      colName: nestedInsert?.referencingColumn,
+    },
+  );
   const media_name = `${media_id}.${type.ext}`;
-  const parsedMediaKeys = ["id", "name", "original_name", "extension", "content_type"] as const
-  const media: Required<Pick<Media, typeof parsedMediaKeys[number]>> = {
+  const parsedMediaKeys = [
+    "id",
+    "name",
+    "original_name",
+    "extension",
+    "content_type",
+  ] as const;
+  const media: Required<Pick<Media, (typeof parsedMediaKeys)[number]>> = {
     id: media_id,
     name: media_name,
     original_name: name,
     extension: type.ext,
-    content_type: type.mime
-  }
+    content_type: type.mime,
+  };
 
   if (validate) {
-    if(!localParams) throw "localParams missing";
-    const parsedMedia = await validate({ row: media, dbx: this.getFinalDbo(localParams), localParams });
-    const missingKeys = parsedMediaKeys.filter(k => !parsedMedia[k])
-    if(missingKeys.length){
+    if (!localParams) throw "localParams missing";
+    const parsedMedia = await validate({
+      row: media,
+      dbx: this.getFinalDbo(localParams),
+      localParams,
+    });
+    const missingKeys = parsedMediaKeys.filter((k) => !parsedMedia[k]);
+    if (missingKeys.length) {
       throw `Some keys are missing from file insert validation: ${missingKeys}`;
     }
   }
 
-  const _media: Media = await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
-    item: {
-      data,
-      name: media.name ?? "????",
-      content_type: media.content_type as any,
-      extension: media.extension
-    },
-    // imageCompression: {
-    //     inside: {
-    //         width: 1100,
-    //         height: 630
-    //     }
-    // }
-  });
+  const _media: Media =
+    await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
+      item: {
+        data,
+        name: media.name ?? "????",
+        content_type: media.content_type as any,
+        extension: media.extension,
+      },
+      // imageCompression: {
+      //     inside: {
+      //         width: 1100,
+      //         height: 630
+      //     }
+      // }
+    });
 
   const mediaRow = {
     ...media,
@@ -66,4 +102,4 @@ export async function uploadFile(this: TableHandler, { row, localParams, validat
   };
 
   return mediaRow;
-}
+}

package/lib/Event_Trigger_Tags.ts

@@ -1,4 +1,3 @@
-
 export const EVENT_TRIGGER_TAGS = [
   "ALTER AGGREGATE",
   "ALTER COLLATION",
@@ -110,9 +109,12 @@ export const EVENT_TRIGGER_TAGS = [
   "REFRESH MATERIALIZED VIEW",
   "REVOKE",
   "SECURITY LABEL",
-  "SELECT INTO"
+  "SELECT INTO",
 ] as const;
 
-export type EventTriggerTag = typeof EVENT_TRIGGER_TAGS[number];
+export type EventTriggerTag = (typeof EVENT_TRIGGER_TAGS)[number];
 
-export type EventTriggerTagFilter = Partial<Record<EventTriggerTag, 1>> | Partial<Record<EventTriggerTag, 0>> | "*";
+export type EventTriggerTagFilter =
+  | Partial<Record<EventTriggerTag, 1>>
+  | Partial<Record<EventTriggerTag, 0>>
+  | "*";

package/lib/FileManager/FileManager.ts

@@ -23,7 +23,10 @@ import { ExpressApp } from "../RestApi";
 
 export const HOUR = 3600 * 1000;
 
-export const asSQLIdentifier = async (name: string, db: DB): Promise<string> => {
+export const asSQLIdentifier = async (
+  name: string,
+  db: DB,
+): Promise<string> => {
   return (await db.one("select format('%I', $1) as name", [name]))?.name;
 };
 
@@ -51,7 +54,9 @@ export type FileUploadArgs = {
   contentType: string;
   file: string | Buffer | stream.PassThrough;
   onFinish: (
-    ...args: [error: Error, result: undefined] | [error: undefined, result: UploadedCloudFile]
+    ...args:
+      | [error: Error, result: undefined]
+      | [error: undefined, result: UploadedCloudFile]
   ) => void;
   onProgress?: (bytesUploaded: number) => void;
 };
@@ -59,7 +64,10 @@ 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>;
+  getSignedUrlForDownload: (
+    fileName: string,
+    expiresInSeconds: number,
+  ) => Promise<string>;
 };
 
 export type LocalConfig = {
@@ -153,11 +161,14 @@ export class FileManager {
             }
           } else {
             console.error(
-              "FileManager checkInterval delayedDelete FAIL: Could not access file table tableHandler.delete()"
+              "FileManager checkInterval delayedDelete FAIL: Could not access file table tableHandler.delete()",
             );
           }
         },
-        Math.max(10000, (fullConfig.delayedDelete.checkIntervalHours || 0) * HOUR)
+        Math.max(
+          10000,
+          (fullConfig.delayedDelete.checkIntervalHours || 0) * HOUR,
+        ),
       );
     }
   }
@@ -191,7 +202,8 @@ export class FileManager {
 
   getValidatedFileType = getValidatedFileType.bind(this);
 
-  getLocalFileUrl = (name: string) => (this.fileRoute ? `${this.fileRoute}/${name}` : "");
+  getLocalFileUrl = (name: string) =>
+    this.fileRoute ? `${this.fileRoute}/${name}` : "";
 
   checkFreeSpace = async (folderPath: string, fileSize = 0) => {
     if (!this.cloudClient && "localFolderPath" in this.config) {
@@ -268,24 +280,32 @@ export class FileManager {
     return res;
   };
 
-  async getFileCloudDownloadURL(fileName: string, expiresInSecondsRaw: number = 30 * 60) {
+  async getFileCloudDownloadURL(
+    fileName: string,
+    expiresInSecondsRaw: number = 30 * 60,
+  ) {
     const expiresInSeconds = Math.max(1, Math.round(expiresInSecondsRaw));
-    return await this.cloudClient?.getSignedUrlForDownload(fileName, expiresInSeconds);
+    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" } )
+  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 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)
+        c.references?.some(({ ftable }) => ftable === this.tableName),
     );
     const allowAllFiles = { acceptedContent: "*" } as const;
     if (isReferencingFileTable) {
@@ -300,13 +320,15 @@ export class FileManager {
   init = initFileManager.bind(this);
 
   destroy = () => {
-    removeExpressRoute(this.prostgles?.opts.fileTable?.expressApp, [this.fileRouteExpress]);
+    removeExpressRoute(this.prostgles?.opts.fileTable?.expressApp, [
+      this.fileRouteExpress,
+    ]);
   };
 }
 
 export const removeExpressRoute = (
   app: ExpressApp | undefined,
-  routePaths: (string | undefined)[]
+  routePaths: (string | undefined)[],
 ) => {
   const routes = app?._router?.stack;
   if (routes) {
@@ -318,7 +340,10 @@ export const removeExpressRoute = (
   }
 };
 
-export const removeExpressRouteByName = (app: ExpressApp | undefined, name: string) => {
+export const removeExpressRouteByName = (
+  app: ExpressApp | undefined,
+  name: string,
+) => {
   const routes = app?._router?.stack;
   if (routes) {
     routes.forEach((route, i) => {
@@ -330,15 +355,17 @@ export const removeExpressRouteByName = (app: ExpressApp | undefined, name: stri
 };
 
 export const getFileTypeFromFilename = (
-  fileName: string
-): { mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION | string } | undefined => {
+  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)
+      (CONTENT_TYPE_TO_EXT[k] as readonly string[]).includes(nameExt),
     );
 
   if (!mime) return undefined;
@@ -354,7 +381,7 @@ export const getFileTypeFromFilename = (
 
 export const getFileType = async (
   file: Buffer | string,
-  fileName: string
+  fileName: string,
 ): Promise<{ mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION }> => {
   const { fileTypeFromBuffer } = await (eval('import("file-type")') as Promise<
     typeof import("file-type")
@@ -362,12 +389,17 @@ export const getFileType = async (
 
   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);
+  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) {
+    if (
+      ["xml", "txt", "csv", "tsv", "svg", "sql"].includes(nameExt) &&
+      fileNameMime.mime
+    ) {
       return fileNameMime as any;
     }
 
@@ -375,7 +407,7 @@ export const getFileType = async (
   } 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}`
+        `There is a mismatch between file name extension and actual buffer extension: ${fileNameMime?.ext} vs ${res.ext}`,
       );
     }
   }

package/lib/FileManager/getValidatedFileType.ts

@@ -1,6 +1,16 @@
-import { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, CONTENT_TYPE_TO_EXT, getKeys, isObject } from "prostgles-types";
+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";
+import {
+  FileManager,
+  getFileType,
+  getFileTypeFromFilename,
+} from "./FileManager";
 
 type Args = {
   file: Buffer | string;
@@ -8,7 +18,10 @@ type Args = {
   colName?: string;
   tableName?: string;
 };
-export async function getValidatedFileType(this: FileManager, args: Args): Promise<{
+export async function getValidatedFileType(
+  this: FileManager,
+  args: Args,
+): Promise<{
   mime: string | ALLOWED_CONTENT_TYPE;
   ext: string | ALLOWED_EXTENSION;
 
@@ -17,53 +30,84 @@ export async function getValidatedFileType(this: FileManager, args: Args): Promi
 }> {
   const { file, fileName, tableName, colName } = args;
   const config = this.prostgles?.opts.fileTable;
-  if(!config) throw new Error("File table config missing");
+  if (!config) throw new Error("File table config missing");
 
-  const buffer = typeof file === "string"? Buffer.from(file, 'utf8') : file;
+  const buffer = typeof file === "string" ? Buffer.from(file, "utf8") : file;
 
   const result = await getFileTypeFromFilename(fileName);
-  if(tableName && colName){
+  if (tableName && colName) {
     const tableConfig = config.referencedTables?.[tableName];
 
-    if(tableConfig && isObject(tableConfig) && tableConfig.referenceColumns[colName]){
+    if (
+      tableConfig &&
+      isObject(tableConfig) &&
+      tableConfig.referenceColumns[colName]
+    ) {
       const colConfig = tableConfig.referenceColumns[colName]!;
-      if(colConfig.maxFileSizeMB){
+      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 (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 !== "*"){
+
+      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} `)
+        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 !== "*"){
+      } 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} `)
+        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 !== "*"){
+      } 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} `)
+        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}`;
+  if (!result?.mime)
+    throw `File MIME type not found for the provided extension: ${result?.ext}`;
   return result;
-}
+}

package/lib/FileManager/initFileManager.ts

@@ -17,9 +17,10 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
   const { tableName = "files", referencedTables = {} } = fileTable;
   this.tableName = tableName;
 
-  const maxBfSizeMB = (prg.opts.io?.engine?.opts?.maxHttpBufferSize || 1e6) / 1e6;
+  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`
+    `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);
@@ -65,7 +66,7 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
         UNIQUE(id),
         UNIQUE(name)
     )`,
-      `Create fileTable ${asName(tableName)}`
+      `Create fileTable ${asName(tableName)}`,
     );
     await prg.refreshDBO();
   }
@@ -84,7 +85,9 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
     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)) {
+        if (
+          existingCol.references?.some(({ ftable }) => ftable === tableName)
+        ) {
           // All ok
         } else {
           if (existingCol.udt_name === "uuid") {
@@ -94,12 +97,12 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
               await runQuery(query, msg);
             } catch (e) {
               console.error(
-                `Could not add constraing. Err: ${e instanceof Error ? e.message : JSON.stringify(e)}`
+                `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)`
+              `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)`,
             );
           }
         }
@@ -115,7 +118,7 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
         // }
         // await createColumn();
         console.error(
-          `Referenced file column ${refTable} (${colName}) does not exist. Create it using this query:\n${query}`
+          `Referenced file column ${refTable} (${colName}) does not exist. Create it using this query:\n${query}`,
         );
       }
     }
@@ -154,7 +157,13 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
         }
         const id = name.slice(0, 36);
         const selectParams = {
-          select: { id: 1, name: 1, signed_url: 1, signed_url_expires: 1, content_type: 1 },
+          select: {
+            id: 1,
+            name: 1,
+            signed_url: 1,
+            signed_url_expires: 1,
+            content_type: 1,
+          },
         };
         const media = await runClientRequest.bind(this.prostgles)({
           type: "http",
@@ -178,7 +187,10 @@ export async function initFileManager(this: FileManager, prg: Prostgles) {
           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 });
+            await mediaTable.update(
+              { name },
+              { signed_url: url, signed_url_expires: EXPIRES },
+            );
           }
 
           res.redirect(url);

package/lib/FileManager/upload.ts

@@ -1,26 +1,30 @@
-import { FileManager, LocalConfig, OnProgress, UploadedItem } from "./FileManager";
-import * as stream from 'stream'; 
-import * as fs from 'fs';
+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, 
+  file: Buffer | string | stream.PassThrough,
   name: string,
   mime: string,
-  onProgress?: OnProgress
+  onProgress?: OnProgress,
 ): Promise<UploadedItem> {
-
   return new Promise(async (resolve, reject) => {
-    if(!file){
+    if (!file) {
       throw "No file. Expecting: Buffer | String | stream.PassThrough";
     }
-    if(!name){
+    if (!name) {
       throw "No file name. Expecting: String";
     }
 
     const url = this.getLocalFileUrl(name);
-    if(!this.cloudClient){
-      if(file instanceof stream.PassThrough){
+    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;
@@ -31,32 +35,30 @@ export async function upload(
         resolve({
           url,
           etag: `none`,
-          content_length: fs.statSync(filePath).size
+          content_length: fs.statSync(filePath).size,
         });
-      } catch(err){
+      } catch (err) {
         console.error("Error saving file locally", err);
-        reject("Internal error")
+        reject("Internal error");
       }
     } else {
-
       let content_length = 0;
       this.cloudClient.upload({
         fileName: name,
         contentType: mime,
         file,
         onFinish: (err, uploaded) => {
-          if(err){
+          if (err) {
             reject(err.toString());
           } else {
             resolve({ ...uploaded, url });
           }
         },
-        onProgress: loaded => {
+        onProgress: (loaded) => {
           content_length = loaded;
           onProgress?.({ loaded, total: content_length });
-        }
+        },
       });
     }
-
   });
-}
+}