nuxt-file-storage 0.2.9 → 0.3.1-beta.1

package/README.md

@@ -2,13 +2,14 @@
 
 # Nuxt File Storage
 
-[![Visits Badge](https://badges.pufler.dev/visits/nyllre/nuxt-file-storage)](https://badges.pufler.dev)
+<!-- [![Visits Badge](https://badges.pufler.dev/visits/nyllre/nuxt-file-storage)](https://badges.pufler.dev) -->
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![nuxt.care health](https://img.shields.io/endpoint?url=https://nuxt.care/api/badge/nuxt-file-storage&style=flat&colorA=18181B&colorB=28CF8D)](https://nuxt.care/?search=nuxt-file-storage)
 [![License][license-src]][license-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
-Easy solution to store files in your nuxt apps. Be able to upload files from the frontend and recieve them from the backend to then save the files in your project.
+Easy solution to store files in your nuxt apps. Be able to upload files from the frontend and receive them from the backend to then save the files in your project.
 
 -  [✨ &nbsp;Release Notes](/CHANGELOG.md)
 -  [🏀 Online playground](https://stackblitz.com/github/NyllRE/nuxt-file-storage?file=playground%2Fapp.vue)
@@ -128,13 +129,15 @@ You have to create a new instance of `useFileStorage` for each input field
 	} = useFileStorage()                                               ← | 2 |
 </script>
 ```
-by calling a new `useFileStorage` instance you seperate the internal logic between the inputs
+by calling a new `useFileStorage` instance you separate the internal logic between the inputs
 
 ### Handling files in the backend
-using Nitro Server Engine, we will make an api route that recieves the files and stores them in the folder `userFiles`
+using Nitro Server Engine, we will make an api route that receives the files and stores them in the folder `userFiles`
 ```ts
+import { ServerFile } from "nuxt-file-storage";
+
 export default defineEventHandler(async (event) => {
-	const { files } = await readBody<{ files: File[] }>(event)
+	const { files } = await readBody<{ files: ServerFile[] }>(event)
 
 	for ( const file of files ) {
 		await storeFileLocally(
@@ -149,13 +152,20 @@ export default defineEventHandler(async (event) => {
 		const { binaryString, ext } = parseDataUrl(file.content)
 	}
 
-	return 'success!'
-})
+	// Deleting Files
+	await deleteFile('requiredFile.txt', '/userFiles')
 
-interface File {
-	name: string
-	content: string
-}
+	// Get file path
+	return await getFileLocally('requiredFile.txt', '/userFiles')
+	// returns: {AbsolutePath}/userFiles/requiredFile.txt
+
+	// Return a NodeStream of the file
+	// uses getFileLocally internally
+	return await retrieveFileLocally(event, 'requiredFile.txt', '/userFiles')
+
+	// Get all files in a folder
+	return await getFilesLocally('/userFiles')
+})
 ```
 
 And that's it! Now you can store any file in your nuxt project from the user ✨

package/dist/module.d.mts

@@ -1,24 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleOptions } from '../dist/runtime/types.js';
+export * from '../dist/runtime/types.js';
 
-interface ServerFile {
-	name: string
-	content: string
-	size: string
-	type: string
-	lastModified: string
-}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-interface ClientFile extends Blob {
-	content: string | ArrayBuffer | null | undefined
-	name: string
-	lastModified: number
-}
-
-interface ModuleOptions {
-	mount: string
-	version: string
-}
-
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
-
-export { type ClientFile, type ModuleOptions, type ServerFile, _default as default };
+export { _default as default };

package/dist/module.json

@@ -1,5 +1,9 @@
 {
   "name": "nuxt-file-storage",
   "configKey": "fileStorage",
-  "version": "0.2.9"
+  "version": "0.3.1-beta.1",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
 }

package/dist/module.mjs

@@ -1,9 +1,7 @@
-import { defineNuxtModule, logger, createResolver, addImportsDir, addServerScanDir } from '@nuxt/kit';
-import defu from 'defu';
+import { defineNuxtModule, createResolver, logger, addImportsDir, addServerScanDir, addTemplate } from '@nuxt/kit';
+import { defu } from 'defu';
 
-const version = "0.2.9";
-
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-file-storage",
     configKey: "fileStorage"
@@ -14,26 +12,35 @@ const module = defineNuxtModule({
   // 	version: '0.0.0',
   // },
   setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
     const config = nuxt.options.runtimeConfig;
     config.public.fileStorage = defu(config.public.fileStorage, {
       ...options
     });
-    if (nuxt.options.dev) {
-      //! I couldn't find a way to detect new updates to warn one time so it will warn every time the server runs again, if you know how to warn about a breaking change only the first run after an update feel free to open a new pull request
-      const previousVersion = config.public.fileStorage?.version;
-      if (!previousVersion || previousVersion !== version) {
-        logger.warn(
-          `There is a breaking change in the \`storeFileLocally\` method, link to changelog:
-https://github.com/NyllRE/nuxt-file-storage/releases/tag/v${version}
-`
-        );
-        config.public.fileStorage.version = version;
-      }
-    }
-    const resolve = createResolver(import.meta.url).resolve;
+    logger.ready(`Nuxt File Storage has mounted successfully`);
+    nuxt.options.alias["#file-storage"] = resolve("./runtime");
     addImportsDir(resolve("runtime/composables"));
     addServerScanDir(resolve("./runtime/server"));
+    addTemplate({
+      filename: "types/nuxt-file-storage.d.ts",
+      getContents: () => [
+        "declare module '#file-storage' {",
+        `  const ServerFile: typeof import('${resolve("./runtime/types")}').ServerFile`,
+        `  const ClientFile: typeof import('${resolve("./runtime/types")}').ClientFile`,
+        "}",
+        "",
+        "declare global {",
+        `  type ServerFile = import('${resolve("./runtime/types")}').ServerFile`,
+        `  type ClientFile = import('${resolve("./runtime/types")}').ClientFile`,
+        "}",
+        "",
+        "export {}"
+      ].join("\n")
+    });
+    nuxt.hook("prepare:types", async (options2) => {
+      options2.references.push({ path: resolve(nuxt.options.buildDir, "types/nuxt-file-storage.d.ts") });
+    });
   }
 });
 
-export { module as default };
+export { module$1 as default };

package/dist/runtime/composables/useFileStorage.d.ts

@@ -2,21 +2,8 @@ type Options = {
     clearOldFiles: boolean;
 };
 export default function (options?: Options): {
-    files: import("vue").Ref<{
-        content: string | {
-            readonly byteLength: number;
-            slice: (begin: number, end?: number | undefined) => ArrayBuffer;
-            readonly [Symbol.toStringTag]: string;
-        } | null | undefined;
-        name: string;
-        lastModified: number;
-        readonly size: number;
-        readonly type: string;
-        arrayBuffer: () => Promise<ArrayBuffer>;
-        slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
-        stream: () => ReadableStream<Uint8Array>;
-        text: () => Promise<string>;
-    }[]>;
+    files: import("vue").Ref<any, any>;
     handleFileInput: (event: any) => Promise<void>;
+    clearFiles: () => void;
 };
 export {};

package/dist/runtime/composables/{useFileStorage.mjs → useFileStorage.js}

@@ -21,9 +21,12 @@ export default function(options = { clearOldFiles: true }) {
       reader.readAsDataURL(file);
     });
   };
+  const clearFiles = () => {
+    files.value.splice(0, files.value.length);
+  };
   const handleFileInput = async (event) => {
     if (options.clearOldFiles) {
-      files.value.splice(0, files.value.length);
+      clearFiles();
     }
     const promises = [];
     for (const file of event.target.files) {
@@ -33,6 +36,7 @@ export default function(options = { clearOldFiles: true }) {
   };
   return {
     files,
-    handleFileInput
+    handleFileInput,
+    clearFiles
   };
 }

package/dist/runtime/server/utils/path-safety.d.ts

@@ -0,0 +1,9 @@
+export declare const normalizeRelative: (p: string) => string;
+export declare const isSafeBasename: (name: string) => boolean;
+export declare const ensureSafeBasename: (name: string) => string;
+export declare const containsPathTraversal: (p: string) => boolean;
+/**
+ * Resolve a target path relative to a mount and ensure it cannot escape the mount.
+ * Throws on any suspicious input (path traversal, symlink escape, absolute outside mount).
+ */
+export declare const resolveAndEnsureInside: (mount: string, ...parts: string[]) => Promise<string>;

package/dist/runtime/server/utils/path-safety.js

@@ -0,0 +1,57 @@
+import path from "path";
+import { realpath, stat } from "fs/promises";
+import { createError } from "#imports";
+export const normalizeRelative = (p) => {
+  if (!p) return "";
+  return p.replace(/^[/\\]+/, "").replace(/\\/g, "/");
+};
+export const isSafeBasename = (name) => {
+  if (!name) return false;
+  if (name !== path.basename(name)) return false;
+  if (name.includes("\0")) return false;
+  if (name === "." || name === "..") return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  if (name.split(/[/\\]+/).includes("..")) return false;
+  return true;
+};
+export const ensureSafeBasename = (name) => {
+  if (!isSafeBasename(name)) throw new Error("Unsafe filename");
+  return name;
+};
+export const containsPathTraversal = (p) => {
+  if (!p) return false;
+  if (/^([\\/]|^)?\.\.([\\/]|$)?/.test(p) || /(^|[\\/])\.\.($|[\\/])/.test(p)) return true;
+  const normalized = path.normalize(p);
+  const parts = normalized.split(/[/\\]+/);
+  return parts.includes("..");
+};
+export const resolveAndEnsureInside = async (mount, ...parts) => {
+  if (!mount) throw new Error("Mount path must be provided");
+  const mountResolved = path.resolve(mount);
+  const cleanedParts = parts.map((p) => p.replace(/^[/\\]+/, ""));
+  const targetResolved = path.resolve(mountResolved, ...cleanedParts);
+  const relative = path.relative(mountResolved, targetResolved);
+  if (relative === "" || !relative.startsWith(".." + path.sep) && relative !== "..") {
+    let cur = targetResolved;
+    while (cur) {
+      try {
+        await stat(cur);
+        break;
+      } catch (error) {
+        const parent = path.dirname(cur);
+        if (parent === cur) break;
+        cur = parent;
+      }
+    }
+    const mountReal = await realpath(mountResolved);
+    const curReal = await realpath(cur);
+    if (!curReal.startsWith(mountReal)) {
+      throw new Error("Resolved path escapes configured mount (symlink detected)");
+    }
+    return targetResolved;
+  }
+  throw createError({
+    statusCode: 400,
+    statusMessage: "Resolved path is outside of configured mount"
+  });
+};

package/dist/runtime/server/utils/storage.d.ts

@@ -1,25 +1,68 @@
-/// <reference types="node" />
-import type { ServerFile } from '../../../types';
+import type { ServerFile } from '../../types.js';
+import type { H3Event, EventHandlerRequest } from 'h3';
 /**
- * #### Will store the file in the specified directory
+ * @description Will store the file in the specified directory
+ * @param file provide the file object
+ * @param fileNameOrIdLength you can pass a string or a number, if you enter a string it will be the file name, if you enter a number it will generate a unique ID
+ * @param filelocation provide the folder you wish to locate the file in
  * @returns file name: `${filename}`.`${fileExtension}`
- * @prop `file`: provide the file object
- * @prop `fileNameOrIdLength`: you can pass a string or a number, if you enter a string it will be the file name, if you enter a number it will generate a unique ID
- * @prop `filelocation`: provide the folder you wish to locate the file in
+ *
+ *
+ * [Documentation](https://github.com/NyllRE/nuxt-file-storage#handling-files-in-the-backend)
+ *
+ *
+ * @example
+ * ```ts
+ * import type { ServerFile } from "nuxt-file-storage";
+ *
+ * export default defineEventHandler(async (event) => {
+ * 	const { file } = await readBody<{ file: ServerFile }>(event);
+ * 	await storeFileLocally( file, 8, '/userFiles' );
+ * })
+ * ```
  */
 export declare const storeFileLocally: (file: ServerFile, fileNameOrIdLength: string | number, filelocation?: string) => Promise<string>;
 /**
- *
- * @param `filename`: the name of the file you want to delete
- * @param `filelocation`: the folder where the file is located, if it is in the root folder you can leave it empty, if it is in a subfolder you can pass the name of the subfolder with a preceding slash: `/subfolder`
+ * @description Get file path in the specified directory
+ * @param filename provide the file name (return of storeFileLocally)
+ * @param filelocation provide the folder you wish to locate the file in
+ * @returns file path: `${config.fileStorage.mount}/${filelocation}/${filename}`
+ */
+export declare const getFileLocally: (filename: string, filelocation?: string) => string;
+/**
+ * @description Get all files in the specified directory
+ * @param filelocation provide the folder you wish to locate the file in
+ * @returns all files in filelocation: `${config.fileStorage.mount}/${filelocation}`
+ */
+export declare const getFilesLocally: (filelocation?: string) => Promise<string[]>;
+/**
+ * @param filename the name of the file you want to delete
+ * @param filelocation the folder where the file is located, if it is in the root folder you can leave it empty, if it is in a subfolder you can pass the name of the subfolder with a preceding slash: `/subfolder`
+ * @example
+ * ```ts
+ * await deleteFile('/userFiles', 'requiredFile.txt')
+ * ```
  */
 export declare const deleteFile: (filename: string, filelocation?: string) => Promise<void>;
 /**
-Parses a data URL and returns an object with the binary data and the file extension.
-@param {string} file - The data URL
-@returns {{ binaryString: Buffer, ext: string }} - An object with the binary data and the file extension
+ * @description Parses a data URL and returns an object with the binary data and the file extension.
+ * @param {string} file - The data URL
+ * @returns {{binaryString: Buffer, ext: string}} An object with the binary data - file extension
+ *
+ * @example
+ * ```ts
+ *   const { binaryString, ext } = parseDataUrl(file.content)
+ * ```
  */
 export declare const parseDataUrl: (file: string) => {
     binaryString: Buffer;
     ext: string;
 };
+/**
+ * Retrieve a file as a readable stream from local storage
+ * @param event H3 event to set response headers
+ * @param filename name of the file to retrieve
+ * @param filelocation folder where the file is located
+ * @returns Readable stream of the file
+ */
+export declare const retrieveFileLocally: (event: H3Event<EventHandlerRequest>, filename: string, filelocation?: string) => Promise<NodeJS.ReadableStream>;

package/dist/runtime/server/utils/storage.js

@@ -0,0 +1,142 @@
+import { writeFile, rm, mkdir, readdir } from "fs/promises";
+import path from "path";
+import {
+  normalizeRelative,
+  ensureSafeBasename,
+  resolveAndEnsureInside
+} from "./path-safety.js";
+import { createError, useRuntimeConfig } from "#imports";
+import { createReadStream, promises as fsPromises } from "fs";
+const getMount = () => {
+  try {
+    return useRuntimeConfig().public.fileStorage.mount;
+  } catch (err) {
+    return process.env.FILE_STORAGE_MOUNT || process.env.NUXT_FILE_STORAGE_MOUNT;
+  }
+};
+export const storeFileLocally = async (file, fileNameOrIdLength, filelocation = "") => {
+  const { binaryString, ext } = parseDataUrl(file.content);
+  const location = getMount();
+  if (!location) throw new Error("fileStorage.mount is not configured");
+  const nameStr = file.name.toString();
+  const originalExt = nameStr.includes(".") ? nameStr.split(".").pop() : ext;
+  const safeExt = (originalExt || ext).replace(/[^a-zA-Z0-9]/g, "") || ext;
+  let filename;
+  if (typeof fileNameOrIdLength === "number") {
+    filename = `${generateRandomId(fileNameOrIdLength)}.${safeExt}`;
+  } else {
+    ensureSafeBasename(fileNameOrIdLength);
+    const extensionFromFileName = fileNameOrIdLength.split(".").pop();
+    if (!fileNameOrIdLength.includes(".")) {
+      filename = `${fileNameOrIdLength}.${safeExt}`;
+    } else if (extensionFromFileName === safeExt) {
+      filename = fileNameOrIdLength;
+    } else {
+      console.warn(
+        `[nuxt-file-storage] The provided filename "${fileNameOrIdLength}" does not have the expected extension ".${safeExt}". The correct extension will be appended.`
+      );
+      filename = `${fileNameOrIdLength.split(".").slice(0, -1).join(".")}.${safeExt}`;
+    }
+  }
+  const normalizedFilelocation = normalizeRelative(filelocation);
+  const dirPath = await resolveAndEnsureInside(location, normalizedFilelocation);
+  try {
+    await mkdir(dirPath, { recursive: true });
+  } catch (err) {
+    if (err?.code === "EEXIST") {
+      throw new Error(
+        `[nuxt-file-storage] EEXIST: A file already exists at "${dirPath}" where a directory was expected. This typically happens when a file was accidentally created at a path meant for a folder. Please remove or rename the conflicting file.`
+      );
+    } else if (err?.code === "ENOTDIR") {
+      throw new Error(
+        `[nuxt-file-storage] ENOTDIR: Cannot create directory "${dirPath}" because a parent path component is a file, not a directory. Check if any part of the path "${normalizedFilelocation}" exists as a file instead of a folder. Please remove or rename the conflicting file.`
+      );
+    }
+    throw err;
+  }
+  const targetPath = await resolveAndEnsureInside(location, normalizedFilelocation, filename);
+  await writeFile(targetPath, binaryString, {
+    flag: "w"
+  });
+  return filename;
+};
+export const getFileLocally = (filename, filelocation = "") => {
+  const location = getMount();
+  if (!location) throw new Error("fileStorage.mount is not configured");
+  ensureSafeBasename(filename);
+  const normalizedFilelocation = normalizeRelative(filelocation);
+  const resolved = path.resolve(location, normalizedFilelocation, filename);
+  const mountResolved = path.resolve(location);
+  const relative = path.relative(mountResolved, resolved);
+  if (relative === "" || !relative.startsWith(".." + path.sep) && relative !== "..") {
+    return resolved;
+  }
+  throw createError({
+    statusCode: 400,
+    statusMessage: "Resolved path is outside of configured mount"
+  });
+};
+export const getFilesLocally = async (filelocation = "") => {
+  const location = getMount();
+  if (!location) return [];
+  const normalizedFilelocation = normalizeRelative(filelocation);
+  const dirPath = await resolveAndEnsureInside(location, normalizedFilelocation);
+  return await readdir(dirPath).catch(() => []);
+};
+export const deleteFile = async (filename, filelocation = "") => {
+  const location = getMount();
+  if (!location) throw new Error("fileStorage.mount is not configured");
+  ensureSafeBasename(filename);
+  const normalizedFilelocation = normalizeRelative(filelocation);
+  const targetPath = await resolveAndEnsureInside(location, normalizedFilelocation, filename);
+  await rm(targetPath);
+};
+const generateRandomId = (length) => {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let randomId = "";
+  for (let i = 0; i < length; i++) {
+    randomId += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return randomId;
+};
+export const parseDataUrl = (file) => {
+  const arr = file.split(",");
+  const mimeMatch = arr[0].match(/:(.*?);/);
+  if (!mimeMatch) {
+    throw new Error("Invalid data URL");
+  }
+  const mime = mimeMatch[1];
+  const base64String = arr[1];
+  const binaryString = Buffer.from(base64String, "base64");
+  const ext = mime.split("/")[1];
+  return { binaryString, ext };
+};
+export const retrieveFileLocally = async (event, filename, filelocation = "") => {
+  const filePath = getFileLocally(filename, filelocation);
+  let stats;
+  try {
+    stats = await fsPromises.stat(filePath);
+    if (!stats.isFile()) {
+      throw createError({ statusCode: 404, statusMessage: "Not Found" });
+    }
+  } catch (err) {
+    throw createError({ statusCode: 404, statusMessage: "Not Found" });
+  }
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  const mimeMap = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    pdf: "application/pdf",
+    txt: "text/plain",
+    html: "text/html",
+    json: "application/json"
+  };
+  const contentType = mimeMap[ext] || "application/octet-stream";
+  event.node.res.setHeader("Content-Type", contentType);
+  event.node.res.setHeader("Content-Length", String(stats.size));
+  event.node.res.setHeader("Content-Disposition", `inline; filename="${path.basename(filePath)}"`);
+  return createReadStream(filePath);
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,23 @@
+export interface ServerFile {
+    name: string;
+    content: string;
+    size: string;
+    type: string;
+    lastModified: string;
+}
+export interface ClientFile extends Blob {
+    content: string | ArrayBuffer | null | undefined;
+    name: string;
+    lastModified: number;
+}
+export interface ModuleOptions {
+    mount: string;
+    version: string;
+}
+/**
+ * @description Augment the '#imports' module to include useRuntimeConfig
+ * this is only needed because this package is consumed as a module
+ */
+declare module '#imports' {
+    function useRuntimeConfig(): any;
+}

package/dist/types.d.mts

@@ -1,16 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
 
-import type { ModuleOptions } from './module.js'
+import type { default as Module } from './module.mjs'
 
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-declare module '@nuxt/schema' {
-  interface NuxtConfig { ['fileStorage']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['fileStorage']?: ModuleOptions }
-}
+export { default } from './module.mjs'
 
-declare module 'nuxt/schema' {
-  interface NuxtConfig { ['fileStorage']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['fileStorage']?: ModuleOptions }
-}
-
-
-export type { ClientFile, ModuleOptions, ServerFile, default } from './module.js'
+export * from '../dist/runtime/types.js'

package/package.json

@@ -1,46 +1,50 @@
 {
-  "name": "nuxt-file-storage",
-  "version": "0.2.9",
-  "description": "Easy solution to store files in your nuxt apps. Be able to upload files from the frontend and recieve them from the backend to then save the files in your project.",
-  "repository": "NyllRE/nuxt-file-storage",
-  "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/types.d.ts",
-      "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs"
-    }
-  },
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "prepack": "nuxt-module-build build",
-    "dev": "nuxi dev playground",
-    "dev:build": "nuxi build playground",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
-    "lint": "eslint .",
-    "test": "vitest run",
-    "test:watch": "vitest watch"
-  },
-  "dependencies": {
-    "@nuxt/kit": "^3.9.3",
-    "defu": "^6.1.4"
-  },
-  "devDependencies": {
-    "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^0.2.0",
-    "@nuxt/module-builder": "^0.8.3",
-    "@nuxt/schema": "^3.9.3",
-    "@nuxt/test-utils": "^3.9.0",
-    "@types/node": "^20.11.5",
-    "changelogen": "^0.5.5",
-    "eslint": "^8.56.0",
-    "nuxt": "^3.9.3",
-    "vitest": "^1.0.0"
-  }
-}
+	"name": "nuxt-file-storage",
+	"version": "0.3.1-beta.1",
+	"description": "Easy solution to store files in your nuxt apps. Be able to upload files from the frontend and recieve them from the backend to then save the files in your project.",
+	"repository": "NyllRE/nuxt-file-storage",
+	"license": "MIT",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/types.d.mts",
+			"import": "./dist/module.mjs"
+		}
+	},
+	"main": "./dist/module.mjs",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"prepack": "nuxt-module-build build",
+		"dev": "nuxi dev playground",
+		"dev:build": "nuxi build playground",
+		"dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+		"bump": "npm version patch -m \"chore(release): %s\"",
+		"release": "npm run lint && npm run bump && npm run prepack && changelogen && git push --follow-tags && npm publish",
+		"lint": "eslint .",
+		"test": "vitest run",
+		"test:watch": "vitest watch"
+	},
+	"dependencies": {
+		"@nuxt/kit": "^4.3.0",
+		"defu": "^6.1.4"
+	},
+	"devDependencies": {
+		"@nuxt/devtools": "^3.1.1",
+		"@nuxt/eslint-config": "^1.13.0",
+		"@nuxt/module-builder": "^1.0.2",
+		"@nuxt/schema": "^4.3.0",
+		"@nuxt/test-utils": "^3.23.0",
+		"@types/node": "^20.17.19",
+		"@vitest/ui": "4.0.16",
+		"@vue/test-utils": "^2.4.6",
+		"changelogen": "^0.5.7",
+		"eslint": "^8.57.1",
+		"happy-dom": "^20.0.11",
+		"nuxt": "^4.3.0",
+		"playwright-core": "^1.57.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.16"
+	}
+}

package/dist/module.cjs

@@ -1,5 +0,0 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
-}
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -1,24 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-
-interface ServerFile {
-	name: string
-	content: string
-	size: string
-	type: string
-	lastModified: string
-}
-
-interface ClientFile extends Blob {
-	content: string | ArrayBuffer | null | undefined
-	name: string
-	lastModified: number
-}
-
-interface ModuleOptions {
-	mount: string
-	version: string
-}
-
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
-
-export { type ClientFile, type ModuleOptions, type ServerFile, _default as default };

package/dist/runtime/server/utils/storage.mjs

@@ -1,37 +0,0 @@
-import { writeFile, rm, mkdir } from "fs/promises";
-import { useRuntimeConfig } from "#imports";
-export const storeFileLocally = async (file, fileNameOrIdLength, filelocation = "") => {
-  const { binaryString, ext } = parseDataUrl(file.content);
-  const location = useRuntimeConfig().public.fileStorage.mount;
-  const originalExt = file.name.toString().split(".").pop() || ext;
-  const filename = typeof fileNameOrIdLength == "number" ? `${generateRandomId(fileNameOrIdLength)}.${originalExt}` : `${fileNameOrIdLength}.${originalExt}`;
-  await mkdir(`${location}${filelocation}`, { recursive: true });
-  await writeFile(`${location}${filelocation}/${filename}`, binaryString, {
-    flag: "w"
-  });
-  return filename;
-};
-export const deleteFile = async (filename, filelocation = "") => {
-  const location = useRuntimeConfig().public.fileStorage.mount;
-  await rm(`${location}${filelocation}/${filename}`);
-};
-const generateRandomId = (length) => {
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let randomId = "";
-  for (let i = 0; i < length; i++) {
-    randomId += characters.charAt(Math.floor(Math.random() * characters.length));
-  }
-  return randomId;
-};
-export const parseDataUrl = (file) => {
-  const arr = file.split(",");
-  const mimeMatch = arr[0].match(/:(.*?);/);
-  if (!mimeMatch) {
-    throw new Error("Invalid data URL");
-  }
-  const mime = mimeMatch[1];
-  const base64String = arr[1];
-  const binaryString = Buffer.from(base64String, "base64");
-  const ext = mime.split("/")[1];
-  return { binaryString, ext };
-};

package/dist/types.d.ts

@@ -1,16 +0,0 @@
-
-import type { ModuleOptions } from './module'
-
-
-declare module '@nuxt/schema' {
-  interface NuxtConfig { ['fileStorage']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['fileStorage']?: ModuleOptions }
-}
-
-declare module 'nuxt/schema' {
-  interface NuxtConfig { ['fileStorage']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['fileStorage']?: ModuleOptions }
-}
-
-
-export type { ClientFile, ModuleOptions, ServerFile, default } from './module'