elysia 1.4.28 → 2.0.0-beta.0

package/dist/plugin/aot/source.js

@@ -0,0 +1,422 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils = require('../../utils.js');
+const require_universal_env = require('../../universal/env.js');
+const require_compile_aot = require('../../compile/aot.js');
+const require_compile_jit_probe = require('../../compile/jit-probe.js');
+const require_compile_handler_jit = require('../../compile/handler/jit.js');
+const require_validator_index = require('../../validator/index.js');
+const require_compile_handler_index = require('../../compile/handler/index.js');
+const require_compile_aot_emit = require('../../compile/aot-emit.js');
+const require_compile_aot_capture = require('../../compile/aot-capture.js');
+
+//#region src/plugin/aot/source.ts
+const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
+async function compileToSource(app, options) {
+	return (await captureArtifacts(app, options)).source;
+}
+async function captureArtifacts(app, options) {
+	const previousAotBuild = require_universal_env.env.ELYSIA_AOT_BUILD;
+	require_universal_env.env.ELYSIA_AOT_BUILD = "1";
+	try {
+		if (!require_compile_aot.Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
+		require_compile_aot_capture.beginValidatorCapture();
+		const modules = app.modules;
+		if (modules) await modules;
+		if (options?.target !== void 0) require_compile_handler_jit.setCaptureHeaderShorthand(options.target === "bun");
+		app.compile();
+		const captured = require_compile_aot_capture.endValidatorCapture();
+		const handlers = require_compile_aot_capture.endHandlerCapture();
+		const fingerprint = app["~aotFingerprint"] ?? require_compile_aot.createAotFingerprint();
+		return {
+			source: emitModule(captured, handlers, fingerprint, options),
+			validators: captured,
+			handlers,
+			fingerprint
+		};
+	} finally {
+		require_compile_handler_jit.setCaptureHeaderShorthand(void 0);
+		require_compile_aot_capture.abortCapture();
+		if (previousAotBuild === void 0) delete require_universal_env.env.ELYSIA_AOT_BUILD;
+		else require_universal_env.env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+const materialiseHandlersForReplay = (captured) => {
+	const manifest = {};
+	for (const h of captured) (manifest[h.method] ??= {})[h.path] = {
+		a: h.alias ? h.alias.split(",") : [],
+		f: new Function(`return ${require_compile_aot_emit.Source.handlerFactory(h.alias, h.code)}`)()
+	};
+	return manifest;
+};
+function replayStubbability(app, handlers) {
+	const previousCompiled = require_compile_aot_capture.snapshotCompiled();
+	const previousAotBuild = require_universal_env.env.ELYSIA_AOT_BUILD;
+	if (previousAotBuild !== void 0) delete require_universal_env.env.ELYSIA_AOT_BUILD;
+	try {
+		require_compile_aot.Compiled.clear();
+		const fingerprint = require_compile_aot.createAotFingerprint();
+		require_compile_aot.Compiled.register({
+			bf: 1,
+			fingerprint,
+			handlers: materialiseHandlersForReplay(handlers)
+		});
+		require_compile_aot.Compiled.claim(app["~programId"], fingerprint);
+		require_validator_index.Validator.clear();
+		const history = app["~routes"] ?? [];
+		require_compile_jit_probe.JITProbe.begin();
+		for (const route of history) try {
+			if (route[0] === "WS") continue;
+			require_compile_handler_index.compileHandler(route, app);
+		} catch {
+			require_compile_jit_probe.JITProbe.end();
+			return {
+				jit: false,
+				reasons: ["handler:new-function"]
+			};
+		}
+		return require_compile_jit_probe.JITProbe.end();
+	} finally {
+		require_compile_aot_capture.restoreCompiled(previousCompiled);
+		require_validator_index.Validator.clear();
+		if (previousAotBuild !== void 0) require_universal_env.env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+const checkIdRegex = /\bcheck_[0-9a-f]+\b/g;
+const normalizeCheckIdentifiers = (src) => {
+	const seen = /* @__PURE__ */ new Map();
+	return src.replace(checkIdRegex, (id) => {
+		let name = seen.get(id);
+		if (name === void 0) {
+			name = `_k${seen.size}`;
+			seen.set(id, name);
+		}
+		return name;
+	});
+};
+function createEntryEncoder() {
+	const branchRef = /* @__PURE__ */ new Map();
+	let branchDecls = "";
+	const branchTable = (u) => "[" + u.map((branch) => "[" + branch.map((b) => {
+		const src = normalizeCheckIdentifiers(require_compile_aot_emit.Source.checkFactory(b.identifier, b.code));
+		let ref = branchRef.get(src);
+		if (ref === void 0) {
+			ref = `_b${branchRef.size}`;
+			branchRef.set(src, ref);
+			branchDecls += `const ${ref} = ${src}\n`;
+		}
+		return ref;
+	}).join(", ") + "]").join(", ") + "]";
+	const unionRef = /* @__PURE__ */ new Map();
+	let unionDecls = "";
+	let hasCoercePlan = false;
+	const unionTable = (u) => {
+		const str = branchTable(u);
+		let ref = unionRef.get(str);
+		if (ref === void 0) {
+			ref = `_u${unionRef.size}`;
+			unionRef.set(str, ref);
+			unionDecls += `const ${ref} = ${str}\n`;
+		}
+		return ref;
+	};
+	return {
+		unionTable,
+		setCoercePlan() {
+			hasCoercePlan = true;
+		},
+		get branchDecls() {
+			return branchDecls;
+		},
+		get unionDecls() {
+			return unionDecls;
+		},
+		get hasCoercePlan() {
+			return hasCoercePlan;
+		}
+	};
+}
+function entryParts(c, enc) {
+	const parts = [];
+	const flags = [];
+	if (c.checkValue) {
+		if (c.external) flags.push("e:1");
+		if (c.async) flags.push("a:1");
+		if (c.hasDefault) flags.push("d:1");
+		if (c.hasCodec) flags.push("k:1");
+		if (c.hasRef) flags.push("r:1");
+	}
+	if (c.checkValue && c.mirror) {
+		const m = c.mirror;
+		parts.push(`cm: ${require_compile_aot_emit.Source.bothFactory(c.identifier, c.checkDefs, c.checkValue, m.source, m.hasExternals)}`, ...flags);
+		if (m.u) parts.push(`u: ${enc.unionTable(m.u)}`);
+	} else if (c.checkValue) parts.push(`c: ${require_compile_aot_emit.Source.checkFactory(c.identifier, require_compile_aot_emit.Source.checkCode(c.checkDefs, c.checkValue))}`, ...flags);
+	else if (c.mirror) {
+		const m = c.mirror;
+		let ms = `s: ${require_compile_aot_emit.Source.mirrorFactory(m.source, m.hasExternals)}`;
+		if (m.u) ms += `, u: ${enc.unionTable(m.u)}`;
+		parts.push(`m: { ${ms} }`);
+	}
+	if (c.decodeMirror) {
+		const dm = c.decodeMirror;
+		let dms = `s: ${require_compile_aot_emit.Source.mirrorFactory(dm.source, true)}`;
+		if (dm.u) dms += `, u: ${enc.unionTable(dm.u)}`;
+		parts.push(`dm: { ${dms} }`);
+	}
+	if (c.encodeMirror) {
+		const em = c.encodeMirror;
+		let ems = `s: ${require_compile_aot_emit.Source.mirrorFactory(em.source, true)}`;
+		if (em.u) ems += `, u: ${enc.unionTable(em.u)}`;
+		parts.push(`em: { ${ems} }`);
+	}
+	if (c.precomputeSafe) {
+		parts.push("ps: 1");
+		if (c.precomputedDefault !== void 0) parts.push(`pd: ${JSON.stringify(c.precomputedDefault)}`);
+		if (c.precomputeNull) parts.push("pn: 1");
+		if (c.precomputedObjectDefault !== void 0) parts.push(`pod: ${JSON.stringify(c.precomputedObjectDefault)}`);
+		if (c.defaultCloner) parts.push(`dc: ${c.defaultCloner}`);
+		if (c.objectDefaultMerger) parts.push(`pm: ${c.objectDefaultMerger}`);
+	}
+	if (c.customErrors?.length) {
+		const ce = c.customErrors.map((e) => `{ p: ${JSON.stringify(e.path)}, c: ${require_compile_aot_emit.Source.checkFactory(e.identifier, require_compile_aot_emit.Source.checkCode(e.checkDefs, e.checkValue))}${e.external ? ", e: 1" : ""} }`).join(", ");
+		parts.push(`ce: [${ce}]`);
+	}
+	if (c.innerCodecs?.length) {
+		const ic = c.innerCodecs.map((e) => {
+			let s = `o: ${e.open}, c: ${require_compile_aot_emit.Source.checkFactory(e.identifier, require_compile_aot_emit.Source.checkCode(e.checkDefs, e.checkValue))}`;
+			if (e.external) s += ", e: 1";
+			let ds = `s: ${require_compile_aot_emit.Source.mirrorFactory(e.decode.source, e.decode.hasExternals)}`;
+			if (e.decode.u) ds += `, u: ${enc.unionTable(e.decode.u)}`;
+			if (e.decode.hasExternals) ds += ", x: 1";
+			s += `, d: { ${ds} }`;
+			return `{ ${s} }`;
+		}).join(", ");
+		parts.push(`ic: [${ic}]`);
+	}
+	if (c.coercePlan) {
+		enc.setCoercePlan();
+		parts.push(`cp: ${JSON.stringify(c.coercePlan)}`);
+	}
+	return parts;
+}
+function emitModule(captured, handlers, fingerprint, options) {
+	const enc = createEntryEncoder();
+	const treeToSource = (tree, slotRef, sink) => {
+		const methods = [];
+		for (const method in tree) {
+			const paths = [];
+			for (const path in tree[method]) {
+				const slotObj = "{" + Object.entries(tree[method][path]).map(([slot, ref]) => `${JSON.stringify(slot)}:${ref}`).join(",") + "}";
+				let ref = slotRef.get(slotObj);
+				if (ref === void 0) {
+					ref = `_s${slotRef.size}`;
+					slotRef.set(slotObj, ref);
+					sink(`const ${ref} = ${slotObj}\n`);
+				}
+				paths.push(`${JSON.stringify(path)}:${ref}`);
+			}
+			methods.push(`${JSON.stringify(method)}:{${paths.join(",")}}`);
+		}
+		return `{${methods.join(",")}}`;
+	};
+	let validatorDecls = "";
+	let validatorExport = "";
+	const order = [];
+	const byRoute = /* @__PURE__ */ new Map();
+	for (const c of captured) {
+		const key = `${c.method}\0${c.path}`;
+		let arr = byRoute.get(key);
+		if (!arr) {
+			byRoute.set(key, arr = []);
+			order.push(key);
+		}
+		arr.push(c);
+	}
+	const autoSize = autoGroupSize(order.length);
+	const lazy = options?.lazy ?? Math.ceil(order.length / autoSize) > 128;
+	if (lazy) {
+		const groupSize = typeof lazy === "number" ? lazy : autoSize;
+		const groupCount = Math.ceil(order.length / groupSize);
+		const groupOf = require_utils.nullObject();
+		const groupOfRoute = /* @__PURE__ */ new Map();
+		for (let i = 0; i < order.length; i++) {
+			const key = order[i];
+			const g = Math.floor(i / groupSize);
+			groupOfRoute.set(key, g);
+			const sep = key.indexOf("\0");
+			(groupOf[key.slice(0, sep)] ??= require_utils.nullObject())[key.slice(sep + 1)] = g;
+		}
+		const entries = /* @__PURE__ */ new Map();
+		const routeSlots = /* @__PURE__ */ new Map();
+		for (const [key, cs] of byRoute) {
+			const g = groupOfRoute.get(key);
+			const slots = [];
+			for (const c of cs) {
+				const parts = entryParts(c, enc);
+				if (!parts.length) continue;
+				const entrySrc = normalizeCheckIdentifiers(`{ ${parts.join(", ")} }`);
+				let e = entries.get(entrySrc);
+				if (!e) {
+					e = {
+						ref: `_c${entries.size}`,
+						groups: /* @__PURE__ */ new Set()
+					};
+					entries.set(entrySrc, e);
+				}
+				e.groups.add(g);
+				slots.push([c.slot, entrySrc]);
+			}
+			routeSlots.set(key, slots);
+		}
+		for (const [src, e] of entries) if (e.groups.size > 1) validatorDecls += `const ${e.ref} = ${src}\n`;
+		let slotCounter = 0;
+		const groupRouteKeys = [];
+		const keySlotSrc = /* @__PURE__ */ new Map();
+		const slotStat = /* @__PURE__ */ new Map();
+		for (let g = 0; g < groupCount; g++) {
+			const keys = [];
+			const end = Math.min((g + 1) * groupSize, order.length);
+			for (let i = g * groupSize; i < end; i++) {
+				const key = order[i];
+				const slots = routeSlots.get(key);
+				if (!slots.length) continue;
+				keys.push(key);
+				let safe = true;
+				const slotSrc = "{" + slots.map(([slot, entrySrc]) => {
+					const e = entries.get(entrySrc);
+					if (e.groups.size === 1) safe = false;
+					return `${JSON.stringify(slot)}:${e.ref}`;
+				}).join(",") + "}";
+				keySlotSrc.set(key, slotSrc);
+				let stat = slotStat.get(slotSrc);
+				if (!stat) {
+					stat = {
+						groups: /* @__PURE__ */ new Set(),
+						safe
+					};
+					slotStat.set(slotSrc, stat);
+				}
+				stat.groups.add(g);
+				if (!safe) stat.safe = false;
+			}
+			groupRouteKeys.push(keys);
+		}
+		const hoistedSlotRef = /* @__PURE__ */ new Map();
+		for (const [src, stat] of slotStat) if (stat.groups.size > 1 && stat.safe) {
+			const ref = `_s${slotCounter++}`;
+			hoistedSlotRef.set(src, ref);
+			validatorDecls += `const ${ref} = ${src}\n`;
+		}
+		const thunks = [];
+		for (let g = 0; g < groupCount; g++) {
+			let localDecls = "";
+			const emitted = /* @__PURE__ */ new Set();
+			const localSlotRef = /* @__PURE__ */ new Map();
+			const byMethod = /* @__PURE__ */ new Map();
+			for (const key of groupRouteKeys[g]) {
+				const sep = key.indexOf("\0");
+				const method = key.slice(0, sep);
+				const path = key.slice(sep + 1);
+				for (const [, entrySrc] of routeSlots.get(key)) {
+					const e = entries.get(entrySrc);
+					if (e.groups.size === 1 && !emitted.has(entrySrc)) {
+						emitted.add(entrySrc);
+						localDecls += `const ${e.ref} = ${entrySrc}\n`;
+					}
+				}
+				const slotSrc = keySlotSrc.get(key);
+				let ref = hoistedSlotRef.get(slotSrc);
+				if (ref === void 0) {
+					ref = localSlotRef.get(slotSrc);
+					if (ref === void 0) {
+						ref = `_s${slotCounter++}`;
+						localSlotRef.set(slotSrc, ref);
+						localDecls += `const ${ref} = ${slotSrc}\n`;
+					}
+				}
+				let paths = byMethod.get(method);
+				if (!paths) byMethod.set(method, paths = []);
+				paths.push(`${JSON.stringify(path)}:${ref}`);
+			}
+			const sliceStr = "{" + [...byMethod.entries()].map(([method, paths]) => `${JSON.stringify(method)}:{${paths.join(",")}}`).join(",") + "}";
+			thunks.push(`() => {\n${localDecls}return ${sliceStr}\n}`);
+		}
+		validatorDecls += `const _groups = [${thunks.join(", ")}]\n`;
+		validatorDecls += `const _groupOf = ${JSON.stringify(groupOf)}\n`;
+		validatorExport = options?.register ? "" : "export const groups = _groups\nexport const groupOf = _groupOf\n";
+	} else {
+		const factoryRef = /* @__PURE__ */ new Map();
+		const tree = require_utils.nullObject();
+		for (const c of captured) {
+			const parts = entryParts(c, enc);
+			if (!parts.length) continue;
+			const entrySrc = normalizeCheckIdentifiers(`{ ${parts.join(", ")} }`);
+			let ref = factoryRef.get(entrySrc);
+			if (ref === void 0) {
+				ref = `_c${factoryRef.size}`;
+				factoryRef.set(entrySrc, ref);
+				validatorDecls += `const ${ref} = ${entrySrc}\n`;
+			}
+			const byPath = tree[c.method] ??= require_utils.nullObject();
+			(byPath[c.path] ??= require_utils.nullObject())[c.slot] = ref;
+		}
+		const treeStr = treeToSource(tree, /* @__PURE__ */ new Map(), (d) => {
+			validatorDecls += d;
+		});
+		validatorExport = options?.register ? `const validators = ${treeStr}\n` : `export const validators = ${treeStr}\n`;
+	}
+	const aliasRef = /* @__PURE__ */ new Map();
+	const handlerRef = /* @__PURE__ */ new Map();
+	let handlerDecls = "";
+	const handlerTree = require_utils.nullObject();
+	for (const h of handlers) {
+		const src = require_compile_aot_emit.Source.handlerFactory(h.alias, h.code);
+		let wref = handlerRef.get(src);
+		if (wref === void 0) {
+			const n = handlerRef.size;
+			let aref = aliasRef.get(h.alias);
+			if (aref === void 0) {
+				aref = `_a${aliasRef.size}`;
+				aliasRef.set(h.alias, aref);
+				handlerDecls += `const ${aref} = ${JSON.stringify(h.alias ? h.alias.split(",") : [])}\n`;
+			}
+			wref = `_w${n}`;
+			handlerRef.set(src, wref);
+			handlerDecls += `const _h${n} = ${src}\nconst ${wref} = { a: ${aref}, f: _h${n} }\n`;
+		}
+		(handlerTree[h.method] ??= {})[h.path] = wref;
+	}
+	let handlerExport = options?.register ? "const handlers = {\n" : "export const handlers = {\n";
+	for (const method in handlerTree) {
+		handlerExport += `\t${JSON.stringify(method)}: {\n`;
+		for (const path in handlerTree[method]) handlerExport += `\t\t${JSON.stringify(path)}: ${handlerTree[method][path]},\n`;
+		handlerExport += "	},\n";
+	}
+	handlerExport += "}\n";
+	const fingerprintExport = options?.register ? `export const fingerprint = ${JSON.stringify(fingerprint)}\n` : "";
+	let body = "// Generated by Elysia build plugin. Do not edit.\n";
+	if (options?.register) body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\n`;
+	if (options?.register && enc.hasCoercePlan) body += `import { buildCoercedFromPlan } from ${JSON.stringify("elysia/coerce-plan")}\n`;
+	if (options?.register && captured.length) body += `import { Reconstruct } from ${JSON.stringify(options.reconstructFrom ?? "elysia/reconstruct")}\n`;
+	const generated = enc.branchDecls + enc.unionDecls + validatorDecls + handlerDecls;
+	const needs = (symbol) => new RegExp(`\\b${symbol}\\b`).test(generated);
+	if (needs("CheckContext")) body += "import { CheckContext } from 'typebox/schema'\n";
+	if (needs("Guard")) body += "import { Guard } from 'typebox/guard'\n";
+	if (needs("Format")) body += "import { Format } from 'typebox/format'\n";
+	if (needs("Hashing")) body += "import { Hashing } from 'typebox/system'\n";
+	if (options?.register) {
+		body += "\n";
+		if (captured.length) body += "Compiled.reconstruct = Reconstruct\n";
+		body += fingerprintExport + "Compiled.register((() => {\n" + enc.branchDecls + (enc.branchDecls && "\n") + enc.unionDecls + (enc.unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport + "\nreturn { bf: 1, fingerprint, " + (lazy ? "lazyGroups: _groups, lazyGroupOf: _groupOf, " : "validators, ") + `handlers${enc.hasCoercePlan ? ", planRebuilder: buildCoercedFromPlan" : ""} }\n})())
+`;
+	} else {
+		body += "\n" + enc.branchDecls + (enc.branchDecls && "\n") + enc.unionDecls + (enc.unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport + "\n";
+		if (!lazy) body += "\nexport default validators\n";
+	}
+	return body;
+}
+
+//#endregion
+exports.autoGroupSize = autoGroupSize;
+exports.captureArtifacts = captureArtifacts;
+exports.compileToSource = compileToSource;
+exports.replayStubbability = replayStubbability;