nuxt-filer 0.0.6 → 0.0.8

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-filer",
   "configKey": "filer",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -73,15 +73,16 @@ const module = defineNuxtModule({
     }
     nuxt.hook("nitro:config", (nitroConfig) => {
       nitroConfig.virtual = nitroConfig.virtual || {};
-      nitroConfig.virtual["#nuxt-filer-options"] = `export const storageName = ${JSON.stringify(options.storageName)}`;
+      nitroConfig.virtual["#nuxt-filer-options"] = [
+        `export const storageName = ${JSON.stringify(options.storageName)};`,
+        `export const storagePath = ${JSON.stringify(options.storagePath)};`
+      ].join("\n");
       nitroConfig.virtual["#nuxt-filer-image"] = `export const ipxRoute = ${JSON.stringify(ipxRoute)}`;
       if (options.provider === "unstorage") {
-        nitroConfig.storage = nitroConfig.storage || {};
-        nitroConfig.storage[options.storageName] = {
-          driver: "fsLite",
-          base: options.storagePath
-        };
         nitroConfig.plugins = nitroConfig.plugins || [];
+        nitroConfig.plugins.push(
+          resolver.resolve("./runtime/server/plugins/default-storage")
+        );
         nitroConfig.plugins.push(
           resolver.resolve("./runtime/server/plugins/default-provider")
         );

package/dist/runtime/image/provider.d.ts

@@ -3,5 +3,10 @@ interface FilerProviderOptions {
     baseURL?: string;
 }
 export declare const getImage: ProviderGetImage;
-export declare const validateDomains = false;
+declare const _default: () => {
+    getImage: ProviderGetImage;
+    validateDomains: boolean;
+    supportsAlias: boolean;
+};
+export default _default;
 export type { FilerProviderOptions };

package/dist/runtime/image/provider.js

@@ -1,17 +1,35 @@
+import { joinURL } from "ufo";
 const operationsGenerator = (modifiers) => {
-  const ops = [];
-  for (const [key, value] of Object.entries(modifiers)) {
+  const out = [];
+  if (modifiers.width && modifiers.height) {
+    modifiers.resize = `${modifiers.width}x${modifiers.height}`;
+    delete modifiers.width;
+    delete modifiers.height;
+  }
+  const keyMap = {
+    format: "f",
+    width: "w",
+    height: "h",
+    resize: "s",
+    quality: "q",
+    background: "b",
+    position: "pos"
+  };
+  for (const [rawKey, value] of Object.entries(modifiers)) {
     if (value === void 0 || value === null || value === "" || value === false) continue;
-    ops.push(`${key}_${value}`);
+    const key = keyMap[rawKey] ?? rawKey;
+    out.push(`${key}_${value}`);
   }
-  return ops.length ? ops.join(",") : "_";
+  return out.length ? out.join(",") : "_";
 };
-export const getImage = (src, { modifiers = {}, baseURL } = {}) => {
-  const root = (baseURL ?? "/_filer-ipx").replace(/\/+$/, "");
+export const getImage = (src, { modifiers = {}, baseURL = "/_filer-ipx" } = {}) => {
   const ops = operationsGenerator(
     modifiers
   );
-  const path = src.replace(/^\/+/, "");
-  return { url: `${root}/${ops}/${path}` };
+  return { url: joinURL(baseURL, ops, src.replace(/^\/+/, "")) };
 };
-export const validateDomains = false;
+export default () => ({
+  getImage,
+  validateDomains: false,
+  supportsAlias: false
+});

package/dist/runtime/server/drivers/fs.d.ts

@@ -0,0 +1,34 @@
+export interface FsDriverOptions {
+    /** Filesystem path used as the base for all keys. Required. */
+    base?: string;
+    /** Treat the storage as read-only; writes become no-ops. */
+    readOnly?: boolean;
+    /** Suppress `clear()`. */
+    noClear?: boolean;
+    /** Optional ignore filter applied during `getKeys`. */
+    ignore?: (path: string) => boolean;
+}
+export default function fsDriver(opts?: FsDriverOptions): {
+    name: string;
+    options: FsDriverOptions;
+    flags: {
+        maxDepth: boolean;
+    };
+    hasItem(key: string): boolean;
+    getItem(key: string): Promise<string | null>;
+    getItemRaw(key: string): Promise<Buffer<ArrayBufferLike> | null>;
+    getMeta(key: string): Promise<{
+        atime: Date | undefined;
+        mtime: Date | undefined;
+        size: number | undefined;
+        birthtime: Date | undefined;
+        ctime: Date | undefined;
+    }>;
+    setItem(key: string, value: string): Promise<void>;
+    setItemRaw(key: string, value: Buffer | Uint8Array): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    getKeys(_base?: string, topts?: {
+        maxDepth?: number;
+    }): Promise<string[]>;
+    clear(): Promise<void>;
+};

package/dist/runtime/server/drivers/fs.js

@@ -0,0 +1,106 @@
+import {
+  existsSync,
+  promises as fsp
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+const PATH_TRAVERSE_RE = /\.\.:|\.\.$/;
+const DRIVER_NAME = "nuxt-filer-fs";
+function driverError(message) {
+  return new Error(`[nuxt-filer] [${DRIVER_NAME}] ${message}`);
+}
+function ignoreNotfound(err) {
+  if (err.code === "ENOENT" || err.code === "EISDIR") return null;
+  throw err;
+}
+async function readdirSafe(dir) {
+  try {
+    return await fsp.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function readdirRecursive(dir, ignore, maxDepth) {
+  if (ignore && ignore(dir)) return [];
+  const entries = await readdirSafe(dir);
+  const files = [];
+  await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (maxDepth === void 0 || maxDepth > 0) {
+          const nested = await readdirRecursive(
+            entryPath,
+            ignore,
+            maxDepth === void 0 ? void 0 : maxDepth - 1
+          );
+          files.push(...nested.map((f) => entry.name + "/" + f));
+        }
+      } else if (!(ignore && ignore(entry.name))) {
+        files.push(entry.name);
+      }
+    })
+  );
+  return files;
+}
+export default function fsDriver(opts = {}) {
+  if (!opts.base) {
+    throw driverError("Missing required option `base`.");
+  }
+  const base = resolve(opts.base);
+  const r = (key) => {
+    if (PATH_TRAVERSE_RE.test(key)) {
+      throw driverError(
+        `Invalid key: ${JSON.stringify(key)}. It should not contain .. segments`
+      );
+    }
+    return join(base, key.replace(/:/g, "/"));
+  };
+  async function write(path, value) {
+    await fsp.mkdir(dirname(path), { recursive: true });
+    await fsp.writeFile(path, value);
+  }
+  return {
+    name: DRIVER_NAME,
+    options: opts,
+    flags: { maxDepth: true },
+    hasItem(key) {
+      return existsSync(r(key));
+    },
+    getItem(key) {
+      return fsp.readFile(r(key), "utf8").catch((err) => ignoreNotfound(err));
+    },
+    getItemRaw(key) {
+      return fsp.readFile(r(key)).catch((err) => ignoreNotfound(err));
+    },
+    async getMeta(key) {
+      const stat = await fsp.stat(r(key)).catch(() => ({}));
+      return {
+        atime: stat.atime,
+        mtime: stat.mtime,
+        size: stat.size,
+        birthtime: stat.birthtime,
+        ctime: stat.ctime
+      };
+    },
+    async setItem(key, value) {
+      if (opts.readOnly) return;
+      await write(r(key), value);
+    },
+    async setItemRaw(key, value) {
+      if (opts.readOnly) return;
+      await write(r(key), value);
+    },
+    async removeItem(key) {
+      if (opts.readOnly) return;
+      await fsp.unlink(r(key)).catch((err) => ignoreNotfound(err));
+    },
+    getKeys(_base, topts) {
+      return readdirRecursive(r("."), opts.ignore, topts?.maxDepth);
+    },
+    async clear() {
+      if (opts.readOnly || opts.noClear) return;
+      await fsp.rm(r("."), { recursive: true, force: true });
+    }
+  };
+}

package/dist/runtime/server/plugins/default-storage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mount the default filesystem-backed storage for nuxt-filer. We mount
+ * via a Nitro plugin rather than `nitroConfig.storage` so that our
+ * custom fs driver is bundled with the plugin and there is no runtime
+ * module resolution against the package's `dist/`.
+ */
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/default-storage.js

@@ -0,0 +1,7 @@
+import { defineNitroPlugin, useStorage } from "nitropack/runtime";
+import { storageName, storagePath } from "#nuxt-filer-options";
+import fsDriver from "../drivers/fs.js";
+export default defineNitroPlugin(() => {
+  const storage = useStorage();
+  storage.mount(storageName, fsDriver({ base: storagePath }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-filer",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "File storage module for Nuxt",
   "repository": {
     "type": "git",

package/src/runtime/image/provider.ts

@@ -1,4 +1,5 @@
 import type { ProviderGetImage } from '@nuxt/image';
+import { joinURL } from 'ufo';
 
 interface FilerProviderOptions {
   baseURL?: string;
@@ -7,27 +8,44 @@ interface FilerProviderOptions {
 const operationsGenerator = (
   modifiers: Record<string, string | number | boolean | undefined>
 ): string => {
-  const ops: string[] = [];
-  for (const [key, value] of Object.entries(modifiers)) {
+  const out: string[] = [];
+  // Match @nuxt/image's built-in IPX provider: width+height collapses to resize.
+  if (modifiers.width && modifiers.height) {
+    modifiers.resize = `${modifiers.width}x${modifiers.height}`;
+    delete modifiers.width;
+    delete modifiers.height;
+  }
+  const keyMap: Record<string, string> = {
+    format: 'f',
+    width: 'w',
+    height: 'h',
+    resize: 's',
+    quality: 'q',
+    background: 'b',
+    position: 'pos',
+  };
+  for (const [rawKey, value] of Object.entries(modifiers)) {
     if (value === undefined || value === null || value === '' || value === false) continue;
-    ops.push(`${key}_${value}`);
+    const key = keyMap[rawKey] ?? rawKey;
+    out.push(`${key}_${value}`);
   }
-  return ops.length ? ops.join(',') : '_';
+  return out.length ? out.join(',') : '_';
 };
 
 export const getImage: ProviderGetImage = (
   src: string,
-  { modifiers = {}, baseURL }: { modifiers?: Record<string, unknown>; baseURL?: string } = {},
-  // ctx is provided by @nuxt/image but unused here
+  { modifiers = {}, baseURL = '/_filer-ipx' }: { modifiers?: Record<string, unknown>; baseURL?: string } = {},
 ) => {
-  const root = (baseURL ?? '/_filer-ipx').replace(/\/+$/, '');
   const ops = operationsGenerator(
     modifiers as Record<string, string | number | boolean | undefined>
   );
-  const path = src.replace(/^\/+/, '');
-  return { url: `${root}/${ops}/${path}` };
+  return { url: joinURL(baseURL, ops, src.replace(/^\/+/, '')) };
 };
 
-export const validateDomains = false;
+export default () => ({
+  getImage,
+  validateDomains: false,
+  supportsAlias: false,
+});
 
 export type { FilerProviderOptions };

package/src/runtime/server/drivers/fs.ts

@@ -0,0 +1,156 @@
+import {
+  existsSync,
+  promises as fsp,
+  type Dirent,
+  type Stats,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+/**
+ * Drop-in replacement for unstorage's built-in `fs-lite` driver.
+ *
+ * `fs-lite` creates intermediate directories via a userspace `ensuredir`
+ * (recursive `existsSync` + non-recursive `mkdir`). In practice this is
+ * unreliable for first-time writes to a brand-new key path — we observed
+ * ENOENT on `writeFile` even though `ensuredir` should have run. The
+ * kernel's atomic `mkdir(..., { recursive: true })` is much more reliable
+ * across filesystems (including container-bound volumes).
+ *
+ * This driver mirrors the fs-lite public surface but always pre-creates
+ * the parent directory tree with a single recursive `mkdir` before any
+ * write, and tolerates missing files / dirs on reads.
+ *
+ * Implemented against unstorage's structural `Driver` contract; we avoid
+ * importing `defineDriver` so this stays decoupled from a specific
+ * unstorage major.
+ */
+
+const PATH_TRAVERSE_RE = /\.\.:|\.\.$/;
+const DRIVER_NAME = 'nuxt-filer-fs';
+
+export interface FsDriverOptions {
+  /** Filesystem path used as the base for all keys. Required. */
+  base?: string;
+  /** Treat the storage as read-only; writes become no-ops. */
+  readOnly?: boolean;
+  /** Suppress `clear()`. */
+  noClear?: boolean;
+  /** Optional ignore filter applied during `getKeys`. */
+  ignore?: (path: string) => boolean;
+}
+
+function driverError(message: string): Error {
+  return new Error(`[nuxt-filer] [${DRIVER_NAME}] ${message}`);
+}
+
+function ignoreNotfound<T>(err: NodeJS.ErrnoException): T | null {
+  if (err.code === 'ENOENT' || err.code === 'EISDIR') return null;
+  throw err;
+}
+
+async function readdirSafe(dir: string): Promise<Dirent[]> {
+  try {
+    return await fsp.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+async function readdirRecursive(
+  dir: string,
+  ignore: ((p: string) => boolean) | undefined,
+  maxDepth: number | undefined,
+): Promise<string[]> {
+  if (ignore && ignore(dir)) return [];
+  const entries = await readdirSafe(dir);
+  const files: string[] = [];
+  await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (maxDepth === undefined || maxDepth > 0) {
+          const nested = await readdirRecursive(
+            entryPath,
+            ignore,
+            maxDepth === undefined ? undefined : maxDepth - 1,
+          );
+          files.push(...nested.map((f) => entry.name + '/' + f));
+        }
+      } else if (!(ignore && ignore(entry.name))) {
+        files.push(entry.name);
+      }
+    }),
+  );
+  return files;
+}
+
+export default function fsDriver(opts: FsDriverOptions = {}) {
+  if (!opts.base) {
+    throw driverError('Missing required option `base`.');
+  }
+  const base = resolve(opts.base);
+
+  const r = (key: string) => {
+    if (PATH_TRAVERSE_RE.test(key)) {
+      throw driverError(
+        `Invalid key: ${JSON.stringify(key)}. It should not contain .. segments`,
+      );
+    }
+    return join(base, key.replace(/:/g, '/'));
+  };
+
+  async function write(path: string, value: string | Buffer | Uint8Array) {
+    await fsp.mkdir(dirname(path), { recursive: true });
+    await fsp.writeFile(path, value);
+  }
+
+  return {
+    name: DRIVER_NAME,
+    options: opts,
+    flags: { maxDepth: true },
+
+    hasItem(key: string) {
+      return existsSync(r(key));
+    },
+    getItem(key: string) {
+      return fsp
+        .readFile(r(key), 'utf8')
+        .catch((err) => ignoreNotfound<string>(err));
+    },
+    getItemRaw(key: string) {
+      return fsp
+        .readFile(r(key))
+        .catch((err) => ignoreNotfound<Buffer>(err));
+    },
+    async getMeta(key: string) {
+      const stat = (await fsp.stat(r(key)).catch(() => ({}))) as Partial<Stats>;
+      return {
+        atime: stat.atime,
+        mtime: stat.mtime,
+        size: stat.size,
+        birthtime: stat.birthtime,
+        ctime: stat.ctime,
+      };
+    },
+    async setItem(key: string, value: string) {
+      if (opts.readOnly) return;
+      await write(r(key), value);
+    },
+    async setItemRaw(key: string, value: Buffer | Uint8Array) {
+      if (opts.readOnly) return;
+      await write(r(key), value);
+    },
+    async removeItem(key: string) {
+      if (opts.readOnly) return;
+      await fsp.unlink(r(key)).catch((err) => ignoreNotfound(err));
+    },
+    getKeys(_base?: string, topts?: { maxDepth?: number }) {
+      return readdirRecursive(r('.'), opts.ignore, topts?.maxDepth);
+    },
+    async clear() {
+      if (opts.readOnly || opts.noClear) return;
+      await fsp.rm(r('.'), { recursive: true, force: true });
+    },
+  };
+}

package/src/runtime/server/plugins/default-storage.ts

@@ -0,0 +1,15 @@
+import { defineNitroPlugin, useStorage } from 'nitropack/runtime';
+// @ts-expect-error virtual module
+import { storageName, storagePath } from '#nuxt-filer-options';
+import fsDriver from '../drivers/fs';
+
+/**
+ * Mount the default filesystem-backed storage for nuxt-filer. We mount
+ * via a Nitro plugin rather than `nitroConfig.storage` so that our
+ * custom fs driver is bundled with the plugin and there is no runtime
+ * module resolution against the package's `dist/`.
+ */
+export default defineNitroPlugin(() => {
+  const storage = useStorage();
+  storage.mount(storageName, fsDriver({ base: storagePath }));
+});