prostgles-server 4.2.613 → 4.2.615

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -1,9 +1,9 @@
 import type pgPromise from "pg-promise";
 import type { AnyObject } from "prostgles-types";
-import { asName, pickKeys } from "prostgles-types";
+import { asName } from "prostgles-types";
 import type { FileTableConfig } from "../../ProstglesTypes";
-import type { TableHandlers } from "../DboBuilder";
-import type { FileTableRow } from "../../StorageClient/getFileTableConfig";
+import type { OnCommit } from "../../PublishParser/publishTypesAndUtils";
+import { deleteUnreferencedFile } from "../../StorageClient/deleteUnreferencedFile";
 
 type OnDeleteFromFileTableArgs = {
   returningQuery: undefined | string;
@@ -12,18 +12,14 @@ type OnDeleteFromFileTableArgs = {
     filter: AnyObject;
   };
   t: pgPromise.ITask<{}>;
-  dbTX: TableHandlers;
+  onCommit: OnCommit;
   isOneOrNone: boolean;
 };
 export const onDeleteFromFileTable = async (
   config: FileTableConfig,
-  { dbTX, t, returningQuery, filterOpts, isOneOrNone }: OnDeleteFromFileTableArgs,
+  { onCommit, t, returningQuery, filterOpts, isOneOrNone }: OnDeleteFromFileTableArgs,
 ) => {
-  const { storageClient, tableName } = config;
-  const tableHandler = dbTX[tableName];
-  if (!tableHandler) {
-    throw new Error(`TableHandler for ${tableName} not found in dbTX`);
-  }
+  const { tableName } = config;
   if (config.delayedDelete) {
     const result = await t.any(
       `UPDATE ${asName(tableName)} SET deleted = now() ${filterOpts.where} ${returningQuery ?? ""};`,
@@ -31,27 +27,15 @@ export const onDeleteFromFileTable = async (
     return (isOneOrNone ? result[0] : result) as undefined | AnyObject[];
   }
 
-  let files: { id: string }[] = [];
-  const totalFiles = await tableHandler.count(filterOpts.filter);
-  do {
-    const batch = (await tableHandler.find(filterOpts.filter, {
-      limit: 100,
-      offset: files.length,
-    })) as FileTableRow[];
-    files = [...files, ...batch];
-  } while (files.length < totalFiles);
-
-  for (const file of files) {
-    await t.any(`DELETE FROM ${asName(tableName)} WHERE id = \${id}`, file);
-  }
-  /** If any table delete fails then do not delete files */
-  for (const file of files) {
-    await storageClient.delete(file.id);
-  }
-
-  if (returningQuery) {
-    return files.map((f) => pickKeys(f, ["id"]));
-  }
-
-  return undefined;
+  const files = await t.any<Record<string, unknown> & { _prostgles_storage_key: string }>(
+    `DELETE FROM ${asName(tableName)} ${filterOpts.where}
+     ${returningQuery ? `${returningQuery},` : "RETURNING"}
+     COALESCE(storage_key, id) AS _prostgles_storage_key`,
+  );
+  const result = files.map(({ _prostgles_storage_key, ...row }) => {
+    onCommit(({ db }) => deleteUnreferencedFile(db, config, _prostgles_storage_key));
+    return row;
+  });
+  if (!returningQuery) return undefined;
+  return (isOneOrNone ? result[0] : result) as AnyObject[] | undefined;
 };

package/lib/DboBuilder/TableHandler/prepareBeforeHookData.ts

@@ -0,0 +1,27 @@
+import { isObject, pickKeys, type AnyObject, type FieldFilter } from "prostgles-types";
+import { validateKeys } from "../ViewHandler/ViewHandler";
+import type { TableHandler } from "./TableHandler";
+
+export const prepareBeforeHookData = (
+  table: TableHandler,
+  row: AnyObject,
+  fields: FieldFilter | undefined,
+  removeDisallowedFields: boolean,
+  command: "insert" | "update",
+) => {
+  const allowed = table.parseFieldFilter(fields, false);
+  // Nested table inserts are checked against their own publish rules later.
+  const nestedTables =
+    command === "insert" && !table.is_media ?
+      Object.keys(row).filter(
+        (key) =>
+          !table.columnSet.has(key) &&
+          table.dboBuilder.dboMap.has(key) &&
+          (isObject(row[key]) || Array.isArray(row[key]) || row[key] === undefined),
+      )
+    : [];
+  const allowedKeys = [...allowed, ...nestedTables];
+  const data = removeDisallowedFields ? pickKeys(row, allowedKeys) : { ...row };
+  validateKeys(data, allowedKeys);
+  return data;
+};

package/lib/DboBuilder/TableHandler/update.ts

@@ -7,7 +7,9 @@ import { prepareNewData } from "./DataValidator";
 import { getInsertTableRules } from "./insert/getInsertTableRules";
 import { getReferenceColumnInserts } from "./insert/getReferenceColumnInserts";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
+import { getFileUpdateId } from "./updateFile";
 import type { TableHandler } from "./TableHandler";
+import { prepareBeforeHookData } from "./prepareBeforeHookData";
 
 export async function update(
   this: TableHandler,
@@ -65,7 +67,37 @@ export async function update(
         );
     }
 
-    const beforeResult = await this.beforeEach(newData, localParams, "update", filter);
+    const updateFilter = await this.prepareWhere({
+      select: undefined,
+      filter,
+      forcedFilter,
+      filterFields,
+      localParams,
+      tableRule: tableRules,
+    });
+    if (this.is_media) getFileUpdateId(filter);
+    if (this.getBeforeHooks("update", [newData]).length) {
+      newData = prepareBeforeHookData(this, newData, fields, removeDisallowedFields, "update");
+      if (params?.returnType?.startsWith("statement") || localParams?.returnQuery) {
+        throw new Error("Updates with beforeEach hooks cannot return SQL statements");
+      }
+      if (!transaction) throw new Error("beforeEach hooks require a transaction");
+      const permittedRows = await transaction.t.any(
+        withUserRLS(
+          localParams,
+          `SELECT 1 FROM ${this.escapedName} ${updateFilter.where} FOR UPDATE`,
+          true,
+        ),
+      );
+      if (!permittedRows.length) {
+        return params?.returning && params.multi !== false ? [] : undefined;
+      }
+      if (params?.multi === false && permittedRows.length > 1) {
+        throw `More than 1 row modified: ${permittedRows.length} rows affected`;
+      }
+    }
+
+    const beforeResult = await this.beforeEach(newData, localParams, "update", updateFilter.filter);
     newData = beforeResult.row;
 
     const { data, allowedCols } = prepareNewData({
@@ -79,15 +111,6 @@ export async function update(
       columnsAddedFromBeforeHooks: beforeResult.columnsAdded,
     });
 
-    const updateFilter = await this.prepareWhere({
-      select: undefined,
-      filter,
-      forcedFilter,
-      filterFields,
-      localParams,
-      tableRule: tableRules,
-    });
-
     /**
      * Nested inserts
      */
@@ -105,10 +128,13 @@ export async function update(
       if (+updateCount > 1) {
         throw "Cannot do a nestedInsert from an update that targets more than 1 row";
       }
+      if (!+updateCount) {
+        return params?.returning && params.multi !== false ? [] : undefined;
+      }
       if (!transaction) {
         return wrapInTx();
       }
-      await Promise.all(
+      const nestedResults = await Promise.allSettled(
         nestedInserts.map(async (nestedInsert) => {
           const nestedTableHandler = transaction.dbTX[nestedInsert.tableName];
           if (!nestedTableHandler)
@@ -151,6 +177,9 @@ export async function update(
           };
         }),
       );
+      for (const result of nestedResults) {
+        if (result.status === "rejected") throw result.reason;
+      }
     }
 
     const tx = localParams?.tx?.t || this.tx?.t || this.db;

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -4,18 +4,40 @@ import type { FileTableConfig } from "../../ProstglesTypes";
 import type { FileTableRow } from "../../StorageClient/getFileTableConfig";
 import type { TableHandler } from "./TableHandler";
 import { uploadFile, type UploadFileArgs } from "./uploadFile";
+import { deleteUnreferencedFile } from "../../StorageClient/deleteUnreferencedFile";
+import { getFileStorageKey } from "../../StorageClient/getFileStorageKey";
 
 type Args = Pick<
   UploadFileArgs,
-  "localParams" | "data" | "original_name" | "original_last_modified"
+  "localParams" | "data" | "original_name" | "original_last_modified" | "onCommit" | "onRollback"
 > & {
   filter: AnyObject;
 };
 export const updateFile = async (
   tableHandler: TableHandler,
   config: FileTableConfig,
-  { filter, data, original_name, original_last_modified, localParams }: Args,
+  { filter, data, original_name, original_last_modified, localParams, onCommit, onRollback }: Args,
 ) => {
+  const existingFile = (await tableHandler.findOne(filter)) as FileTableRow | undefined;
+
+  if (!existingFile?.id) {
+    throw new Error("Existing file record not found");
+  }
+
+  onCommit(({ db }) => deleteUnreferencedFile(db, config, getFileStorageKey(existingFile)));
+  const newFile = await uploadFile(config, {
+    onCommit,
+    onRollback,
+    original_name,
+    data,
+    localParams,
+    mediaId: existingFile.id,
+    original_last_modified,
+  });
+  return { newData: omitKeys(newFile, ["id"]) };
+};
+
+export const getFileUpdateId = (filter: AnyObject): string => {
   const { data: validFilter } = getJSONBObjectSchemaValidationError(
     { id: { optional: true, type: "string" } },
     filter,
@@ -30,21 +52,5 @@ export const updateFile = async (
     );
   }
 
-  const existingFile = (await tableHandler.findOne({
-    id: existingMediaId,
-  })) as FileTableRow | undefined;
-
-  if (!existingFile?.id) {
-    throw new Error("Existing file record not found");
-  }
-
-  await config.storageClient.delete(existingFile.id);
-  const newFile = await uploadFile(config, {
-    original_name,
-    data,
-    localParams,
-    mediaId: existingFile.id,
-    original_last_modified,
-  });
-  return { newData: omitKeys(newFile, ["id"]) };
+  return existingMediaId;
 };

package/lib/DboBuilder/TableHandler/uploadFile.ts

@@ -4,7 +4,12 @@ import type { FileTableConfig } from "../../ProstglesTypes";
 import type { FileTableRow } from "../../StorageClient/getFileTableConfig";
 import { getValidatedFileType } from "../../StorageClient/getValidatedFileType";
 import { getFileServeRoute } from "../../StorageClient/setupFileServeHandler";
+import { deleteUnreferencedFile } from "../../StorageClient/deleteUnreferencedFile";
 import type { LocalParams } from "../DboBuilder";
+import type {
+  OnCommitCallback,
+  TransactionCallbacks,
+} from "../../PublishParser/publishTypesAndUtils";
 
 const FILE_SCHEMA = {
   id: { type: "string", optional: true },
@@ -30,7 +35,7 @@ export const assertFileObjectValid: AssertFileObjectValid = (row) => {
   }
 };
 
-export type UploadFileArgs = {
+export type UploadFileArgs = TransactionCallbacks & {
   data: Buffer<ArrayBufferLike>;
   original_name: string;
   original_last_modified: string | null;
@@ -43,7 +48,15 @@ export type UploadFileArgs = {
 
 export const uploadFile = async (
   config: FileTableConfig,
-  { data, original_name, original_last_modified, localParams, mediaId }: UploadFileArgs,
+  {
+    data,
+    original_name,
+    original_last_modified,
+    localParams,
+    mediaId,
+    onCommit,
+    onRollback,
+  }: UploadFileArgs,
 ): Promise<Omit<FileTableRow, "added"> & Partial<Pick<FileTableRow, "added">>> => {
   const storageClient = config.storageClient;
 
@@ -64,11 +77,22 @@ export const uploadFile = async (
     content_type: type.mime,
   };
 
-  const uploadedInfo = await storageClient.upload({
-    file: data,
-    fileName: coreInfo.id,
-    contentType: coreInfo.content_type,
-  });
+  const storageKey = randomUUID();
+  const pendingUpload = Promise.resolve().then(async () =>
+    storageClient.upload({
+      file: data,
+      fileName: storageKey,
+      contentType: coreInfo.content_type,
+    }),
+  );
+  const cleanup: OnCommitCallback = async ({ db }) => {
+    // A sibling operation may have failed while this upload was still running.
+    await pendingUpload.catch(() => {});
+    await deleteUnreferencedFile(db, config, storageKey);
+  };
+  onCommit(cleanup);
+  onRollback(cleanup);
+  const uploadedInfo = await pendingUpload;
 
   const { contentLength, contentHash } = uploadedInfo;
   const { filePath } = uploadedInfo.type === "local" ? uploadedInfo : {};
@@ -76,6 +100,7 @@ export const uploadFile = async (
 
   const fileServeRoute = getFileServeRoute(config);
   const mediaRow: Omit<FileTableRow, "added"> = {
+    storage_key: storageKey,
     signed_url: null,
     signed_url_expires: null,
     updated: new Date().toISOString(),

package/lib/Logging.ts

@@ -176,6 +176,7 @@ export namespace EventTypes {
             | "initFileManager.runQuery"
             | "DboBuilder.getTablesForSchemaPostgresSQL"
             | "DboBuilder.onCommit"
+            | "DboBuilder.onRollback"
             | "PubSubManager.create";
           data?: AnyObject;
         }

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -88,11 +88,12 @@ export type BeforeEachTsTrigger<R, DBX, Context = undefined> = {
    */
   changedFields?: (keyof R)[];
   validate: (
-    params: ValidateBeforeRowArgsCommon<R, DBX> & {
-      localParams: undefined | LocalParams;
-      hookContext: AnyObject | undefined;
-      context: Context;
-    },
+    params: ValidateBeforeRowArgsCommon<R, DBX> &
+      TransactionCallbacks<DBX> & {
+        localParams: undefined | LocalParams;
+        hookContext: AnyObject | undefined;
+        context: Context;
+      },
   ) => MaybePromise<void | { row: Partial<R>; hookContext?: AnyObject; onInserted?: () => void }>;
 };
 
@@ -102,6 +103,16 @@ export type OnCommitCallback<DBO = DBHandlerServer> = (args: {
 }) => MaybePromise<unknown>;
 export type OnCommit<DBO = DBHandlerServer> = (callback: OnCommitCallback<DBO>) => void;
 
+export type TransactionCallbacks<DBO = DBHandlerServer> = {
+  /** Awaited after the outer transaction commits. Errors are logged. */
+  onCommit: OnCommit<DBO>;
+  /**
+   * Awaited after the outer transaction rejects. Errors are logged.
+   * A failed COMMIT acknowledgement may have committed; verify state before destructive cleanup.
+   */
+  onRollback: OnCommit<DBO>;
+};
+
 export type AfterEachTsTrigger<R, DBX, Context = undefined> = {
   commands: Partial<Record<"insert" | "update" | "delete", 1>>;
   /**
@@ -109,11 +120,11 @@ export type AfterEachTsTrigger<R, DBX, Context = undefined> = {
    */
   changedFields?: (keyof R)[];
   validate: (
-    params: ValidateRowArgsCommon<R, DBX> & {
-      localParams: undefined | LocalParams;
-      context: Context;
-      onCommit: OnCommit<DBX>;
-    },
+    params: ValidateRowArgsCommon<R, DBX> &
+      TransactionCallbacks<DBX> & {
+        localParams: undefined | LocalParams;
+        context: Context;
+      },
   ) => Promise<void>;
 };
 
@@ -152,11 +163,11 @@ export type AfterAllTsTrigger<R, DBX, Context = undefined> = {
   commands: Partial<Record<"insert" | "update" | "delete", 1>>;
   changedFields?: string[];
   validate: (
-    params: ValidateRowsArgsCommon<R, DBX> & {
-      localParams: undefined | LocalParams;
-      context: Context;
-      onCommit: OnCommit<DBX>;
-    },
+    params: ValidateRowsArgsCommon<R, DBX> &
+      TransactionCallbacks<DBX> & {
+        localParams: undefined | LocalParams;
+        context: Context;
+      },
   ) => Promise<void>;
 };
 

package/lib/StorageClient/deleteUnreferencedFile.ts

@@ -0,0 +1,19 @@
+import type { DB } from "../Prostgles";
+import type { FileTableConfig } from "../ProstglesTypes";
+
+export const deleteUnreferencedFile = async (
+  db: DB,
+  config: FileTableConfig,
+  storageKey: string,
+) => {
+  // A failed COMMIT response does not prove rollback. Check committed state first.
+  // Fail closed if RLS would hide a reference or the database is unavailable.
+  const referenced = await db.tx(async (tx) => {
+    await tx.none("SET LOCAL row_security = off");
+    return tx.oneOrNone<{ found: number }>(
+      "SELECT 1 FROM ${table:name} WHERE storage_key = ${key}::uuid OR (storage_key IS NULL AND id = ${key}::uuid) LIMIT 1",
+      { table: config.tableName, key: storageKey },
+    );
+  });
+  if (!referenced) await config.storageClient.delete(storageKey);
+};

package/lib/StorageClient/getFileStorageKey.ts

@@ -0,0 +1,5 @@
+import type { FileTableRow } from "./getFileTableConfig";
+
+/** Legacy files are stored under their logical ID. */
+export const getFileStorageKey = (file: Pick<FileTableRow, "id" | "storage_key">) =>
+  file.storage_key ?? file.id;

package/lib/StorageClient/getFileTableConfig.ts

@@ -8,9 +8,11 @@ import type { TableConfig } from "../TableConfig/TableConfigTypes";
 import type { TableRowFromColumnDefinitions } from "../TableConfig/TableRowFromColumnDefinitions";
 import type { TableHooks } from "../TableHooks/TableHooks";
 import { setupFileServeHandler } from "./setupFileServeHandler";
+import type { TableHandlers } from "../DboBuilder/DboBuilder";
 
 const FILE_TABLE_COLUMN_DEFINITIONS = {
   id: `UUID PRIMARY KEY DEFAULT gen_random_uuid()`,
+  storage_key: `UUID UNIQUE`, // NULL for legacy objects stored under their file ID.
   extension: `TEXT NOT NULL DEFAULT ''`,
   content_type: `TEXT NOT NULL DEFAULT ''`,
   content_length: `BIGINT NOT NULL DEFAULT 0`,
@@ -101,8 +103,16 @@ export const getFileTableConfig = (
             insert: 1,
             update: 1,
           },
-          validate: async ({ data: insertData, localParams, command, filter }) => {
-            const tableHandler = prg.dboBuilder.dboMap.get(fileTableName);
+          validate: async ({
+            data: insertData,
+            localParams,
+            command,
+            filter,
+            dbx,
+            onCommit,
+            onRollback,
+          }) => {
+            const tableHandler = dbx[fileTableName];
             if (!tableHandler) throw "Storage tableHandler not found";
             assertFileObjectValid(insertData);
 
@@ -110,6 +120,8 @@ export const getFileTableConfig = (
             const data = dataBlob as unknown as Buffer;
             if (command === "update") {
               const { newData } = await updateFile(tableHandler, fileTable, {
+                onCommit,
+                onRollback,
                 filter: filter ?? {},
                 localParams,
                 data,
@@ -125,6 +137,8 @@ export const getFileTableConfig = (
             }
 
             const media = await uploadFile(fileTable, {
+              onCommit,
+              onRollback,
               data,
               original_name,
               localParams,
@@ -139,12 +153,12 @@ export const getFileTableConfig = (
               },
             };
           },
-        } satisfies BeforeEachTsTrigger<FileTableRow, {}>,
+        } satisfies BeforeEachTsTrigger<FileTableRow, TableHandlers>,
         ...(userFileTableHooks?.beforeEach || []),
       ],
-      onInsteadOfDelete: async ({ dbx, tx, returningQuery, isOneOrNone, filterOpts }) => {
+      onInsteadOfDelete: async ({ onCommit, tx, returningQuery, isOneOrNone, filterOpts }) => {
         return onDeleteFromFileTable(fileTable, {
-          dbTX: dbx,
+          onCommit,
           t: tx,
           returningQuery,
           isOneOrNone,

package/lib/StorageClient/getFileType.ts

@@ -1,8 +1,3 @@
-// const fileType = require("file-type");
-// const res = await fileType.fromBuffer(typeof file === "string"? Buffer.from(file, 'utf8') : file);
-
-// import * as sharp from "sharp";
-
 import type { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION } from "prostgles-types";
 import { CONTENT_TYPE_TO_EXT, getKeys } from "prostgles-types";
 
@@ -17,24 +12,26 @@ export const getFileType = async (
 
   const fileNameMime = getFileTypeFromFilename(fileName);
   if (!fileNameMime?.ext) throw new Error("File name must contain extension");
-  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)) {
+  const detectedFileType = await fileTypeFromBuffer(
+    typeof file === "string" ? Buffer.from(file, "utf8") : file,
+  );
+
+  if (!detectedFileType) {
+    // Text formats may not have a detectable binary signature.
+    const { mime } = fileNameMime;
+    if (mime.startsWith("text/") || mime.endsWith("+xml") || mime === "application/sql") {
       return fileNameMime;
     }
 
     throw new Error("Could not get the file type from file buffer");
   } else {
-    if (fileNameMime.ext.toLowerCase() !== res.ext.toLowerCase()) {
+    if (fileNameMime.ext.toLowerCase() !== detectedFileType.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 ${detectedFileType.ext}`,
       );
     }
   }
-  return res as any;
+  return detectedFileType as any;
 };
 
 export const getFileTypeFromFilename = (

package/lib/StorageClient/getLocalStorageClient.ts

@@ -2,6 +2,7 @@ import crypto from "crypto";
 import fs from "fs";
 import path from "path";
 import stream from "stream";
+import { pipeline } from "stream/promises";
 import type {
   UploadFileOptions,
   LocalStorageClient,
@@ -55,52 +56,28 @@ export const getLocalStorageClient = (localConfig: LocalConfig): LocalStorageCli
       const hash = crypto.createHash("md5");
       let contentLength = 0;
 
-      return new Promise((resolve, reject) => {
-        const writeStream = fs.createWriteStream(filePath);
-
-        writeStream.on("error", reject);
-        writeStream.on("finish", () => {
-          resolve({
-            type: "local",
-            filePath,
-            contentHash: hash.digest("hex"),
-            contentLength: contentLength,
-          });
-        });
-
-        if (typeof args.file === "string" || Buffer.isBuffer(args.file)) {
-          const buffer = Buffer.isBuffer(args.file) ? args.file : Buffer.from(args.file);
-
-          contentLength = buffer.length;
-          hash.update(buffer);
-
-          if (args.onProgress) {
+      const buffered = typeof args.file === "string" || Buffer.isBuffer(args.file);
+      const source = buffered ? stream.Readable.from([args.file]) : args.file;
+      let lastProgress = Date.now();
+      const measure = new stream.Transform({
+        transform: (chunk: Buffer, _encoding, callback) => {
+          contentLength += chunk.length;
+          hash.update(chunk);
+          if (args.onProgress && (buffered || Date.now() - lastProgress > 1000)) {
+            lastProgress = Date.now();
             args.onProgress(contentLength);
           }
-
-          writeStream.write(buffer);
-          writeStream.end();
-        } else if (
-          args.file instanceof stream.Readable ||
-          (args.file as unknown) instanceof stream.PassThrough
-        ) {
-          let lastProgress = Date.now();
-          const throttle = 1000; // 1 second
-          args.file.on("data", (chunk: Buffer) => {
-            contentLength += chunk.length;
-            hash.update(chunk);
-            if (args.onProgress && Date.now() - lastProgress > throttle) {
-              lastProgress = Date.now();
-              args.onProgress(contentLength);
-            }
-          });
-
-          args.file.on("error", reject);
-          args.file.pipe(writeStream);
-        } else {
-          reject(new Error("Unsupported file type provided to upload."));
-        }
+          callback(null, chunk);
+        },
       });
+      // Wait for all streams to close before transaction cleanup can remove a failed upload.
+      await pipeline(source, measure, fs.createWriteStream(filePath));
+      return {
+        type: "local",
+        filePath,
+        contentHash: hash.digest("hex"),
+        contentLength,
+      };
     },
 
     downloadAsStream: async (name: string) => {

package/lib/StorageClient/getValidatedFileType.ts

@@ -87,6 +87,9 @@ export const getValidatedFileType = async (
       }
     }
   }
-  if (!result?.mime) throw `File MIME type not found for the provided extension: ${result?.ext}`;
+  if (!result?.mime) {
+    const extension = fileName.includes(".") ? fileName.split(".").at(-1) : "(none)";
+    throw `File MIME type not found for the provided extension: ${extension}`;
+  }
   return result;
 };