@remix-run/file-storage 0.9.0 → 0.10.0

package/src/lib/local-file-storage.ts

@@ -1,11 +1,11 @@
-import * as fs from 'node:fs';
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
-import { openFile, writeFile } from '@remix-run/lazy-file/fs';
+import * as fs from 'node:fs'
+import * as fsp from 'node:fs/promises'
+import * as path from 'node:path'
+import { openFile, writeFile } from '@remix-run/lazy-file/fs'
 
-import type { FileStorage, FileMetadata, ListOptions, ListResult } from './file-storage.ts';
+import type { FileStorage, FileMetadata, ListOptions, ListResult } from './file-storage.ts'
 
-type MetadataJson = Omit<FileMetadata, 'size'>;
+type MetadataJson = Omit<FileMetadata, 'size'>
 
 /**
  * A `FileStorage` that is backed by a directory on the local filesystem.
@@ -19,171 +19,171 @@ type MetadataJson = Omit<FileMetadata, 'size'>;
  * same storage object.
  */
 export class LocalFileStorage implements FileStorage {
-  #dirname: string;
+  #dirname: string
 
   /**
    * @param directory The directory where files are stored
    */
   constructor(directory: string) {
-    this.#dirname = path.resolve(directory);
+    this.#dirname = path.resolve(directory)
 
     try {
-      let stats = fs.statSync(this.#dirname);
+      let stats = fs.statSync(this.#dirname)
 
       if (!stats.isDirectory()) {
-        throw new Error(`Path "${this.#dirname}" is not a directory`);
+        throw new Error(`Path "${this.#dirname}" is not a directory`)
       }
     } catch (error) {
       if (!isNoEntityError(error)) {
-        throw error;
+        throw error
       }
 
-      fs.mkdirSync(this.#dirname, { recursive: true });
+      fs.mkdirSync(this.#dirname, { recursive: true })
     }
   }
 
   async get(key: string): Promise<File | null> {
-    let { filePath, metaPath } = await this.#getPaths(key);
+    let { filePath, metaPath } = await this.#getPaths(key)
 
     try {
-      let meta = await readMetadata(metaPath);
+      let meta = await readMetadata(metaPath)
 
       return openFile(filePath, {
         lastModified: meta.lastModified,
         name: meta.name,
         type: meta.type,
-      });
+      })
     } catch (error) {
       if (!isNoEntityError(error)) {
-        throw error;
+        throw error
       }
 
-      return null;
+      return null
     }
   }
 
   async has(key: string): Promise<boolean> {
-    let { metaPath } = await this.#getPaths(key);
+    let { metaPath } = await this.#getPaths(key)
 
     try {
-      await fsp.access(metaPath);
-      return true;
+      await fsp.access(metaPath)
+      return true
     } catch {
-      return false;
+      return false
     }
   }
 
   async list<T extends ListOptions>(options?: T): Promise<ListResult<T>> {
-    let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {};
+    let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {}
 
-    let files: any[] = [];
-    let foundCursor = cursor === undefined;
-    let nextCursor: string | undefined;
-    let lastHash: string | undefined;
+    let files: any[] = []
+    let foundCursor = cursor === undefined
+    let nextCursor: string | undefined
+    let lastHash: string | undefined
 
     outerLoop: for await (let subdir of await fsp.opendir(this.#dirname)) {
-      if (!subdir.isDirectory()) continue;
+      if (!subdir.isDirectory()) continue
 
       for await (let file of await fsp.opendir(path.join(this.#dirname, subdir.name))) {
-        if (!file.isFile() || !file.name.endsWith('.meta.json')) continue;
+        if (!file.isFile() || !file.name.endsWith('.meta.json')) continue
 
-        let hash = file.name.slice(0, -10); // Remove ".meta.json"
+        let hash = file.name.slice(0, -10) // Remove ".meta.json"
 
         if (foundCursor) {
-          let meta = await readMetadata(path.join(this.#dirname, subdir.name, file.name));
+          let meta = await readMetadata(path.join(this.#dirname, subdir.name, file.name))
 
           if (prefix != null && !meta.key.startsWith(prefix)) {
-            continue;
+            continue
           }
 
           if (files.length >= limit) {
-            nextCursor = lastHash;
-            break outerLoop;
+            nextCursor = lastHash
+            break outerLoop
           }
 
           if (includeMetadata) {
-            let size = (await fsp.stat(path.join(this.#dirname, subdir.name, `${hash}.dat`))).size;
-            files.push({ ...meta, size });
+            let size = (await fsp.stat(path.join(this.#dirname, subdir.name, `${hash}.dat`))).size
+            files.push({ ...meta, size })
           } else {
-            files.push({ key: meta.key });
+            files.push({ key: meta.key })
           }
         } else if (hash === cursor) {
-          foundCursor = true;
+          foundCursor = true
         }
 
-        lastHash = hash;
+        lastHash = hash
       }
     }
 
     return {
       cursor: nextCursor,
       files,
-    };
+    }
   }
 
   async put(key: string, file: File): Promise<File> {
-    await this.set(key, file);
-    return (await this.get(key))!;
+    await this.set(key, file)
+    return (await this.get(key))!
   }
 
   async remove(key: string): Promise<void> {
-    let { directory, filePath, metaPath } = await this.#getPaths(key);
+    let { directory, filePath, metaPath } = await this.#getPaths(key)
 
     try {
-      await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)]);
+      await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)])
 
       // Check if directory is empty and remove it if so
-      let files = await fsp.readdir(directory);
+      let files = await fsp.readdir(directory)
       if (files.length === 0) {
-        await fsp.rmdir(directory);
+        await fsp.rmdir(directory)
       }
     } catch (error) {
       if (!isNoEntityError(error)) {
-        throw error;
+        throw error
       }
     }
   }
 
   async set(key: string, file: File): Promise<void> {
-    let { directory, filePath, metaPath } = await this.#getPaths(key);
+    let { directory, filePath, metaPath } = await this.#getPaths(key)
 
     // Ensure directory exists
-    await fsp.mkdir(directory, { recursive: true });
+    await fsp.mkdir(directory, { recursive: true })
 
-    await writeFile(filePath, file);
+    await writeFile(filePath, file)
 
     let meta: MetadataJson = {
       key,
       lastModified: file.lastModified,
       name: file.name,
       type: file.type,
-    };
-    await fsp.writeFile(metaPath, JSON.stringify(meta));
+    }
+    await fsp.writeFile(metaPath, JSON.stringify(meta))
   }
 
   async #getPaths(key: string): Promise<{ directory: string; filePath: string; metaPath: string }> {
-    let hash = await computeHash(key);
-    let directory = path.join(this.#dirname, hash.slice(0, 2));
+    let hash = await computeHash(key)
+    let directory = path.join(this.#dirname, hash.slice(0, 2))
 
     return {
       directory,
       filePath: path.join(directory, `${hash}.dat`),
       metaPath: path.join(directory, `${hash}.meta.json`),
-    };
+    }
   }
 }
 
 async function readMetadata(metaPath: string): Promise<MetadataJson> {
-  return JSON.parse(await fsp.readFile(metaPath, 'utf-8'));
+  return JSON.parse(await fsp.readFile(metaPath, 'utf-8'))
 }
 
 async function computeHash(key: string, algorithm = 'SHA-256'): Promise<string> {
-  let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key));
+  let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key))
   return Array.from(new Uint8Array(digest))
     .map((b) => b.toString(16).padStart(2, '0'))
-    .join('');
+    .join('')
 }
 
 function isNoEntityError(obj: unknown): obj is NodeJS.ErrnoException & { code: 'ENOENT' } {
-  return obj instanceof Error && 'code' in obj && (obj as NodeJS.ErrnoException).code === 'ENOENT';
+  return obj instanceof Error && 'code' in obj && (obj as NodeJS.ErrnoException).code === 'ENOENT'
 }

package/src/lib/memory-file-storage.ts

@@ -1,35 +1,35 @@
-import type { FileStorage, ListOptions, ListResult } from './file-storage.ts';
+import type { FileStorage, ListOptions, ListResult } from './file-storage.ts'
 
 /**
  * A simple, in-memory implementation of the `FileStorage` interface.
  */
 export class MemoryFileStorage implements FileStorage {
-  #map = new Map<string, File>();
+  #map = new Map<string, File>()
 
   get(key: string): File | null {
-    return this.#map.get(key) ?? null;
+    return this.#map.get(key) ?? null
   }
 
   has(key: string): boolean {
-    return this.#map.has(key);
+    return this.#map.has(key)
   }
 
   list<T extends ListOptions>(options?: T): ListResult<T> {
-    let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {};
+    let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {}
 
-    let files: any[] = [];
-    let foundCursor = cursor === undefined;
-    let nextCursor: string | undefined;
+    let files: any[] = []
+    let foundCursor = cursor === undefined
+    let nextCursor: string | undefined
 
     for (let [key, file] of this.#map.entries()) {
       if (foundCursor) {
         if (prefix != null && !key.startsWith(prefix)) {
-          continue;
+          continue
         }
 
         if (files.length >= limit) {
-          nextCursor = files[files.length - 1]?.key;
-          break;
+          nextCursor = files[files.length - 1]?.key
+          break
         }
 
         if (includeMetadata) {
@@ -39,37 +39,37 @@ export class MemoryFileStorage implements FileStorage {
             name: file.name,
             size: file.size,
             type: file.type,
-          });
+          })
         } else {
-          files.push({ key });
+          files.push({ key })
         }
       } else if (key === cursor) {
-        foundCursor = true;
+        foundCursor = true
       }
     }
 
     return {
       cursor: nextCursor,
       files,
-    };
+    }
   }
 
   async put(key: string, file: File): Promise<File> {
-    await this.set(key, file);
-    return this.get(key)!;
+    await this.set(key, file)
+    return this.get(key)!
   }
 
   remove(key: string): void {
-    this.#map.delete(key);
+    this.#map.delete(key)
   }
 
   async set(key: string, file: File): Promise<void> {
-    let buffer = await file.arrayBuffer();
+    let buffer = await file.arrayBuffer()
     let newFile = new File([buffer], file.name, {
       lastModified: file.lastModified,
       type: file.type,
-    });
+    })
 
-    this.#map.set(key, newFile);
+    this.#map.set(key, newFile)
   }
 }

package/src/local.ts

@@ -1 +1 @@
-export { LocalFileStorage } from './lib/local-file-storage.ts';
+export { LocalFileStorage } from './lib/local-file-storage.ts'

package/src/memory.ts

@@ -1 +1 @@
-export { MemoryFileStorage } from './lib/memory-file-storage.ts';
+export { MemoryFileStorage } from './lib/memory-file-storage.ts'

package/dist/file-storage.cjs

@@ -1,19 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/file-storage.ts
-var file_storage_exports = {};
-module.exports = __toCommonJS(file_storage_exports);
-//# sourceMappingURL=file-storage.cjs.map

package/dist/file-storage.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/file-storage.ts"],
-  "sourcesContent": ["export type {\n  FileStorage,\n  FileKey,\n  FileMetadata,\n  ListOptions,\n  ListResult,\n} from './lib/file-storage.ts';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;",
-  "names": []
-}

package/dist/file-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-storage.d.ts","sourceRoot":"","sources":["../src/file-storage.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,uBAAuB,CAAC"}

package/dist/file-storage.js

@@ -1 +0,0 @@
-//# sourceMappingURL=file-storage.js.map