nuxt-files-sdk 0.1.0 → 0.2.0

package/dist/integration/resolve.js

@@ -0,0 +1,113 @@
+import { dirname, join } from "node:path";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { resolveModulePath } from "exsolve";
+import { getPackageInfoSync, resolveModule } from "local-pkg";
+import { exports } from "resolve.exports";
+//#region src/integration/resolve.ts
+const packageName = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+/** Resolve first to keep local-pkg silent when an optional dependency is absent. */
+const packageInfo = (specifier, from) => {
+	const name = packageName(specifier);
+	const entry = resolveModule(specifier, { paths: [from.href] });
+	if (entry) {
+		const info = getPackageInfoSync(entry);
+		if (info?.packageJson.name === name) {
+			const manifestPath = realpathSync(info.packageJsonPath);
+			return {
+				manifest: {
+					...info.packageJson,
+					name,
+					version: info.version ?? ""
+				},
+				manifestPath,
+				root: dirname(manifestPath)
+			};
+		}
+	}
+	for (const directory of createRequire(from).resolve.paths(name) ?? []) {
+		const path = join(directory, name, "package.json");
+		if (!existsSync(path)) continue;
+		const manifest = JSON.parse(readFileSync(path, "utf8"));
+		if (manifest.name !== name) continue;
+		const manifestPath = realpathSync(path);
+		return {
+			manifest,
+			manifestPath,
+			root: dirname(manifestPath)
+		};
+	}
+};
+const resolvePackage = (specifier, from, conditions = ["node", "import"]) => {
+	const info = packageInfo(specifier, from);
+	if (!info) return { status: "missing" };
+	const entry = publicEntry(info, specifier, conditions);
+	return entry ? {
+		status: "resolved",
+		entry: entry.replaceAll("\\", "/"),
+		package: info
+	} : {
+		status: "unresolved",
+		package: info
+	};
+};
+const resolveOwnedSdk = (from = import.meta.url) => {
+	const result = resolvePackage("files-sdk", new URL(from));
+	if (result.status !== "resolved") throw new Error("[nuxt-files-sdk:sdk-resolution] The owned Files SDK dependency could not be resolved.");
+	return result.package;
+};
+const publicEntry = (info, specifier, conditions) => {
+	try {
+		const suffix = specifier.slice(info.manifest.name.length);
+		const target = info.manifest.exports ? exports(info.manifest, `.${suffix}`, {
+			conditions,
+			unsafe: true
+		})?.[0] : suffix ? `.${suffix}` : info.manifest.main || "./index.js";
+		if (!target) return void 0;
+		return resolveModulePath(new URL(target, pathToFileURL(info.manifestPath)).href, {
+			conditions,
+			cache: false,
+			try: true,
+			extensions: [
+				".js",
+				".json",
+				".node"
+			],
+			suffixes: ["", "/index"]
+		});
+	} catch {
+		return;
+	}
+};
+const sdkEntry = (sdk, subpath, conditions = ["node", "import"]) => {
+	const entry = publicEntry(sdk, subpath, conditions);
+	if (!entry) throw new Error(`[nuxt-files-sdk:sdk-exports] Cannot resolve public entry ${subpath}.`);
+	return entry.replaceAll("\\", "/");
+};
+/** Enumerate public subpaths without evaluating providers. Root comes last for prefix alias engines. */
+const sdkAliases = (sdk, conditions = ["node", "import"]) => Object.fromEntries(Object.keys(sdk.manifest.exports ?? {}).toSorted((a, b) => b.length - a.length).map((key) => {
+	if (key !== "." && (!key.startsWith("./") || key.includes("*"))) throw new Error(`[nuxt-files-sdk:sdk-exports] Unsupported public export pattern: ${key}`);
+	const suffix = key === "." ? "" : key.slice(1);
+	return [`#files-sdk${suffix}`, sdkEntry(sdk, `files-sdk${suffix}`, conditions)];
+}));
+const registerSdkAliases = (aliases, sdk, conditions = ["node", "import"]) => {
+	const selected = sdkAliases(sdk, conditions);
+	let node;
+	let browser;
+	for (const [name, path] of Object.entries(aliases)) {
+		if (name !== "#files-sdk" && !name.startsWith("#files-sdk/")) continue;
+		const normalized = path.replaceAll("\\", "/");
+		if (selected[name] === normalized) continue;
+		node ??= sdkAliases(sdk);
+		browser ??= sdkAliases(sdk, ["browser", "import"]);
+		if (![node[name], browser[name]].includes(normalized)) throw new Error(`[nuxt-files-sdk:reserved-alias] ${name} must refer to the owned Files SDK.`);
+	}
+	return {
+		...selected,
+		...Object.fromEntries(Object.entries(aliases).filter(([name]) => !(name in selected)))
+	};
+};
+const sdkTypePaths = (sdk) => Object.fromEntries(Object.entries(sdkAliases(sdk, ["types", "import"])).map(([name, entry]) => [name, [entry]]));
+//#endregion
+export { packageInfo, registerSdkAliases, resolveOwnedSdk, resolvePackage, sdkAliases, sdkEntry, sdkTypePaths };

package/dist/integration/terminal.js

@@ -0,0 +1,20 @@
+//#region src/integration/terminal.ts
+/** Short work is quiet. A visible task always terminates with its actual outcome. */
+const withFilesTask = async (terminal, label, work, delay = 500) => {
+	let task;
+	let outcome = "failure";
+	const timer = setTimeout(() => {
+		task = terminal.startTask(label);
+	}, delay);
+	timer.unref();
+	try {
+		const result = await work();
+		outcome = "success";
+		return result;
+	} finally {
+		clearTimeout(timer);
+		task?.stop(void 0, outcome);
+	}
+};
+//#endregion
+export { withFilesTask };

package/dist/integration/update.js

@@ -0,0 +1,59 @@
+import { fileHash } from "../runtime/development.js";
+import { unwatchFile, watchFile } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+//#region src/integration/update.ts
+const writeChanged = async (path, content) => {
+	if (await readFile(path, "utf8").catch(() => void 0) !== content) await writeFile(path, content);
+};
+/** Poll specific inputs, including missing lockfiles, without watching generated output. */
+const watchFiles = (paths, changed, failed) => {
+	const listeners = /* @__PURE__ */ new Map();
+	let timer;
+	let pending = false;
+	let running = false;
+	let closed = false;
+	const run = async () => {
+		if (closed || running || !pending) return;
+		pending = false;
+		running = true;
+		try {
+			await changed();
+		} catch (error) {
+			failed(error);
+		} finally {
+			running = false;
+			if (pending && !closed) run();
+		}
+	};
+	const add = (files) => {
+		for (const path of files) {
+			if (listeners.has(path)) continue;
+			let hash = fileHash(path);
+			const listener = () => {
+				const next = fileHash(path);
+				if (hash === next) return;
+				hash = next;
+				pending = true;
+				clearTimeout(timer);
+				timer = setTimeout(() => void run(), 100);
+				timer.unref();
+			};
+			listeners.set(path, listener);
+			watchFile(path, {
+				interval: 250,
+				persistent: false
+			}, listener);
+		}
+	};
+	add(paths);
+	return {
+		add,
+		close() {
+			closed = true;
+			clearTimeout(timer);
+			for (const [path, listener] of listeners) unwatchFile(path, listener);
+		}
+	};
+};
+//#endregion
+export { watchFiles, writeChanged };

package/dist/meta.js

@@ -0,0 +1,8 @@
+//#region src/meta.ts
+const moduleMeta = {
+	name: "nuxt-files-sdk",
+	configKey: "files",
+	compatibility: { nuxt: "^4.6.0 || ^5.0.0-0" }
+};
+//#endregion
+export { moduleMeta };

package/dist/module.d.ts

@@ -1,11 +1,5 @@
 import { FilesDevtoolsOptions } from "./devtools/enabled.js";
-import { NitroIntegration } from "./integration/nitro.js";
 //#region src/module.d.ts
-declare module '@nuxt/schema' {
-  interface NuxtHooks {
-    'nitro:init': (nitro: NitroIntegration) => void | Promise<void>;
-  }
-}
 /** Options for the Nuxt Files SDK module. */
 export interface ModuleOptions {
   /** Path to the Files configuration module, relative to the Nuxt root directory. */
@@ -16,5 +10,4 @@ export interface ModuleOptions {
 /** Install Files SDK storage configuration, server utilities, Vue composables, and development diagnostics in Nuxt. */
 declare const _default: import("@nuxt/schema").NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion
-export { type FilesDevtoolsOptions, _default as default };
-//# sourceMappingURL=module.d.ts.map
+export { type FilesDevtoolsOptions, _default as default };

package/dist/module.js

@@ -1,75 +1,90 @@
 import { filesDevtoolsWriteEnabled, shouldEnableFilesDevtools } from "./devtools/enabled.js";
-import { setupNitroFilesIntegration } from "./integration/nitro.js";
-import { randomUUID } from "node:crypto";
+import { filesBuilderCapabilities } from "./integration/capabilities.js";
+import { moduleMeta } from "./meta.js";
+import { createHash, randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { addImports, addServerImports, defineNuxtModule, getNuxtModuleVersion } from "@nuxt/kit";
+import { addImports, addServerImports, defineNuxtModule, getNuxtModuleVersion, resolveModule, resolveServerVariant, useLogger } from "@nuxt/kit";
 //#region src/module.ts
 /** Install Files SDK storage configuration, server utilities, Vue composables, and development diagnostics in Nuxt. */
 var module_default = defineNuxtModule({
-	meta: {
-		name: "nuxt-files-sdk",
-		configKey: "files",
-		compatibility: { nuxt: "^4.0.0 || ^5.0.0" }
-	},
+	meta: moduleMeta,
 	defaults: {
 		config: "files.config.ts",
 		devtools: true
 	},
-	async setup(options, nuxt) {
-		const configPath = resolve(nuxt.options.rootDir, options.config);
-		(nuxt.options.typescript.tsConfig.include ??= []).push(configPath);
-		const paths = (nuxt.options.typescript.tsConfig.compilerOptions ??= {}).paths ??= {};
-		paths["files-sdk"] ??= [resolve(nuxt.options.rootDir, "node_modules/files-sdk").replaceAll("\\", "/")];
-		let active = false;
-		nuxt.hook("nitro:init", async (nitro) => {
-			active = await setupNitroFilesIntegration(nitro, {
-				configPath,
-				environments: nitro.options.static ? ["production", "prerender"] : [nuxt.options.envName || (nuxt.options.dev ? "development" : "production")]
-			});
-		});
-		nuxt.hook("prepare:types", ({ references }) => {
-			if (active) references.push({ path: resolve(nuxt.options.buildDir, "nuxt-files-sdk/storage-registry.d.ts") });
-		});
-		addServerImports([
-			{
+	setup(options, nuxt) {
+		nuxt.hook("modules:done", () => nuxt.runWithContext(async () => {
+			const { setupNuxtFilesIntegration } = await import("./integration/nuxt.js");
+			if (!await setupNuxtFilesIntegration(nuxt, { configPath: resolve(nuxt.options.rootDir, options.config) })) return;
+			const capabilities = filesBuilderCapabilities(resolveServerVariant({
+				nuxt: "nuxt",
+				nitro2: "nitro2",
+				nitro3: "nitro3"
+			}));
+			addServerImports([
+				{
+					name: "defineFilesConfig",
+					from: "nuxt-files-sdk/config",
+					typeFrom: resolveModule("nuxt-files-sdk/config", { url: new URL(import.meta.url) }).replaceAll("\\", "/")
+				},
+				{
+					name: "useServerFiles",
+					from: "nuxt-files-sdk/runtime",
+					dtsDisabled: true
+				},
+				{
+					name: "syncFiles",
+					from: "nuxt-files-sdk/runtime",
+					dtsDisabled: true
+				},
+				{
+					name: "transferFiles",
+					from: "nuxt-files-sdk/runtime",
+					dtsDisabled: true
+				}
+			]);
+			addImports({
 				name: "defineFilesConfig",
 				from: "nuxt-files-sdk/config"
-			},
-			{
-				name: "useServerFiles",
-				from: "nuxt-files-sdk/runtime"
-			},
-			{
-				name: "syncFiles",
-				from: "nuxt-files-sdk/runtime"
-			},
-			{
-				name: "transferFiles",
-				from: "nuxt-files-sdk/runtime"
+			});
+			for (const name of [
+				"useFiles",
+				"useFile",
+				"useList",
+				"useSearch"
+			]) addImports({
+				name,
+				from: "#files-sdk/vue"
+			});
+			if (shouldEnableFilesDevtools(nuxt.options.dev, options.devtools, nuxt.options.devtools)) {
+				if (!capabilities.devtools) {
+					useLogger("nuxt-files-sdk").warn("[nuxt-files-sdk:devtools-unavailable] Files DevTools is unavailable with this server builder. Basic Files runtime remains enabled.");
+					return;
+				}
+				const version = await getNuxtModuleVersion("@nuxt/devtools", nuxt);
+				const { setupFilesDevtools } = await import("./devtools/index.js");
+				const environmentKey = `NUXT_FILES_DEVTOOLS_${createHash("sha256").update(nuxt.options.rootDir).digest("hex").slice(0, 24).toUpperCase()}`;
+				const previous = process.env[environmentKey];
+				const secrets = {
+					token: randomUUID(),
+					environmentKey
+				};
+				process.env[environmentKey] = secrets.token;
+				const restore = () => {
+					if (process.env[environmentKey] !== secrets.token) return;
+					if (previous === void 0) delete process.env[environmentKey];
+					else process.env[environmentKey] = previous;
+				};
+				nuxt.hook("close", restore);
+				try {
+					await setupFilesDevtools(nuxt, version || "3", filesDevtoolsWriteEnabled(options.devtools), secrets);
+				} catch (error) {
+					restore();
+					throw error;
+				}
 			}
-		]);
-		addImports({
-			name: "defineFilesConfig",
-			from: "nuxt-files-sdk/config"
-		});
-		for (const name of [
-			"useFiles",
-			"useFile",
-			"useList",
-			"useSearch"
-		]) addImports({
-			name,
-			from: "files-sdk/vue"
-		});
-		if (shouldEnableFilesDevtools(nuxt.options.dev, options.devtools, nuxt.options.devtools)) {
-			const version = await getNuxtModuleVersion("@nuxt/devtools", nuxt);
-			const { setupFilesDevtools } = await import("./devtools/index.js");
-			const secrets = { token: randomUUID() };
-			setupFilesDevtools(nuxt, version || "3", filesDevtoolsWriteEnabled(options.devtools), secrets);
-		}
+		}));
 	}
 });
 //#endregion
 export { module_default as default };
-
-//# sourceMappingURL=module.js.map

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "nuxt-files-sdk",
+  "configKey": "files",
+  "compatibility": {
+    "nuxt": "^4.6.0 || ^5.0.0-0"
+  },
+  "version": "0.2.0"
+}

package/dist/nitro.d.ts

@@ -9,5 +9,4 @@ declare const _default: {
   setup: (nitro: NitroIntegration) => Promise<boolean>;
 };
 //#endregion
-export { _default as default };
-//# sourceMappingURL=nitro.d.ts.map
+export { _default as default };

package/dist/nitro.js

@@ -1,4 +1,3 @@
-import { setupNitroFilesIntegration } from "./integration/nitro.js";
 import { resolve } from "node:path";
 //#region src/nitro.ts
 /**
@@ -7,12 +6,13 @@ import { resolve } from "node:path";
 */
 var nitro_default = {
 	name: "nuxt-files-sdk",
-	setup: (nitro) => setupNitroFilesIntegration(nitro, {
-		configPath: resolve(nitro.options.rootDir, "files.config.ts"),
-		environments: nitro.options.static ? ["production", "prerender"] : [nitro.options.dev ? "development" : "production"]
-	})
+	setup: async (nitro) => {
+		const { setupNitroFilesIntegration } = await import("./integration/nitro.js");
+		return setupNitroFilesIntegration(nitro, {
+			configPath: resolve(nitro.options.rootDir, "files.config.ts"),
+			environments: nitro.options.static ? ["production", "prerender"] : [nitro.options.dev ? "development" : "production"]
+		});
+	}
 };
 //#endregion
 export { nitro_default as default };
-
-//# sourceMappingURL=nitro.js.map

package/dist/package.js

@@ -1,6 +1,4 @@
 //#region package.json
-var version = "0.1.0";
+var version = "0.2.0";
 //#endregion
 export { version };
-
-//# sourceMappingURL=package.js.map

package/dist/runtime/development.d.ts

@@ -0,0 +1,5 @@
+//#region src/runtime/development.d.ts
+export declare const fileHash: (path: string) => string;
+/** Development only: a failed rebuild must never leave old authorization accepting requests. */
+export declare const developmentConfigCurrent: (files: Record<string, string>) => boolean;
+//#endregion

package/dist/runtime/development.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+//#region src/runtime/development.ts
+const fileHash = (path) => {
+	try {
+		return createHash("sha256").update(readFileSync(path)).digest("hex");
+	} catch {
+		return "unavailable";
+	}
+};
+/** Development only: a failed rebuild must never leave old authorization accepting requests. */
+const developmentConfigCurrent = (files) => Object.entries(files).every(([path, hash]) => hash !== "unavailable" && fileHash(path) === hash);
+//#endregion
+export { developmentConfigCurrent, fileHash };

package/dist/runtime/gateway-secret.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/gateway-secret.d.ts
+/** Resolve on the server only. Never serialize the resolved value during generation. */
+export declare const resolveGatewaySecret: (routeSecret: string | undefined, environmentSecret: string | undefined, derive?: () => Promise<string>) => Promise<string>;
+//#endregion

package/dist/runtime/gateway-secret.js

@@ -0,0 +1,10 @@
+//#region src/runtime/gateway-secret.ts
+/** Resolve on the server only. Never serialize the resolved value during generation. */
+const resolveGatewaySecret = async (routeSecret, environmentSecret, derive) => {
+	if (routeSecret) return routeSecret;
+	if (environmentSecret) return environmentSecret;
+	if (derive) return derive();
+	throw new Error("[nuxt-files-sdk:gateway-secret] Standalone Nitro requires route.secret or FILES_API_SECRET.");
+};
+//#endregion
+export { resolveGatewaySecret };

package/dist/runtime/internal.d.ts

@@ -7,5 +7,4 @@ export declare const configureFiles: <const C extends FilesConfig>(config: C, op
 /** Return secret-free diagnostics for the configured process-local Files registry. */
 export declare const inspectFiles: () => ReturnType<FilesRegistry['inspect']>;
 export declare const getFiles: (name?: string) => Files;
-//#endregion
-//# sourceMappingURL=internal.d.ts.map
+//#endregion

package/dist/runtime/internal.js

@@ -18,6 +18,7 @@ const configureFiles = (config, options) => {
 /** Return secret-free diagnostics for the configured process-local Files registry. */
 const inspectFiles = () => registry?.inspect() ?? {
 	storages: [],
+	dependencies: [],
 	diagnostics: [registryDiagnostic ?? { code: "NUXT_FILES_NOT_CONFIGURED" }]
 };
 const getFiles = (name) => {
@@ -26,5 +27,3 @@ const getFiles = (name) => {
 };
 //#endregion
 export { configureFiles, getFiles, inspectFiles };
-
-//# sourceMappingURL=internal.js.map

package/dist/runtime/normalize.d.ts

@@ -0,0 +1 @@
+import "../config.js";

package/dist/runtime/normalize.js

@@ -25,5 +25,3 @@ const normalizeFilesConfig = (config) => {
 };
 //#endregion
 export { normalizeFilesConfig };
-
-//# sourceMappingURL=normalize.js.map

package/dist/runtime/provider-types.d.ts

@@ -49,5 +49,4 @@ export interface ProviderFactories {
   webdav: typeof import('files-sdk/webdav').webdav;
   yandex: typeof import('files-sdk/yandex').yandex;
 }
-//#endregion
-//# sourceMappingURL=provider-types.d.ts.map
+//#endregion

package/dist/runtime/registry.d.ts

@@ -1,5 +1,6 @@
 import { ProviderFactories } from "./provider-types.js";
-import { FilesConfig, FilesConfigInput } from "../config.js";
+import { FilesConfig, FilesConfigInput, StorageBranches, StorageNames } from "../config.js";
+import { DependencyDiagnostic } from "../integration/diagnostics.js";
 import { FilesDevtoolsDiagnosticCode } from "../devtools/diagnostics.js";
 import { Adapter, ExtensionsOf, Files, FilesActionEvent, FilesErrorEvent, FilesRetryEvent, ProviderSlug } from "files-sdk";
 //#region src/runtime/registry.d.ts
@@ -8,30 +9,15 @@ type AdapterFor<A> = A extends ProviderSlug ? ReturnType<ProviderFactories[A]> :
 type PluginsFor<T> = T extends {
   plugins: infer V;
 } ? V extends ((...args: never[]) => infer P) ? P extends readonly import('files-sdk').FilesPlugin[] ? P : never : V extends readonly import('files-sdk').FilesPlugin[] ? V : never : never;
-export type FilesForStorage<T extends {
+export type FilesForStorage<T> = T extends {
   adapter: ProviderSlug | ((...args: never[]) => Adapter);
-}> = Files<AdapterFor<T['adapter']>> & ExtensionsOf<PluginsFor<T>>;
-type StorageOf<C> = C extends {
-  storage: infer S;
-} ? S : never;
-type StorageBranch<C> = StorageOf<C> | StorageOf<C extends {
-  $development: infer E;
-} ? E : never> | StorageOf<C extends {
-  $production: infer E;
-} ? E : never> | StorageOf<C extends {
-  $test: infer E;
-} ? E : never> | StorageOf<C extends {
-  $prerender: infer E;
-} ? E : never> | StorageOf<C extends {
-  $env: infer E;
-} ? E[keyof E] : never>;
-type SingleEntry<C> = Extract<StorageBranch<C>, {
+} ? Files<AdapterFor<T['adapter']>> & ExtensionsOf<PluginsFor<T>> : never;
+type SingleEntry<C> = Extract<StorageBranches<C>, {
   adapter: ProviderSlug | ((...args: never[]) => Adapter);
 }>;
-type NamedSet<C> = Exclude<StorageBranch<C>, {
+type NamedSet<C> = Exclude<StorageBranches<C>, {
   adapter: unknown;
 }>;
-type StorageNames<C> = NamedSet<C> extends (infer S) ? (S extends object ? keyof S : never) : never;
 type NamedEntry<C, Name extends PropertyKey> = NamedSet<C> extends (infer S) ? (S extends object ? (Name extends keyof S ? S[Name] : never) : never) : never;
 /** Map each configured storage name to its native Files client and plugin extensions. */
 export type StorageRegistry<C extends FilesConfigInput> = { [Name in StorageNames<C>]: FilesForStorage<Extract<NamedEntry<C, Name>, {
@@ -66,6 +52,7 @@ export declare class FilesRegistry<const C extends FilesConfig = FilesConfig> {
     environment?: ProviderEnvironment;
     factories: FilesProviderFactories;
     hooks?: FilesRuntimeHooks;
+    dependencies?: readonly DependencyDiagnostic[];
   });
   /** Return the client from an unnamed single-storage configuration. */
   get(...args: SingleEntry<C> extends never ? [name: never] : []): SingleStorage<C>;
@@ -80,9 +67,9 @@ export declare class FilesRegistry<const C extends FilesConfig = FilesConfig> {
       initialized: boolean;
     }[];
     diagnostics: RegistryDiagnostic[];
+    dependencies: readonly DependencyDiagnostic[];
   };
   /** Resolve one selected adapter without constructing its Files client. */
   resolveAdapter(name?: string): Adapter;
 }
-//#endregion
-//# sourceMappingURL=registry.d.ts.map
+//#endregion