nuxt-files-sdk 0.1.1 → 0.2.0

package/dist/config/evaluate.js

@@ -0,0 +1,149 @@
+import { extname, isAbsolute } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/config/evaluate.ts
+const normalize = (path) => {
+	const normalized = path.replaceAll("\\", "/").replace(/\/$/u, "");
+	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+};
+/** Create one fresh source graph per c12 load, retaining Jiti's resolver and compiler. */
+const createFilesConfigEvaluator = async ({ alias, nativeRoots }) => {
+	const { createJiti } = await import("jiti");
+	const cache = Object.create(null);
+	const virtualModules = Object.create(null);
+	const instances = /* @__PURE__ */ new Map();
+	const requires = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const results = /* @__PURE__ */ new Map();
+	const failures = /* @__PURE__ */ new Map();
+	const dependencies = /* @__PURE__ */ new Map();
+	const bridgeId = "nuxt-files-sdk:config-source-bridge";
+	const roots = nativeRoots.map(normalize);
+	const sourceSpecifier = (id) => id.startsWith(".") || isAbsolute(id) || id.startsWith("file:") || Object.keys(alias).some((key) => id === key || id.startsWith(`${key}/`));
+	const sourceFile = (id, filename) => sourceSpecifier(id) && /^\.[cm]?[jt]sx?$/u.test(extname(filename)) && !roots.some((root) => normalize(filename) === root || normalize(filename).startsWith(`${root}/`));
+	const callBridge = (types, method, args) => types.callExpression(types.memberExpression(types.callExpression(types.identifier("require"), [types.stringLiteral(bridgeId)]), types.identifier(method)), args);
+	const rewriteImports = (opts) => ({ types }) => ({ visitor: { Program: { enter(path) {
+		const origin = opts.filename;
+		if (!origin) throw new Error("[nuxt-files-sdk:config-source] Missing source filename.");
+		const rewriteStatic = ({ node }) => {
+			if (typeof node.source?.value === "string" && node.importKind !== "type" && node.exportKind !== "type") node.source.value = virtualize(node.source.value, origin, !!opts.async);
+		};
+		path.traverse({
+			ImportDeclaration: rewriteStatic,
+			ExportNamedDeclaration: rewriteStatic,
+			ExportAllDeclaration: rewriteStatic,
+			CallExpression(reference) {
+				const argument = reference.node.arguments?.[0];
+				if (reference.node.callee?.type === "Import" && argument) reference.replaceWith(callBridge(types, "importFrom", [argument, types.stringLiteral(origin)]));
+			},
+			ReferencedIdentifier(reference) {
+				if (reference.node.name !== "require" || reference.scope.getBinding("require")) return;
+				const parent = reference.parentPath?.node;
+				if (parent?.type === "CallExpression" && parent.callee === reference.node && parent.arguments?.[0]?.value === bridgeId) return;
+				reference.replaceWith(callBridge(types, "requireFor", [types.stringLiteral(origin)]));
+				reference.skip();
+			}
+		});
+	} } } });
+	function instance(filename) {
+		const existing = instances.get(filename);
+		if (existing) return existing;
+		const jiti = createJiti(filename, {
+			alias,
+			virtualModules,
+			interopDefault: true,
+			moduleCache: false,
+			tryNative: false,
+			nativeModules: ["files-sdk"],
+			fsCache: false
+		});
+		const transform = jiti.options.transform;
+		if (!transform) throw new Error("[nuxt-files-sdk:config-source] Jiti has no source transformer.");
+		jiti.options.transform = (opts) => transform({
+			...opts,
+			babel: {
+				...opts.babel,
+				plugins: [...opts.babel?.plugins ?? [], rewriteImports(opts)]
+			}
+		});
+		instances.set(filename, jiti);
+		return jiti;
+	}
+	function virtualize(id, origin, async) {
+		if (!sourceSpecifier(id)) return id;
+		const key = `${bridgeId}:${async}:${JSON.stringify([origin, id])}`;
+		if (!(key in virtualModules)) Object.defineProperty(virtualModules, key, {
+			enumerable: true,
+			get: () => async ? importFrom(id, origin) : requireFrom(id, origin)
+		});
+		return key;
+	}
+	function reaches(from, target, visited = /* @__PURE__ */ new Set()) {
+		if (from === target) return true;
+		if (visited.has(from)) return false;
+		visited.add(from);
+		return [...dependencies.get(from) ?? []].some((next) => reaches(next, target, visited));
+	}
+	function evaluate(filename, async, source) {
+		if (failures.has(filename)) throw failures.get(filename);
+		if (results.has(filename)) return results.get(filename);
+		if (cache[filename]) return cache[filename].exports;
+		try {
+			const result = instance(filename).evalModule(source ?? readFileSync(filename, "utf8"), {
+				filename,
+				async,
+				forceTranspile: true,
+				cache
+			});
+			if (!async) {
+				results.set(filename, result);
+				return result;
+			}
+			const completion = Promise.resolve(result).then((value) => {
+				results.set(filename, value);
+				pending.delete(filename);
+				return value;
+			}, (error) => {
+				failures.set(filename, error);
+				pending.delete(filename);
+				throw error;
+			});
+			pending.set(filename, completion);
+			return completion;
+		} catch (error) {
+			failures.set(filename, error);
+			throw error;
+		}
+	}
+	async function importFrom(id, origin) {
+		const jiti = instance(origin);
+		const url = jiti.esmResolve(id);
+		if (!url.startsWith("file:")) return jiti.import(id);
+		const filename = fileURLToPath(url);
+		if (!sourceFile(id, filename)) return jiti.import(id);
+		const circular = reaches(filename, origin);
+		const edges = dependencies.get(origin) ?? /* @__PURE__ */ new Set();
+		edges.add(filename);
+		dependencies.set(origin, edges);
+		return !circular && pending.get(filename) || evaluate(filename, true);
+	}
+	function requireFrom(id, origin) {
+		const jiti = instance(origin);
+		const filename = jiti.resolve(id);
+		return sourceFile(id, filename) ? evaluate(filename, false) : jiti(id);
+	}
+	function requireFor(origin) {
+		const existing = requires.get(origin);
+		if (existing) return existing;
+		const wrapped = new Proxy(instance(origin), { apply: (_target, _this, args) => requireFrom(args[0], origin) });
+		requires.set(origin, wrapped);
+		return wrapped;
+	}
+	virtualModules[bridgeId] = {
+		importFrom,
+		requireFor
+	};
+	return async (filename, source) => evaluate(filename, true, source);
+};
+//#endregion
+export { createFilesConfigEvaluator };

package/dist/config/load.js

@@ -1,16 +1,12 @@
 import { normalizeFilesConfig } from "../runtime/normalize.js";
 import { mergeFilesConfig } from "./merge.js";
+import { registerSdkAliases, resolveOwnedSdk } from "../integration/resolve.js";
+import { createFilesConfigEvaluator } from "./evaluate.js";
 import { basename, dirname } from "node:path";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { loadConfig } from "c12";
-import { createJiti } from "jiti";
 //#region src/config/load.ts
 const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const isResolvedFilesConfig = (value) => {
-	normalizeFilesConfig(value);
-	return true;
-};
 const hasEnvironmentStorage = (config) => [
 	config.$development,
 	config.$production,
@@ -18,50 +14,36 @@ const hasEnvironmentStorage = (config) => [
 	config.$prerender,
 	...isObject(config.$env) ? Object.values(config.$env) : []
 ].some((branch) => isObject(branch) && branch.storage !== void 0);
-/** c12 selects the first environment; a later prerender override is applied with the same merger. */
-const loadFilesConfig = async ({ configPath, environments, alias, injectImports }) => {
-	const jiti = createJiti(import.meta.url, {
+const loadFilesConfig = async ({ configPath, environments, alias, injectImports, source }) => {
+	const { loadConfig } = await import("c12");
+	const sdk = resolveOwnedSdk();
+	const evaluate = await createFilesConfigEvaluator({
 		alias: {
-			...alias,
+			...registerSdkAliases(alias ?? {}, sdk),
 			"nuxt-files-sdk/config": fileURLToPath(new URL("../config.js", import.meta.url))
 		},
-		interopDefault: true,
-		moduleCache: false
+		nativeRoots: [sdk.root]
 	});
-	const importer = Object.assign(jiti, { import: async (id) => {
-		const source = await readFile(id, "utf8");
-		const code = injectImports ? (await injectImports(source, id)).code : source;
-		const loaded = await jiti.evalModule(code, {
-			filename: id,
-			async: true
-		});
-		return loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
-	} });
-	const { config } = await loadConfig({
+	const { config, layers } = await loadConfig({
 		cwd: dirname(configPath),
 		configFile: basename(configPath),
 		configFileRequired: true,
 		rcFile: false,
 		extend: false,
-		envName: environments[0] ?? false,
-		jiti: importer,
-		merger: mergeFilesConfig
+		dotenv: false,
+		envName: [...environments],
+		omit$Keys: true,
+		merger: mergeFilesConfig,
+		envMerger: mergeFilesConfig,
+		import: async (id) => {
+			const input = source ?? await readFile(id, "utf8");
+			const code = injectImports ? (await injectImports(input, id)).code : input;
+			return evaluate(id, code);
+		}
 	});
-	let resolved = config;
-	for (const environment of environments.slice(1)) {
-		const direct = resolved[`$${environment}`];
-		const named = isObject(resolved.$env) ? resolved.$env[environment] : void 0;
-		resolved = mergeFilesConfig({
-			...isObject(direct) ? direct : {},
-			...isObject(named) ? named : {}
-		}, resolved);
-	}
-	const result = Object.fromEntries(Object.entries(resolved).filter(([key]) => !key.startsWith("$")));
-	if (isObject(result) && result.storage === void 0 && hasEnvironmentStorage(resolved)) return void 0;
-	if (!isResolvedFilesConfig(result)) throw new Error("[nuxt-files-sdk:invalid-config] Invalid resolved configuration.");
-	return result;
+	if (config.storage === void 0 && layers?.some(({ config: layer }) => layer && hasEnvironmentStorage(layer))) return void 0;
+	normalizeFilesConfig(config);
+	return config;
 };
 //#endregion
 export { loadFilesConfig };
-
-//# sourceMappingURL=load.js.map

package/dist/config/merge.d.ts

@@ -1,5 +1,4 @@
 //#region src/config/merge.d.ts
 /** c12 merger with Files provider boundaries and replacement arrays. Sources are highest priority first. */
 export declare const mergeFilesConfig: (...sources: Array<Record<string, unknown> | null | undefined>) => Record<string, unknown>;
-//#endregion
-//# sourceMappingURL=merge.d.ts.map
+//#endregion

package/dist/config/merge.js

@@ -18,5 +18,3 @@ const mergeFilesConfig = (...sources) => {
 };
 //#endregion
 export { mergeFilesConfig };
-
-//# sourceMappingURL=merge.js.map

package/dist/config/prepare.js

@@ -0,0 +1,58 @@
+import { normalizeFilesConfig } from "../runtime/normalize.js";
+import { readFile } from "node:fs/promises";
+import { getProvider, listEnvVars } from "files-sdk/providers";
+//#region src/config/prepare.ts
+const selectedAdapters = (config, entries = normalizeFilesConfig(config)) => {
+	const adapters = [...new Set([...entries.values()].map(({ storage }) => storage.adapter).filter((adapter) => typeof adapter === "string"))].toSorted();
+	for (const adapter of adapters) if (!getProvider(adapter)) throw new Error(`[nuxt-files-sdk:unknown-adapter] Unknown adapter "${adapter}".`);
+	return adapters;
+};
+const gatewayRoutes = (config, storages = normalizeFilesConfig(config)) => {
+	const routes = config && typeof config === "object" && "routes" in config ? config.routes : void 0;
+	if (routes === void 0) return [];
+	if (!Array.isArray(routes)) throw new Error("[nuxt-files-sdk:invalid-route] routes must be an array.");
+	const paths = /* @__PURE__ */ new Set();
+	const selected = [];
+	for (const route of routes) {
+		if (!route || typeof route !== "object" || !("path" in route) || typeof route.path !== "string" || !/^\/(?:[\w.~-]+(?:\/[\w.~-]+)*)?$/u.test(route.path)) throw new Error("[nuxt-files-sdk:invalid-route] Each route needs a static absolute path.");
+		if (paths.has(route.path)) throw new Error(`[nuxt-files-sdk:duplicate-route] Duplicate route "${route.path}".`);
+		paths.add(route.path);
+		if ("authorize" in route && route.authorize !== void 0 && typeof route.authorize !== "function") throw new Error("[nuxt-files-sdk:invalid-route] authorize must be a function.");
+		const name = "storage" in route ? route.storage : void 0;
+		if (storages.has(void 0) ? name !== void 0 : typeof name !== "string" || !storages.has(name)) throw new Error(`[nuxt-files-sdk:unknown-storage] Invalid storage for route "${route.path}".`);
+		selected.push(typeof name === "string" ? {
+			path: route.path,
+			storage: name
+		} : { path: route.path });
+	}
+	return selected;
+};
+const factoryName = (adapter) => adapter === "cloudinary" ? "cloudinaryAdapter" : adapter.replaceAll(/-([a-z0-9])/gu, (_, character) => character.toUpperCase());
+const providerCode = (adapters) => ({
+	imports: adapters.map((adapter, index) => `import { ${factoryName(adapter)} as provider${index} } from ${JSON.stringify(`#files-sdk/${adapter}`)}`).join("\n"),
+	factories: adapters.map((adapter, index) => `${JSON.stringify(adapter)}: provider${index}`).join(", ")
+});
+const prepareFilesConfig = async (options) => {
+	const { loadFilesConfig } = await import("./load.js");
+	const { pruneFilesConfigSource } = await import("./prune.js");
+	const original = await readFile(options.configPath, "utf8");
+	const source = options.injectImports ? (await options.injectImports(original, options.configPath)).code : original;
+	const config = await loadFilesConfig({
+		...options,
+		source,
+		injectImports: void 0
+	});
+	if (!config) return void 0;
+	const entries = normalizeFilesConfig(config);
+	const adapters = selectedAdapters(config, entries);
+	return {
+		entries,
+		adapters,
+		routes: gatewayRoutes(config, entries),
+		providers: providerCode(adapters),
+		source: pruneFilesConfigSource(source, options.configPath, options.environments),
+		environment: Object.fromEntries(adapters.map((adapter) => [adapter, listEnvVars(adapter).filter((variable) => variable.readBy === "files-sdk").map((variable) => [variable.key, ...variable.aliases ?? []])]))
+	};
+};
+//#endregion
+export { gatewayRoutes, prepareFilesConfig, providerCode, selectedAdapters };

package/dist/config/prune.js

@@ -2,7 +2,7 @@ import { dirname, resolve } from "node:path";
 import { parseSync } from "oxc-parser";
 //#region src/config/prune.ts
 const unwrap = (node) => node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ParenthesizedExpression" ? unwrap(node.expression) : node;
-const keyOf = (node) => node.key?.type === "Identifier" ? node.key.name : typeof node.key?.value === "string" ? node.key.value : void 0;
+const keyOf = (node) => node.type !== "Property" ? void 0 : node.key.type === "Identifier" && !node.computed ? node.key.name : node.key.type === "Literal" && typeof node.key.value === "string" ? node.key.value : void 0;
 /** Remove inactive environment literals before bundling the user config. */
 const pruneFilesConfigSource = (source, configPath, environments) => {
 	const parsed = parseSync(configPath, source, {
@@ -14,21 +14,22 @@ const pruneFilesConfigSource = (source, configPath, environments) => {
 	const exported = body.find((node) => node.type === "ExportDefaultDeclaration")?.declaration;
 	if (!exported) throw new Error("[nuxt-files-sdk:invalid-config] files.config.ts needs a default export.");
 	let root = unwrap(exported);
-	if (root.type === "CallExpression") root = unwrap(root.arguments?.[0] ?? root);
+	if (root.type === "CallExpression") root = unwrap(root.arguments[0] ?? root);
 	if (root.type === "Identifier") {
-		const declaration = body.flatMap((node) => node.declarations ?? []).find((node) => node.id?.name === root.name);
+		const name = root.name;
+		const declaration = body.flatMap((node) => node.type === "VariableDeclaration" ? node.declarations : []).find((node) => node.id.type === "Identifier" && node.id.name === name);
 		if (declaration?.init) root = unwrap(declaration.init);
 	}
 	if (root.type !== "ObjectExpression") throw new Error("[nuxt-files-sdk:invalid-config] The default Files config must be a static object literal.");
 	const edits = [];
 	const active = new Set(environments);
-	for (const property of root.properties ?? []) {
+	for (const property of root.properties) {
 		const key = keyOf(property);
 		if (!key?.startsWith("$")) continue;
-		if (key === "$env" && property.value) {
+		if (key === "$env" && property.type === "Property") {
 			const env = unwrap(property.value);
 			if (env.type !== "ObjectExpression") throw new Error("[nuxt-files-sdk:invalid-config] $env must be an object.");
-			for (const entry of env.properties ?? []) if (!active.has(keyOf(entry) ?? "")) edits.push({
+			for (const entry of env.properties) if (!active.has(keyOf(entry) ?? "")) edits.push({
 				start: entry.start,
 				end: entry.end,
 				text: "...{}"
@@ -40,7 +41,7 @@ const pruneFilesConfigSource = (source, configPath, environments) => {
 		});
 	}
 	for (const node of body) {
-		if (!node.source || typeof node.source.value !== "string" || !node.source.value.startsWith(".")) continue;
+		if (!("source" in node) || !node.source || !node.source.value.startsWith(".")) continue;
 		edits.push({
 			start: node.source.start,
 			end: node.source.end,
@@ -53,5 +54,3 @@ const pruneFilesConfigSource = (source, configPath, environments) => {
 };
 //#endregion
 export { pruneFilesConfigSource };
-
-//# sourceMappingURL=prune.js.map

package/dist/config.d.ts

@@ -1,7 +1,7 @@
 import { ProviderFactories } from "./runtime/provider-types.js";
 import { Adapter, FilesHooks, FilesOptions, FilesPlugin, ProviderSlug } from "files-sdk";
 import { AuthorizeContext, AuthorizeResult, CreateFilesRouterOptions } from "files-sdk/api";
-import { H3Event } from "h3";
+import { RequestEvent } from "@nuxt/schema";
 //#region src/config.d.ts
 export type AdapterFactory = (...args: never[]) => Adapter;
 type StorageAdapter = ProviderSlug | AdapterFactory;
@@ -28,7 +28,7 @@ export type FilesRoute = Omit<CreateFilesRouterOptions, 'files' | 'authorize'> &
   path: string;
   storage?: string;
   authorize?: (context: AuthorizeContext & {
-    event: H3Event;
+    event: RequestEvent;
   }) => AuthorizeResult | Promise<AuthorizeResult>;
 };
 export type StorageSet = StorageConfig | Record<string, StorageConfig>;
@@ -66,7 +66,7 @@ type StorageCheck<T> = T extends {
 type StorageOf<T> = T extends {
   storage: infer S;
 } ? S : never;
-type StorageBranches<T> = StorageOf<T> | StorageOf<T extends {
+type EnvironmentStorage<T> = StorageOf<T extends {
   $development: infer E;
 } ? E : never> | StorageOf<T extends {
   $production: infer E;
@@ -77,7 +77,13 @@ type StorageBranches<T> = StorageOf<T> | StorageOf<T extends {
 } ? E : never> | StorageOf<T extends {
   $env: infer E;
 } ? E[keyof E] : never>;
-type StorageNames<T> = StorageBranches<T> extends (infer S) ? S extends {
+type OverrideEntry<Base, Override> = Omit<Base, keyof Override> & Override;
+type OverrideStorage<Base, Override> = Override extends {
+  adapter: unknown;
+} ? OverrideEntry<Base, Override> : Override extends object ? { [K in keyof Base | keyof Override]: K extends keyof Override ? OverrideEntry<K extends keyof Base ? Base[K] : {}, Override[K]> : K extends keyof Base ? Base[K] : never; } : never;
+/** Possible storage shapes after inheriting common options into each environment. */
+export type StorageBranches<T> = StorageOf<T> | OverrideStorage<[StorageOf<T>] extends [never] ? {} : StorageOf<T>, EnvironmentStorage<T>>;
+export type StorageNames<T> = StorageBranches<T> extends (infer S) ? S extends {
   adapter: unknown;
 } ? never : S extends object ? Extract<keyof S, string> : never : never;
 type RouteCheck<T> = FilesRoute & ([StorageNames<T>] extends [never] ? {
@@ -109,5 +115,4 @@ type InputCheck<T> = Record<Exclude<keyof T, 'storage' | 'routes' | '$developmen
 } : unknown);
 /** Preserve storage names, adapters, and plugin literals without resolving an environment. */
 export declare function defineFilesConfig<const C extends object>(config: C & FilesConfigInput & InputCheck<NoInfer<C>>): C;
-//#endregion
-//# sourceMappingURL=config.d.ts.map
+//#endregion

package/dist/config.js

@@ -5,5 +5,3 @@ function defineFilesConfig(config) {
 }
 //#endregion
 export { defineFilesConfig };
-
-//# sourceMappingURL=config.js.map

package/dist/devtools/auth.js

@@ -45,5 +45,3 @@ const authorizeFilesDevtoolsRequest = async (request, secret) => {
 };
 //#endregion
 export { FILES_DEVTOOLS_TOKEN_TTL, authorizeFilesDevtoolsRequest, createFilesDevtoolsToken, verifyFilesDevtoolsToken };
-
-//# sourceMappingURL=auth.js.map