wawesome 0.22.0 → 0.24.0

package/dist/local-modules-DvEInmfO.mjs

@@ -0,0 +1,225 @@
+import { f as readFunctionConfig, i as listFiles } from "./assets-Cgw3_rAq.mjs";
+import fs from "node:fs";
+import path from "node:path";
+//#region ../../server/guest-surface/private-files.js
+const constants = Object.freeze({
+	F_OK: 0,
+	R_OK: 4,
+	W_OK: 2,
+	X_OK: 1
+});
+function fsError(code, description, syscall, path) {
+	const error = /* @__PURE__ */ new Error(`${code}: ${description}, ${syscall} '${path}'`);
+	error.code = code;
+	error.syscall = syscall;
+	error.path = path;
+	return error;
+}
+function pathOf(path) {
+	if (path instanceof URL) return decodeURIComponent(path.pathname);
+	return String(path);
+}
+function keyOf(path) {
+	const segments = [];
+	for (const segment of path.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") segments.pop();
+		else segments.push(segment);
+	}
+	return segments.join("/");
+}
+var Kind = class {
+	#folder;
+	constructor(folder) {
+		this.#folder = folder;
+	}
+	isFile() {
+		return !this.#folder;
+	}
+	isDirectory() {
+		return this.#folder;
+	}
+	isSymbolicLink() {
+		return false;
+	}
+	isBlockDevice() {
+		return false;
+	}
+	isCharacterDevice() {
+		return false;
+	}
+	isFIFO() {
+		return false;
+	}
+	isSocket() {
+		return false;
+	}
+};
+var Stats = class extends Kind {
+	constructor(entry) {
+		super(entry.folder);
+		this.size = entry.size;
+		this.mode = entry.folder ? 16749 : 33060;
+	}
+};
+var Dirent = class extends Kind {
+	constructor(name, parentPath, folder) {
+		super(folder);
+		this.name = name;
+		this.parentPath = parentPath;
+		this.path = parentPath;
+	}
+};
+function readOnly(syscall) {
+	return async (path) => {
+		throw fsError("EROFS", "read-only file system", syscall, pathOf(path));
+	};
+}
+/**
+* `listing` is `[path, size]` pairs. `fetchFile(path)` answers a Response:
+* 200 with the bytes, 404 for a file that is gone, 413 with the reason for a
+* read past the invocation's cap.
+*/
+function privateFiles(listing, fetchFile) {
+	const sizes = new Map(listing);
+	const folders = /* @__PURE__ */ new Map([["", /* @__PURE__ */ new Set()]]);
+	for (const path of sizes.keys()) {
+		const segments = path.split("/");
+		for (let depth = 0; depth < segments.length; depth++) {
+			const parent = segments.slice(0, depth).join("/");
+			if (!folders.has(parent)) folders.set(parent, /* @__PURE__ */ new Set());
+			folders.get(parent).add(segments[depth]);
+		}
+	}
+	function entryAt(name, syscall) {
+		const key = keyOf(name);
+		if (sizes.has(key)) return {
+			key,
+			folder: false,
+			size: sizes.get(key)
+		};
+		if (folders.has(key)) return {
+			key,
+			folder: true,
+			size: 0
+		};
+		throw fsError("ENOENT", "no such file or directory", syscall, name);
+	}
+	async function readFile(path, options) {
+		const name = pathOf(path);
+		const encoding = typeof options === "string" ? options : options?.encoding;
+		const entry = entryAt(name, "open");
+		if (entry.folder) throw fsError("EISDIR", "illegal operation on a directory", "read", name);
+		const response = await fetchFile(entry.key);
+		if (response.status === 404) throw fsError("ENOENT", "no such file or directory", "open", name);
+		if (response.status === 413) throw fsError("EFBIG", await response.text(), "read", name);
+		if (!response.ok) throw fsError("EIO", "i/o error", "read", name);
+		if (encoding == null) return new Uint8Array(await response.arrayBuffer());
+		if (/^utf-?8$/i.test(encoding)) return response.text();
+		return new TextDecoder(encoding).decode(await response.arrayBuffer());
+	}
+	async function readdir(path, options) {
+		const name = pathOf(path);
+		const entry = entryAt(name, "scandir");
+		if (!entry.folder) throw fsError("ENOTDIR", "not a directory", "scandir", name);
+		const listed = [];
+		const walk = (key, relative, parentPath) => {
+			for (const child of [...folders.get(key)].sort()) {
+				const childKey = key === "" ? child : `${key}/${child}`;
+				const folder = folders.has(childKey);
+				const childRelative = relative === "" ? child : `${relative}/${child}`;
+				listed.push(options?.withFileTypes ? new Dirent(child, parentPath, folder) : childRelative);
+				if (options?.recursive && folder) walk(childKey, childRelative, `${parentPath}/${child}`);
+			}
+		};
+		walk(entry.key, "", name);
+		return listed;
+	}
+	async function stat(path) {
+		return new Stats(entryAt(pathOf(path), "stat"));
+	}
+	async function lstat(path) {
+		return new Stats(entryAt(pathOf(path), "lstat"));
+	}
+	async function access(path, mode = constants.F_OK) {
+		const name = pathOf(path);
+		const entry = entryAt(name, "access");
+		if (mode & constants.W_OK) throw fsError("EROFS", "read-only file system", "access", name);
+		if (mode & constants.X_OK && !entry.folder) throw fsError("EACCES", "permission denied", "access", name);
+	}
+	return {
+		constants,
+		readFile,
+		readdir,
+		stat,
+		lstat,
+		access,
+		appendFile: readOnly("open"),
+		chmod: readOnly("chmod"),
+		chown: readOnly("chown"),
+		copyFile: readOnly("copyfile"),
+		cp: readOnly("cp"),
+		lchown: readOnly("lchown"),
+		link: readOnly("link"),
+		lutimes: readOnly("lutime"),
+		mkdir: readOnly("mkdir"),
+		mkdtemp: readOnly("mkdtemp"),
+		rename: readOnly("rename"),
+		rm: readOnly("rm"),
+		rmdir: readOnly("rmdir"),
+		symlink: readOnly("symlink"),
+		truncate: readOnly("open"),
+		unlink: readOnly("unlink"),
+		utimes: readOnly("utime"),
+		writeFile: readOnly("open")
+	};
+}
+//#endregion
+//#region src/local-modules.ts
+/**
+* `DEFAULT_MAX_PRIVATE_FILE_READ_BYTES` in the runner. Production counts it over
+* every read of one invocation; a local run has no invocation, so it holds for
+* each read alone.
+*/
+const MAX_PRIVATE_FILE_READ_BYTES = 8388608;
+const LOCAL_MODULES = { "fs-promises": localFsPromises };
+/** A declared module as the guest gets it, backed by the project on disk. */
+function localModule(shim, projectDir) {
+	const create = LOCAL_MODULES[shim];
+	if (!create) throw new Error(`wawesome: the guest surface declares the module '${shim}', and no local implementation is registered for it.`);
+	const exports = create(projectDir);
+	return {
+		...exports,
+		default: exports
+	};
+}
+/** Where `wawesome deploy` would take the private files from, if anywhere. */
+function privateFilesDir(projectDir) {
+	const files = readFunctionConfig(projectDir)?.files;
+	return files ? path.resolve(projectDir, files) : null;
+}
+/**
+* The platform's own rules over a listing read fresh on every call, so a file
+* edited while the dev server runs is what the next request reads.
+*/
+function localFsPromises(projectDir) {
+	const dir = privateFilesDir(projectDir);
+	const current = () => onDisk(dir);
+	return Object.fromEntries(Object.entries(onDisk(null)).map(([name, value]) => [name, typeof value === "function" ? (...args) => current()[name](...args) : value]));
+}
+function onDisk(dir) {
+	const files = dir ? listFiles(dir) : [];
+	const byPath = new Map(files.map((file) => [file.path, file]));
+	return privateFiles(files.map((file) => [file.path, file.size_bytes]), async (key) => {
+		const file = byPath.get(key);
+		if (!file) return new Response(null, { status: 404 });
+		if (file.size_bytes > 8388608) return new Response(`one invocation may read at most ${MAX_PRIVATE_FILE_READ_BYTES} bytes of private files`, { status: 413 });
+		try {
+			return new Response(await fs.promises.readFile(file.source));
+		} catch {
+			return new Response(null, { status: 404 });
+		}
+	});
+}
+//#endregion
+export { localModule as n, privateFilesDir as r, MAX_PRIVATE_FILE_READ_BYTES as t };

package/dist/local-modules.d.mts

@@ -0,0 +1,16 @@
+//#region src/local-modules.d.ts
+type LocalModule = Record<string, unknown> & {
+  default: Record<string, unknown>;
+};
+/**
+ * `DEFAULT_MAX_PRIVATE_FILE_READ_BYTES` in the runner. Production counts it over
+ * every read of one invocation; a local run has no invocation, so it holds for
+ * each read alone.
+ */
+declare const MAX_PRIVATE_FILE_READ_BYTES: number;
+/** A declared module as the guest gets it, backed by the project on disk. */
+declare function localModule(shim: string, projectDir: string): LocalModule;
+/** Where `wawesome deploy` would take the private files from, if anywhere. */
+declare function privateFilesDir(projectDir: string): string | null;
+//#endregion
+export { LocalModule, MAX_PRIVATE_FILE_READ_BYTES, localModule, privateFilesDir };

package/dist/local-modules.mjs

@@ -0,0 +1,2 @@
+import { n as localModule, r as privateFilesDir, t as MAX_PRIVATE_FILE_READ_BYTES } from "./local-modules-DvEInmfO.mjs";
+export { MAX_PRIVATE_FILE_READ_BYTES, localModule, privateFilesDir };

package/dist/vite.d.mts

@@ -18,6 +18,12 @@ interface WawesomeReactOptions {
  * route and answer with an empty shell that fails to hydrate. Every URL it
  * carries is a **Request-time base** away from the mount.
  */
-declare function wawesomeReact(options?: WawesomeReactOptions): Plugin;
+declare function wawesomeReact(options?: WawesomeReactOptions): Plugin[];
+/**
+ * Hands the server code the dev server runs the platform's `node:fs/promises`,
+ * reading the project's `files` folder. Only the build leaves the import for
+ * the platform, so this is a no-op there.
+ */
+declare function wawesomePrivateFiles(): Plugin;
 //#endregion
-export { WawesomeReactOptions, wawesomeReact as default, wawesomeReact };
+export { WawesomeReactOptions, wawesomeReact as default, wawesomeReact, wawesomePrivateFiles };

package/dist/vite.mjs

@@ -1,7 +1,11 @@
-import { i as polyfilledGlobals, o as unsupportedGlobals, r as methodRemedy, t as declaredMethods } from "./guest-surface-BwrNP2Cz.mjs";
+import { i as polyfilledGlobals, n as declaredModules, o as unsupportedGlobals, r as methodRemedy, t as declaredMethods } from "./guest-surface-BwrNP2Cz.mjs";
+import { n as localModule, r as privateFilesDir, t as MAX_PRIVATE_FILE_READ_BYTES } from "./local-modules-DvEInmfO.mjs";
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 //#region src/vite.ts
+const LOCAL_MODULE_PREFIX = "\0wawesome:module:";
+const LOCAL_MODULES_FILE = fileURLToPath(new URL(`./local-modules${path.extname(fileURLToPath(import.meta.url))}`, import.meta.url));
 const DOCUMENT_MODULE_ID = "virtual:wawesome/document";
 const BASE_MODULE_ID = "virtual:wawesome/base";
 const RESOLVED_DOCUMENT = `\0${DOCUMENT_MODULE_ID}`;
@@ -32,7 +36,7 @@ function wawesomeReact(options = {}) {
 	let root = process.cwd();
 	let dev = null;
 	let clientBuild = null;
-	return {
+	return [wawesomePrivateFiles(), {
 		name: "wawesome:react-ssr",
 		config(_userConfig, env) {
 			const building = env.command === "build";
@@ -124,6 +128,52 @@ function wawesomeReact(options = {}) {
 			}
 			return documentModule(html, clientEntry, clientBuild);
 		}
+	}];
+}
+/**
+* Hands the server code the dev server runs the platform's `node:fs/promises`,
+* reading the project's `files` folder. Only the build leaves the import for
+* the platform, so this is a no-op there.
+*/
+function wawesomePrivateFiles() {
+	const shims = new Map(declaredModules().flatMap((module) => module.specifiers.map((specifier) => [specifier, module.shim])));
+	let root = process.cwd();
+	return {
+		name: "wawesome:private-files",
+		apply: "serve",
+		enforce: "pre",
+		config() {
+			return { resolve: { alias: [...shims.keys()].map((specifier) => ({
+				find: new RegExp(`^${specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`),
+				replacement: specifier
+			})) } };
+		},
+		configResolved(config) {
+			root = config.root;
+		},
+		configureServer(server) {
+			const dir = privateFilesDir(root);
+			if (!dir) return;
+			server.config.logger.info(`  wawesome  node:fs/promises reads ${path.relative(root, dir) || "."} here, as on the guest`);
+			server.config.logger.warn(`            each read here may take ${MAX_PRIVATE_FILE_READ_BYTES / 1024 / 1024} MiB; the guest counts that over a whole invocation`);
+		},
+		resolveId(id) {
+			if (this.environment.config.consumer !== "server") return;
+			const shim = shims.get(id);
+			if (shim) return LOCAL_MODULE_PREFIX + shim;
+		},
+		load(id) {
+			if (!id.startsWith(LOCAL_MODULE_PREFIX)) return;
+			const shim = id.slice(17);
+			const names = Object.keys(localModule(shim, root)).filter((name) => name !== "default");
+			return [
+				`import { localModule } from ${JSON.stringify(LOCAL_MODULES_FILE)};`,
+				`const module = localModule(${JSON.stringify(shim)}, ${JSON.stringify(root)});`,
+				`export const { ${names.join(", ")} } = module;`,
+				"export default module.default;",
+				""
+			].join("\n");
+		}
 	};
 }
 /**
@@ -244,4 +294,4 @@ function normalize(file) {
 	return file.replace(/\\/g, "/").replace(/^\.?\//, "");
 }
 //#endregion
-export { wawesomeReact as default, wawesomeReact };
+export { wawesomeReact as default, wawesomeReact, wawesomePrivateFiles };

package/dist/vitest-setup.mjs

@@ -1,5 +1,12 @@
+import { n as declaredModules } from "./guest-surface-BwrNP2Cz.mjs";
 import { t as applyGuestParity } from "./guest-parity-DA7x-8BC.mjs";
+import { n as localModule } from "./local-modules-DvEInmfO.mjs";
+import { vi } from "vitest";
 //#region src/vitest-setup.ts
 applyGuestParity();
+for (const declared of declaredModules()) {
+	const module = localModule(declared.shim, process.cwd());
+	for (const specifier of declared.specifiers) vi.doMock(specifier, () => module);
+}
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wawesome",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "CLI tool for building and deploying serverless functions on wawesome.io platform",
   "license": "MIT",
   "type": "module",
@@ -69,11 +69,15 @@
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
-    "vite": "^8.0.0"
+    "vite": "^8.0.0",
+    "vitest": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "vite": {
       "optional": true
+    },
+    "vitest": {
+      "optional": true
     }
   }
 }