nuxt-files-sdk 0.1.0 → 0.2.0

package/dist/devtools/paths.js

@@ -0,0 +1,8 @@
+//#region src/devtools/paths.ts
+const FILES_DEVTOOLS_PATH = "/__nuxt-files-sdk/";
+const FILES_SNAPSHOT_PATH = "/__nuxt-files-api/snapshot";
+const FILES_GATEWAY_PATH = "/__nuxt-files-api/files";
+const FILES_TOKEN_PATH = "/__nuxt-files-api/token";
+const FILES_DEVTOOLS_MAX_UPLOAD_SIZE = 10485760;
+//#endregion
+export { FILES_DEVTOOLS_MAX_UPLOAD_SIZE, FILES_DEVTOOLS_PATH, FILES_GATEWAY_PATH, FILES_SNAPSHOT_PATH, FILES_TOKEN_PATH };

package/dist/devtools/snapshot.d.ts

@@ -1,4 +1,6 @@
+import { DependencyDiagnostic } from "../integration/diagnostics.js";
 import { FilesDevtoolsDiagnostic } from "./diagnostics.js";
+import { RequestEvent } from "@nuxt/schema";
 //#region src/devtools/snapshot.d.ts
 export interface FilesDevtoolsSnapshot {
   storages: Array<{
@@ -8,19 +10,8 @@ export interface FilesDevtoolsSnapshot {
     initialized: boolean;
   }>;
   diagnostics: FilesDevtoolsDiagnostic[];
+  dependencies: DependencyDiagnostic[];
 }
-export declare const FILES_DEVTOOLS_PATH = "/__nuxt-files-sdk/";
-export declare const FILES_SNAPSHOT_PATH = "/__nuxt-files-sdk/snapshot";
-export declare const FILES_GATEWAY_PATH = "/__nuxt-files-sdk/files";
-export declare const FILES_TOKEN_PATH = "/__nuxt-files-sdk/token";
-export declare const FILES_DEVTOOLS_MAX_UPLOAD_SIZE: number;
-declare function _default(event: {
-  node: {
-    req: {
-      headers: Headers;
-    };
-  };
-}, secret: string): Promise<Response>;
+declare function _default(event: RequestEvent, secret: string): Promise<Response>;
 //#endregion
-export { _default as default };
-//# sourceMappingURL=snapshot.d.ts.map
+export { _default as default };

package/dist/devtools/snapshot.js

@@ -2,13 +2,8 @@ import { inspectFiles } from "../runtime/internal.js";
 import { authorizeFilesDevtoolsRequest } from "./auth.js";
 import { createFilesDevtoolsDiagnostic } from "./diagnostics.js";
 //#region src/devtools/snapshot.ts
-const FILES_DEVTOOLS_PATH = "/__nuxt-files-sdk/";
-const FILES_SNAPSHOT_PATH = `${FILES_DEVTOOLS_PATH}snapshot`;
-const FILES_GATEWAY_PATH = `${FILES_DEVTOOLS_PATH}files`;
-const FILES_TOKEN_PATH = `${FILES_DEVTOOLS_PATH}token`;
-const FILES_DEVTOOLS_MAX_UPLOAD_SIZE = 10485760;
 var snapshot_default = async (event, secret) => {
-	if (!await authorizeFilesDevtoolsRequest(event.node.req, secret)) return new Response(null, { status: 401 });
+	if (!await authorizeFilesDevtoolsRequest(event.req, secret)) return new Response(null, { status: 401 });
 	const snapshot = inspectFiles();
 	return Response.json({
 		...snapshot,
@@ -16,6 +11,4 @@ var snapshot_default = async (event, secret) => {
 	});
 };
 //#endregion
-export { FILES_DEVTOOLS_MAX_UPLOAD_SIZE, FILES_DEVTOOLS_PATH, FILES_GATEWAY_PATH, FILES_SNAPSHOT_PATH, FILES_TOKEN_PATH, snapshot_default as default };
-
-//# sourceMappingURL=snapshot.js.map
+export { snapshot_default as default };

package/dist/devtools/token.d.ts

@@ -10,5 +10,4 @@ declare function _default(event: {
   };
 }, secret: string, authorize: (token: string) => Promise<void>): Promise<Response>;
 //#endregion
-export { _default as default };
-//# sourceMappingURL=token.d.ts.map
+export { _default as default };

package/dist/devtools/token.js

@@ -13,5 +13,3 @@ var token_default = async (event, secret, authorize) => {
 };
 //#endregion
 export { token_default as default };
-
-//# sourceMappingURL=token.js.map

package/dist/integration/capabilities.js

@@ -0,0 +1,17 @@
+//#region src/integration/capabilities.ts
+/** Public API selection is evidence of an adapter, not a promise of arbitrary builder features. */
+const filesBuilderCapabilities = (api) => {
+	const nitro = api === "nitro2" || api === "nitro3";
+	return {
+		runtime: true,
+		gateway: nitro,
+		devtools: nitro,
+		nitroHooks: nitro,
+		experimental: !nitro
+	};
+};
+const requireFilesGateway = (enabled, available) => {
+	if (enabled && !available) throw new Error("[nuxt-files-sdk:gateway-unavailable] The selected server builder cannot mount Files Gateway routes.");
+};
+//#endregion
+export { filesBuilderCapabilities, requireFilesGateway };

package/dist/integration/dependencies.d.ts

@@ -0,0 +1,12 @@
+import "../runtime/normalize.js";
+//#region src/integration/dependencies.d.ts
+export interface DependencyRequirement {
+  storage?: string;
+  subpath: string;
+  dependency: string;
+  necessity: 'required' | 'conditional' | 'unknown';
+  stage: 'import' | 'construction' | 'operation';
+  reason: string;
+  conditions?: string[];
+}
+//#endregion

package/dist/integration/dependencies.js

@@ -0,0 +1,67 @@
+//#region src/integration/dependencies.ts
+const aws = [
+	"@aws-sdk/client-s3",
+	"@aws-sdk/s3-presigned-post",
+	"@aws-sdk/s3-request-presigner"
+];
+const unknownValue = Symbol("runtime value");
+const field = (object, key) => {
+	if (typeof object === "function") return unknownValue;
+	if (!object || typeof object !== "object") return void 0;
+	for (let current = object; current; current = Object.getPrototypeOf(current)) {
+		const descriptor = Object.getOwnPropertyDescriptor(current, key);
+		if (descriptor) return "value" in descriptor ? descriptor.value : unknownValue;
+	}
+};
+/** Pure structural analysis: never calls config resolvers, clients, factories or credentials. */
+const storageDependencies = (entry, target, imports) => {
+	const adapter = entry.storage.adapter;
+	if (typeof adapter !== "string") return [];
+	const subpath = `files-sdk/${adapter}`;
+	const requirement = (dependency, necessity, stage, reason) => ({
+		...entry.name === void 0 ? {} : { storage: entry.name },
+		subpath,
+		dependency,
+		necessity,
+		stage,
+		reason
+	});
+	const result = imports.map((entryImport) => ({
+		...entryImport,
+		...entry.name === void 0 ? {} : { storage: entry.name }
+	}));
+	let usesAws = imports.some(({ dependency }) => dependency === "@aws-sdk/client-s3");
+	if (adapter === "r2" || adapter === "minio" || adapter === "rustfs") {
+		const binding = adapter === "r2" ? field(entry.storage.config, "binding") : void 0;
+		const client = field(entry.storage.config, "client");
+		usesAws = binding === unknownValue || client === unknownValue ? void 0 : binding || client === "fetch" ? false : client === "aws-sdk" ? true : target === "node" || target === "bun" ? true : void 0;
+		if (usesAws !== false) result.push(...aws.map((dependency) => requirement(dependency, usesAws ? "required" : "unknown", "operation", "AWS engine selected at runtime unless client is explicit")));
+	}
+	if (usesAws !== false) result.push(requirement("@aws-sdk/lib-storage", usesAws ? "conditional" : "unknown", "operation", "Multipart, progress or unknown-length uploads only"));
+	if (adapter === "firebase-storage") {
+		const app = field(entry.storage.config, "app");
+		const file = field(app, "file");
+		const getFiles = field(app, "getFiles");
+		const injectedBucket = typeof file === "function" && typeof getFiles === "function";
+		const unknown = app === unknownValue || file === unknownValue || getFiles === unknownValue;
+		if (!injectedBucket) {
+			if (!app || unknown) result.push({
+				...requirement("firebase-admin/app", unknown ? "unknown" : "required", "construction", "Create the Firebase app"),
+				conditions: ["node", "require"]
+			});
+			result.push({
+				...requirement("firebase-admin/storage", unknown ? "unknown" : "required", "construction", "Resolve a bucket from the Firebase app"),
+				conditions: ["node", "require"]
+			});
+		}
+	}
+	return result;
+};
+const deploymentTarget = (preset) => {
+	if (preset?.startsWith("cloudflare")) return "workerd";
+	if (preset === "bun") return "bun";
+	if (preset === "node" || preset?.startsWith("node-")) return "node";
+	return "unknown";
+};
+//#endregion
+export { deploymentTarget, storageDependencies };

package/dist/integration/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import { DependencyRequirement } from "./dependencies.js";
+import "./resolve.js";
+//#region src/integration/diagnostics.d.ts
+export interface DependencyDiagnostic extends DependencyRequirement {
+  status: 'satisfied' | 'missing' | 'incompatible' | 'unresolved' | 'unknown';
+  range?: string;
+  version?: string;
+}
+//#endregion

package/dist/integration/diagnostics.js

@@ -0,0 +1,80 @@
+import { resolvePackage, sdkEntry } from "./resolve.js";
+import { pathToFileURL } from "node:url";
+import { satisfies } from "verkit";
+//#region src/integration/diagnostics.ts
+/** Resolution and version inspection are silent, even for uncertain aliases and optional operations. */
+const diagnoseDependencies = (sdk, requirements, aliases = {}, shims = []) => requirements.map((requirement) => {
+	const name = requirement.dependency.split("/").slice(0, requirement.dependency.startsWith("@") ? 2 : 1).join("/");
+	const range = sdk.manifest.peerDependencies?.[name];
+	const base = {
+		...requirement,
+		...range ? { range } : {}
+	};
+	if (requirement.necessity !== "required") return {
+		...base,
+		status: "unknown"
+	};
+	if (Object.keys(aliases).some((alias) => !shims.includes(alias) && (requirement.dependency === alias || requirement.dependency.startsWith(`${alias}/`)))) return {
+		...base,
+		status: "unknown"
+	};
+	const resolved = resolvePackage(requirement.dependency, pathToFileURL(sdkEntry(sdk, requirement.subpath)), requirement.conditions);
+	if (resolved.status !== "resolved") return {
+		...base,
+		status: resolved.status
+	};
+	const version = resolved.package.manifest.version;
+	if (!version || !range) return {
+		...base,
+		status: "unknown"
+	};
+	try {
+		return {
+			...base,
+			version,
+			status: satisfies(version, range) ? "satisfied" : "incompatible"
+		};
+	} catch {
+		return {
+			...base,
+			status: "unknown"
+		};
+	}
+});
+/** The caller retains state across setup, generation and internal worker restarts. */
+const reportDependencyIssues = (diagnostics, previous, warn) => {
+	const issues = diagnostics.filter((entry) => entry.necessity === "required" && (entry.status === "missing" || entry.status === "incompatible" || entry.status === "unresolved"));
+	const current = new Set(issues.map((entry) => JSON.stringify([
+		entry.storage,
+		entry.subpath,
+		entry.dependency,
+		entry.status,
+		entry.range,
+		entry.version
+	])));
+	const fresh = issues.filter((entry) => !previous.has(JSON.stringify([
+		entry.storage,
+		entry.subpath,
+		entry.dependency,
+		entry.status,
+		entry.range,
+		entry.version
+	])));
+	previous.clear();
+	for (const key of current) previous.add(key);
+	if (!fresh.length) return;
+	warn(`[nuxt-files-sdk:dependencies] ${[...new Set(fresh.map((entry) => {
+		return `${entry.storage === void 0 ? entry.subpath : `${entry.storage} (${entry.subpath})`}: ${entry.dependency} ${entry.status}${entry.version ? ` (${entry.version})` : ""}; ${entry.status === "unresolved" ? "check its public exports and aliases" : `install a version matching ${entry.range}`}`;
+	}))].join("\n")}`);
+};
+const sessions = /* @__PURE__ */ new Map();
+const dependencySession = (root) => {
+	let state = sessions.get(root);
+	if (!state) {
+		state = /* @__PURE__ */ new Set();
+		sessions.set(root, state);
+	}
+	return state;
+};
+//#endregion
+export { dependencySession, diagnoseDependencies, reportDependencyIssues };

package/dist/integration/imports.js

@@ -0,0 +1,83 @@
+import { sdkEntry } from "./resolve.js";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+import { parseSync } from "oxc-parser";
+//#region src/integration/imports.ts
+/** Follow local and Layer imports from their actual importer, without discovering/merging configs. */
+const configSources = (filename, aliases = {}) => {
+	const files = /* @__PURE__ */ new Set();
+	const sdkImports = /* @__PURE__ */ new Set();
+	const visit = (path) => {
+		path = resolve(path);
+		if (files.has(path)) return;
+		files.add(path);
+		let source;
+		try {
+			source = readFileSync(path, "utf8");
+		} catch {
+			return;
+		}
+		for (const specifier of sourceImports(path, source)) {
+			if (specifier === "#files-sdk" || specifier.startsWith("#files-sdk/")) {
+				sdkImports.add(specifier.slice(1));
+				continue;
+			}
+			const alias = Object.keys(aliases).toSorted((a, b) => b.length - a.length).find((key) => specifier === key || specifier.startsWith(`${key}/`));
+			const target = alias ? aliases[alias] + specifier.slice(alias.length) : specifier;
+			if (!target.startsWith(".") && !isAbsolute(target)) continue;
+			const entry = resolveModulePath(target, {
+				from: pathToFileURL(path),
+				cache: false,
+				try: true,
+				extensions: [
+					".ts",
+					".mts",
+					".js",
+					".mjs",
+					".cts",
+					".cjs",
+					".json"
+				],
+				suffixes: ["", "/index"]
+			});
+			if (entry) visit(entry);
+			else files.add(resolve(dirname(path), target));
+		}
+	};
+	visit(filename);
+	return {
+		files: [...files],
+		sdkImports: [...sdkImports]
+	};
+};
+/** Runtime imports only; type-only references never require optional SDK installation. */
+const sourceImports = (filename, source) => {
+	const { module } = parseSync(filename, source);
+	return [.../* @__PURE__ */ new Set([...module.staticImports.filter((entry) => !entry.entries.length || entry.entries.some((binding) => !binding.isType)).map((entry) => entry.moduleRequest.value), ...module.staticExports.flatMap((entry) => entry.entries.filter((binding) => !binding.isType && binding.moduleRequest).map((binding) => binding.moduleRequest.value))])];
+};
+/** Read the selected public entry's static graph; never import or execute it. */
+const subpathDependencies = (sdk, subpath) => {
+	const seen = /* @__PURE__ */ new Set();
+	const found = /* @__PURE__ */ new Set();
+	const visit = (filename) => {
+		if (seen.has(filename)) return;
+		seen.add(filename);
+		for (const specifier of sourceImports(filename, readFileSync(filename, "utf8"))) if (specifier.startsWith(".")) visit(resolve(dirname(filename), specifier));
+		else {
+			const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+			if (sdk.manifest.peerDependencies?.[name]) found.add(specifier);
+		}
+	};
+	visit(sdkEntry(sdk, subpath));
+	return [...found].map((dependency) => ({
+		subpath,
+		dependency,
+		necessity: "required",
+		stage: "import",
+		reason: "Static public SDK import"
+	}));
+};
+//#endregion
+export { configSources, sourceImports, subpathDependencies };

package/dist/integration/nitro-dev-close.js

@@ -0,0 +1,13 @@
+//#region src/integration/nitro-dev-close.ts
+/** Stop late Nitro 2 build events from recreating a development worker during Nuxt shutdown. */
+const stopNitroDevReloadOnClose = (instance) => {
+	const hooks = instance?.hooks;
+	if (typeof hooks?.hook !== "function" || typeof hooks.callHookWith !== "function" || typeof hooks.removeHook !== "function") return;
+	const callHookWith = hooks.callHookWith.bind(hooks);
+	const removeHook = hooks.removeHook.bind(hooks);
+	hooks.hook("close", () => callHookWith((callbacks) => {
+		for (const callback of callbacks) removeHook("dev:reload", callback);
+	}, "dev:reload"));
+};
+//#endregion
+export { stopNitroDevReloadOnClose };

package/dist/integration/nitro-event.d.ts

@@ -0,0 +1,7 @@
+import { RequestEvent } from "@nuxt/schema";
+//#region src/integration/nitro-event.d.ts
+/** Adapt standalone Nitro only. Nuxt handlers already receive its public RequestEvent. */
+export declare const nitroRequestEvent: (req: Request, context: RequestEvent['context']) => RequestEvent;
+/** Preserve response changes made by portable authorization callbacks. */
+export declare const nitroResponse: (response: Response, event: RequestEvent) => Response;
+//#endregion

package/dist/integration/nitro-event.js

@@ -0,0 +1,24 @@
+//#region src/integration/nitro-event.ts
+/** Adapt standalone Nitro only. Nuxt handlers already receive its public RequestEvent. */
+const nitroRequestEvent = (req, context) => ({
+	req,
+	url: new URL(req.url),
+	context,
+	res: { headers: new Headers() }
+});
+/** Preserve response changes made by portable authorization callbacks. */
+const nitroResponse = (response, event) => {
+	const headers = new Headers(response.headers);
+	for (const [name, value] of event.res.headers) if (name !== "set-cookie") headers.set(name, value);
+	if (event.res.headers.has("set-cookie")) {
+		headers.delete("set-cookie");
+		for (const cookie of event.res.headers.getSetCookie()) headers.append("set-cookie", cookie);
+	}
+	return new Response(response.body, {
+		status: event.res.status ?? response.status,
+		statusText: event.res.statusText ?? response.statusText,
+		headers
+	});
+};
+//#endregion
+export { nitroRequestEvent, nitroResponse };

package/dist/integration/nitro.d.ts

@@ -1,11 +1,16 @@
+import "./resolve.js";
 import { ProviderSlug } from "files-sdk";
 //#region src/integration/nitro.d.ts
 export interface NitroIntegration {
+  logger?: {
+    warn(message: string): void;
+  };
   meta?: {
     majorVersion?: number;
   };
   options: {
     rootDir: string;
+    workspaceDir?: string;
     buildDir: string;
     dev?: boolean;
     static?: boolean;
@@ -16,6 +21,7 @@ export interface NitroIntegration {
       handler: string;
     }[];
     alias?: Record<string, string>;
+    virtual?: Record<string, string>;
     externals?: {
       inline?: unknown[];
     };
@@ -32,6 +38,8 @@ export interface NitroIntegration {
     };
   };
   hooks: {
+    callHook?(name: 'restart'): Promise<void>;
+    hook(name: 'close', callback: () => void): void;
     hook(name: 'types:extend', callback: (types: {
       tsConfig?: {
         include?: string[];
@@ -42,5 +50,4 @@ export interface NitroIntegration {
     }) => void | Promise<void>): void;
   };
 }
-//#endregion
-//# sourceMappingURL=nitro.d.ts.map
+//#endregion