alepha 0.14.3 → 0.15.0

package/dist/core/index.browser.js

@@ -1,7 +1,7 @@
-import { Compile } from "typebox/compile";
 import { Type } from "typebox";
 import Format from "typebox/format";
 import * as Value from "typebox/value";
+import { Compile } from "typebox/compile";
 
 //#region ../../src/core/constants/KIND.ts
 /**
@@ -310,7 +310,7 @@ var AlsProvider = class AlsProvider {
 		if (!this.als) return callback();
 		data.registry ??= /* @__PURE__ */ new Map();
 		data.context ??= this.createContextId();
-		return this.als.run(data, callback);
+		return this.als.run({ ...data }, callback);
 	}
 	exists() {
 		return !!this.get("context");
@@ -395,84 +395,6 @@ var JsonSchemaCodec = class extends SchemaCodec {
 	}
 };
 
-//#endregion
-//#region ../../src/core/errors/TypeBoxError.ts
-var TypeBoxError = class extends AlephaError {
-	name = "TypeBoxError";
-	cause;
-	value;
-	constructor(error) {
-		super(`Invalid input: ${error.message}${error.instancePath ? ` at ${error.instancePath}` : ""}`, { cause: error });
-		const params = error.params;
-		if (params?.requiredProperties) this.value = {
-			path: `/${params.requiredProperties[0]}`,
-			message: "must be defined"
-		};
-		else this.value = {
-			path: error.instancePath,
-			message: error.message
-		};
-		this.cause = error;
-	}
-};
-
-//#endregion
-//#region ../../src/core/primitives/$hook.ts
-/**
-* Registers a new hook.
-*
-* ```ts
-* import { $hook } from "alepha";
-*
-* class MyProvider {
-*   onStart = $hook({
-*     name: "start", // or "configure", "ready", "stop", ...
-*     handler: async (app) => {
-*       // await db.connect(); ...
-*     }
-*   });
-* }
-* ```
-*
-* Hooks are used to run async functions from all registered providers/services.
-*
-* You can't register a hook after the App has started.
-*
-* It's used under the hood by the `configure`, `start`, and `stop` methods.
-* Some modules also use hooks to run their own logic. (e.g. `alepha/server`).
-*
-* You can create your own hooks by using module augmentation:
-*
-* ```ts
-* declare module "alepha" {
-*
-*   interface Hooks {
-*     "my:custom:hook": {
-*       arg1: string;
-*     }
-*   }
-* }
-*
-* await alepha.events.emit("my:custom:hook", { arg1: "value" });
-* ```
-*
-*/
-const $hook = (options) => createPrimitive(HookPrimitive, options);
-var HookPrimitive = class extends Primitive {
-	called = 0;
-	onInit() {
-		this.alepha.events.on(this.options.on, {
-			caller: this.config.service,
-			priority: this.options.priority,
-			callback: async (args) => {
-				this.called += 1;
-				await this.options.handler(args);
-			}
-		});
-	}
-};
-$hook[KIND] = HookPrimitive;
-
 //#endregion
 //#region ../../src/core/helpers/FileLike.ts
 const isTypeFile = (value) => {
@@ -907,6 +829,322 @@ var TypeProvider = class TypeProvider {
 };
 const t = new TypeProvider();
 
+//#endregion
+//#region ../../src/core/providers/KeylessJsonSchemaCodec.ts
+/**
+* KeylessJsonSchemaCodec provides schema-driven JSON encoding without keys.
+*
+* It uses the schema to determine field order, allowing the encoded output
+* to be a simple JSON array instead of an object with keys.
+*
+* Performance characteristics:
+* - Encode: 0.94-1.53x vs JSON.stringify (faster for complex objects)
+* - Decode: 1.76-2.00x vs JSON.parse
+* - Size: 50-56% smaller than JSON
+*/
+var KeylessJsonSchemaCodec = class extends SchemaCodec {
+	cache = /* @__PURE__ */ new Map();
+	encoder = new TextEncoder();
+	decoder = new TextDecoder();
+	varCounter = 0;
+	/**
+	* Encode value to a keyless JSON string.
+	*/
+	encodeToString(schema, value) {
+		return this.getCodec(schema).encode(value);
+	}
+	/**
+	* Encode value to binary (UTF-8 encoded keyless JSON).
+	*/
+	encodeToBinary(schema, value) {
+		return this.encoder.encode(this.encodeToString(schema, value));
+	}
+	/**
+	* Decode keyless JSON string or binary to value.
+	*/
+	decode(schema, value) {
+		if (value instanceof Uint8Array) {
+			const text = this.decoder.decode(value);
+			return this.getCodec(schema).decode(text);
+		}
+		if (typeof value === "string") return this.getCodec(schema).decode(value);
+		if (Array.isArray(value)) return this.reconstructObject(schema, value);
+		return value;
+	}
+	/**
+	* Get a compiled codec for the given schema.
+	* Codecs are cached for reuse.
+	*/
+	getCodec(schema) {
+		let c = this.cache.get(schema);
+		if (!c) {
+			c = this.compile(schema);
+			this.cache.set(schema, c);
+		}
+		return c;
+	}
+	nextVar() {
+		return `_${this.varCounter++}`;
+	}
+	compile(schema) {
+		this.varCounter = 0;
+		const encBody = this.genEnc(schema, "v");
+		this.varCounter = 0;
+		const decBody = this.genDec(schema);
+		return {
+			encode: new Function("v", `return JSON.stringify(${encBody});`),
+			decode: new Function("s", `const a=JSON.parse(s);let i=0;${decBody.code}return ${decBody.result};`)
+		};
+	}
+	genEnc(schema, ve) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return ve;
+		if (t.schema.isBigInt(schema)) return `${ve}+'n'`;
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			const itemEnc = this.genEnc(arrSchema.items, "e");
+			if (t.schema.isString(arrSchema.items) || t.schema.isNumber(arrSchema.items) || t.schema.isInteger(arrSchema.items) || t.schema.isBoolean(arrSchema.items)) return ve;
+			return `${ve}.map(e=>${itemEnc})`;
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			const parts = [];
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				const innerEnc = this.genEnc(inner, `${ve}.${k}`);
+				if (isOpt) parts.push(`${ve}.${k}!==undefined?${innerEnc}:null`);
+				else if (isNullable) parts.push(`${ve}.${k}!==null?${innerEnc}:null`);
+				else parts.push(innerEnc);
+			}
+			return `[${parts.join(",")}]`;
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			const innerEnc = this.genEnc(inner, ve);
+			if (this.isNullable(schema)) return `${ve}!==null?${innerEnc}:null`;
+			return `${ve}!==undefined?${innerEnc}:null`;
+		}
+		return ve;
+	}
+	genDec(schema) {
+		const v = this.nextVar();
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return {
+			code: "",
+			result: "a[i++]"
+		};
+		if (t.schema.isBigInt(schema)) return {
+			code: "",
+			result: "BigInt(a[i++].slice(0,-1))"
+		};
+		if (t.schema.isArray(schema)) {
+			const arrSchema = schema;
+			if (t.schema.isObject(arrSchema.items)) return {
+				code: "",
+				result: `a[i++].map(e=>${this.genDecFromValue(arrSchema.items, "e")})`
+			};
+			return {
+				code: "",
+				result: "a[i++]"
+			};
+		}
+		if (t.schema.isObject(schema)) {
+			const objSchema = schema;
+			const props = objSchema.properties;
+			const keys = Object.keys(props);
+			const req = new Set(objSchema.required || []);
+			let simple = true;
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				if (isOpt || isNullable || t.schema.isObject(inner) || t.schema.isArray(inner)) {
+					simple = false;
+					break;
+				}
+			}
+			if (simple) return {
+				code: "",
+				result: `{${keys.map((k) => `${k}:a[i++]`).join(",")}}`
+			};
+			let code = `const ${v}={};`;
+			for (const k of keys) {
+				const ps = props[k];
+				const isOpt = !req.has(k) || t.schema.isOptional(ps);
+				const isNullable = this.isNullable(ps);
+				const inner = this.unwrap(ps);
+				if (isOpt) {
+					const nested = this.genDecFromValue(inner, "t");
+					code += `{const t=a[i++];if(t!==null){${v}.${k}=${nested};}}`;
+				} else if (isNullable) {
+					const nested = this.genDecFromValue(inner, "t");
+					code += `{const t=a[i++];if(t===null){${v}.${k}=null;}else{${v}.${k}=${nested};}}`;
+				} else if (t.schema.isObject(inner)) {
+					const nested = this.genDecFromValue(inner, "a[i++]");
+					code += `${v}.${k}=${nested};`;
+				} else if (t.schema.isArray(inner)) {
+					const arrSchema = inner;
+					if (t.schema.isObject(arrSchema.items)) {
+						const itemTransform = this.genDecFromValue(arrSchema.items, "e");
+						code += `${v}.${k}=a[i++].map(e=>${itemTransform});`;
+					} else code += `${v}.${k}=a[i++];`;
+				} else code += `${v}.${k}=a[i++];`;
+			}
+			return {
+				code,
+				result: v
+			};
+		}
+		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+			const inner = this.unwrap(schema);
+			const innerDec = this.genDec(inner);
+			return {
+				code: `const ${v}t=a[i++];let ${v};if(${v}t===null){${v}=${this.isNullable(schema) ? "null" : "undefined"};}else{${innerDec.code.replace(/a\[i\+\+\]/g, `${v}t`)}${v}=${innerDec.result.replace(/a\[i\+\+\]/g, `${v}t`)};}`,
+				result: v
+			};
+		}
+		return {
+			code: "",
+			result: "a[i++]"
+		};
+	}
+	genDecFromValue(schema, expr) {
+		if (t.schema.isString(schema) || t.schema.isNumber(schema) || t.schema.isInteger(schema) || t.schema.isBoolean(schema) || this.isEnum(schema)) return expr;
+		if (t.schema.isBigInt(schema)) return `BigInt(${expr}.slice(0,-1))`;
+		if (t.schema.isArray(schema)) return expr;
+		if (t.schema.isObject(schema)) {
+			const props = schema.properties;
+			const keys = Object.keys(props);
+			const v = this.nextVar();
+			return `((${v}=${expr})=>({${keys.map((k, idx) => {
+				const inner = this.unwrap(props[k]);
+				const innerExpr = `${v}[${idx}]`;
+				if (t.schema.isObject(inner)) return `${k}:${this.genDecFromValue(inner, innerExpr)}`;
+				if (t.schema.isBigInt(inner)) return `${k}:BigInt(${innerExpr}.slice(0,-1))`;
+				return `${k}:${innerExpr}`;
+			}).join(",")}}))()`;
+		}
+		return expr;
+	}
+	isEnum(schema) {
+		return "enum" in schema && Array.isArray(schema.enum) && (schema.enum?.length ?? 0) > 0;
+	}
+	isNullable(schema) {
+		if (!t.schema.isUnion(schema)) return false;
+		return schema.anyOf?.some((s) => t.schema.isNull(s)) ?? false;
+	}
+	unwrap(schema) {
+		if ("anyOf" in schema && Array.isArray(schema.anyOf)) return schema.anyOf.find((s) => !t.schema.isNull(s)) || schema;
+		return schema;
+	}
+	/**
+	* Reconstruct an object from a parsed array (for when input is already parsed).
+	*/
+	reconstructObject(schema, arr) {
+		if (!t.schema.isObject(schema)) return arr;
+		const props = schema.properties;
+		const keys = Object.keys(props);
+		const result = {};
+		let i = 0;
+		for (const k of keys) {
+			const ps = props[k];
+			const isOpt = t.schema.isOptional(ps);
+			const isNullable = this.isNullable(ps);
+			const inner = this.unwrap(ps);
+			const val = arr[i++];
+			if (isOpt) {
+				if (val !== null) result[k] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			} else if (isNullable) result[k] = val === null ? null : t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			else result[k] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region ../../src/core/errors/TypeBoxError.ts
+var TypeBoxError = class extends AlephaError {
+	name = "TypeBoxError";
+	cause;
+	value;
+	constructor(error) {
+		super(`Invalid input: ${error.message}${error.instancePath ? ` at ${error.instancePath}` : ""}`, { cause: error });
+		const params = error.params;
+		if (params?.requiredProperties) this.value = {
+			path: `/${params.requiredProperties[0]}`,
+			message: "must be defined"
+		};
+		else this.value = {
+			path: error.instancePath,
+			message: error.message
+		};
+		this.cause = error;
+	}
+};
+
+//#endregion
+//#region ../../src/core/primitives/$hook.ts
+/**
+* Registers a new hook.
+*
+* ```ts
+* import { $hook } from "alepha";
+*
+* class MyProvider {
+*   onStart = $hook({
+*     name: "start", // or "configure", "ready", "stop", ...
+*     handler: async (app) => {
+*       // await db.connect(); ...
+*     }
+*   });
+* }
+* ```
+*
+* Hooks are used to run async functions from all registered providers/services.
+*
+* You can't register a hook after the App has started.
+*
+* It's used under the hood by the `configure`, `start`, and `stop` methods.
+* Some modules also use hooks to run their own logic. (e.g. `alepha/server`).
+*
+* You can create your own hooks by using module augmentation:
+*
+* ```ts
+* declare module "alepha" {
+*
+*   interface Hooks {
+*     "my:custom:hook": {
+*       arg1: string;
+*     }
+*   }
+* }
+*
+* await alepha.events.emit("my:custom:hook", { arg1: "value" });
+* ```
+*
+*/
+const $hook = (options) => createPrimitive(HookPrimitive, options);
+var HookPrimitive = class extends Primitive {
+	called = 0;
+	onInit() {
+		const handler = this.options.handler;
+		this.alepha.events.on(this.options.on, {
+			caller: this.config.service,
+			priority: this.options.priority,
+			callback: (args) => {
+				this.called += 1;
+				return handler(args);
+			}
+		});
+	}
+};
+$hook[KIND] = HookPrimitive;
+
 //#endregion
 //#region ../../src/core/providers/SchemaValidator.ts
 var SchemaValidator = class {
@@ -1001,19 +1239,26 @@ var SchemaValidator = class {
 var CodecManager = class {
 	codecs = /* @__PURE__ */ new Map();
 	jsonCodec = $inject(JsonSchemaCodec);
+	keylessCodec = $inject(KeylessJsonSchemaCodec);
 	schemaValidator = $inject(SchemaValidator);
 	default = "json";
 	constructor() {
-		this.register(this.default, this.jsonCodec);
+		this.register({
+			name: "json",
+			codec: this.jsonCodec,
+			default: true
+		});
+		this.register({
+			name: "keyless",
+			codec: this.keylessCodec
+		});
 	}
 	/**
 	* Register a new codec format.
-	*
-	* @param name - The name of the codec (e.g., 'json', 'protobuf')
-	* @param codec - The codec implementation
 	*/
-	register(name, codec) {
-		this.codecs.set(name, codec);
+	register(opts) {
+		this.codecs.set(opts.name, opts.codec);
+		if (opts.default) this.default = opts.name;
 	}
 	/**
 	* Get a specific codec by name.
@@ -1092,35 +1337,110 @@ var EventManager = class {
 		};
 	}
 	/**
+	* Compiles an event into an optimized executor function.
+	*
+	* Call this after all hooks are registered (e.g., after Alepha.start()).
+	* The returned function checks each hook's return value and awaits promises.
+	* Returns undefined if all hooks are sync, or a Promise if any hook returns one.
+	*
+	* @example
+	* ```ts
+	* // At startup (after hooks are registered)
+	* const onRequest = alepha.events.compile("server:onRequest", { catch: true });
+	*
+	* // In hot path - only await if promise returned
+	* const result = onRequest({ request, route });
+	* if (result) await result;
+	* ```
+	*/
+	compile(event, options = {}) {
+		const hooks = this.events[event];
+		if (!hooks || hooks.length === 0) return () => {};
+		const catchErrors = options.catch ?? false;
+		const log = this.log;
+		const runRemainingAsync = async (startIndex, payload) => {
+			for (let i = startIndex; i < hooks.length; i++) {
+				const hook = hooks[i];
+				try {
+					const result = hook.callback(payload);
+					if (result && typeof result === "object" && "then" in result) if (catchErrors) await result.catch((error) => {
+						log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					});
+					else await result;
+				} catch (error) {
+					if (catchErrors) log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					else throw error;
+				}
+			}
+		};
+		return (payload) => {
+			for (let i = 0; i < hooks.length; i++) {
+				const hook = hooks[i];
+				try {
+					const result = hook.callback(payload);
+					if (result && typeof result === "object" && "then" in result) {
+						if (catchErrors) return result.catch((error) => {
+							log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+						}).then(() => runRemainingAsync(i + 1, payload));
+						return result.then(() => runRemainingAsync(i + 1, payload));
+					}
+				} catch (error) {
+					if (catchErrors) log?.error(`${String(event)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					else throw error;
+				}
+			}
+		};
+	}
+	/**
 	* Emits the specified event with the given payload.
+	*
+	* For hot paths (like HTTP request handling), use compile() instead
+	* to get an optimized executor.
 	*/
 	async emit(func, payload, options = {}) {
+		const events = this.events[func];
+		if (!events || events.length === 0) return;
+		if (events.length === 1 && !options.log && !options.reverse) {
+			const hook = events[0];
+			try {
+				const result = hook.callback(payload);
+				if (result && typeof result === "object" && "then" in result) await result;
+			} catch (error) {
+				if (options.catch) {
+					this.log?.error(`${String(func)}(${hook.caller?.name ?? "unknown"}) ERROR`, error);
+					return;
+				}
+				throw error;
+			}
+			return;
+		}
 		const ctx = {};
 		if (options.log) {
-			ctx.now = Date.now();
-			this.log?.trace(`${func} ...`);
+			ctx.now = performance.now();
+			this.log?.trace(`${String(func)} ...`);
 		}
-		let events = this.events[func] ?? [];
-		if (options.reverse) events = events.toReversed();
-		for (const hook of events) {
+		let eventList = events;
+		if (options.reverse) eventList = events.toReversed();
+		for (const hook of eventList) {
 			const name = hook.caller?.name ?? "unknown";
 			if (options.log) {
-				ctx.now2 = Date.now();
-				this.log?.trace(`${func}(${name}) ...`);
+				ctx.now2 = performance.now();
+				this.log?.trace(`${String(func)}(${name}) ...`);
 			}
 			try {
-				await hook.callback(payload);
+				const result = hook.callback(payload);
+				if (result && typeof result === "object" && "then" in result) await result;
 			} catch (error) {
 				if (options.catch) {
-					this.log?.error(`${func}(${name}) ERROR`, error);
+					this.log?.error(`${String(func)}(${name}) ERROR`, error);
 					continue;
 				}
-				if (options.log) throw new AlephaError(`Failed during '${func}()' hook for service: ${name}`, { cause: error });
+				if (options.log) throw new AlephaError(`Failed during '${String(func)}()' hook for service: ${name}`, { cause: error });
 				throw error;
 			}
-			if (options.log) this.log?.debug(`${func}(${name}) OK [${Date.now() - ctx.now2}ms]`);
+			if (options.log) this.log?.debug(`${String(func)}(${name}) OK [${(performance.now() - ctx.now2).toFixed(1)}ms]`);
 		}
-		if (options.log) this.log?.debug(`${func} OK [${Date.now() - ctx.now}ms]`);
+		if (options.log) this.log?.debug(`${String(func)} OK [${(performance.now() - ctx.now).toFixed(1)}ms]`);
 	}
 };
 
@@ -1404,10 +1724,13 @@ var Alepha = class Alepha {
 	* If you are not interested about these helpers, you can use the constructor directly.
 	*/
 	static create(state = {}) {
-		if (typeof process === "object" && typeof process.env === "object") state.env = {
-			...state.env,
-			...process.env
-		};
+		if (typeof process === "object" && typeof process.env === "object") {
+			state.env = {
+				...state.env,
+				...process.env
+			};
+			for (const key in state.env) if (state.env[key] === "") delete state.env[key];
+		}
 		const alepha = new Alepha(state);
 		if (alepha.isTest()) {
 			const g = globalThis;
@@ -1835,6 +2158,25 @@ var Alepha = class Alepha {
 		}
 		return graph;
 	}
+	dump() {
+		const env = {};
+		for (const [schema] of this.cacheEnv.entries()) {
+			const ref = schema;
+			for (const [key, value] of Object.entries(ref.properties)) {
+				const prop = value;
+				env[key] = {
+					description: prop.description,
+					default: prop.default,
+					required: ref.required?.includes(key) ?? void 0,
+					enum: prop.enum ? [...prop.enum] : void 0
+				};
+			}
+		}
+		return {
+			env,
+			providers: this.graph()
+		};
+	}
 	services(base) {
 		const list = [];
 		for (const [key, value] of this.registry.entries()) if (value.instance instanceof base) list.push(value.instance);
@@ -2306,5 +2648,5 @@ const run = (entry, opts) => {
 };
 
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, Value, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, KeylessJsonSchemaCodec, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, Value, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.browser.js.map