alepha 0.13.5 → 0.13.7

package/dist/core/index.js

@@ -2,11 +2,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import cluster from "node:cluster";
 import { cpus } from "node:os";
 import { Compile } from "typebox/compile";
-import * as TypeBox from "typebox";
 import { Type } from "typebox";
-import TypeBoxFormat from "typebox/format";
+import Format from "typebox/format";
 import { Locale } from "typebox/system";
-import * as TypeBoxValue from "typebox/value";
+import * as Value from "typebox/value";
 
 //#region ../../src/core/constants/KIND.ts
 /**
@@ -700,7 +699,7 @@ var StateManager = class {
 		const key = atom.key;
 		if (!this.atoms.has(key)) {
 			this.atoms.set(key, atom);
-			if (!(key in this.store)) this.set(key, atom.options.default);
+			if (!(key in this.store)) this.set(key, atom.options.default, { skipContext: true });
 		}
 		return this;
 	}
@@ -710,15 +709,15 @@ var StateManager = class {
 		const store = this.store;
 		return this.als?.exists() ? this.als.get(key) ?? store[key] : store[key];
 	}
-	set(target, value) {
+	set(target, value, options) {
 		if (target instanceof Atom) this.register(target);
 		const key = target instanceof Atom ? target.key : target;
 		const store = this.store;
 		const prevValue = this.get(key);
 		if (prevValue === value) return this;
-		if (this.als?.exists()) this.als.set(key, value);
+		if (options?.skipContext !== true && this.als?.exists()) this.als.set(key, value);
 		else store[key] = value;
-		this.events?.emit("state:mutate", {
+		if (options?.skipEvents !== true) this.events?.emit("state:mutate", {
 			key,
 			value,
 			prevValue
@@ -744,9 +743,9 @@ var StateManager = class {
 	/**
 	* Push a value to an array in the state
 	*/
-	push(key, value) {
+	push(key, ...value) {
 		const current = this.get(key) ?? [];
-		if (Array.isArray(current)) this.set(key, [...current, value]);
+		if (Array.isArray(current)) this.set(key, [...current, ...value]);
 		return this;
 	}
 	/**
@@ -899,10 +898,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
+			};
+			if (process.env.NODE_ENV === "production") state.env.NODE_ENV ??= "production";
+		}
 		const alepha = new Alepha(state);
 		if (alepha.isTest()) {
 			const g = globalThis;
@@ -941,12 +943,6 @@ var Alepha = class Alepha {
 	*/
 	starting;
 	/**
-	* Initial state of the container.
-	*
-	* > Used to initialize the StateManager.
-	*/
-	init;
-	/**
 	* During the instantiation process, we keep a list of pending instantiations.
 	* > It allows us to detect circular dependencies.
 	*/
@@ -983,30 +979,21 @@ var Alepha = class Alepha {
 	*
 	* Mocked for browser environments.
 	*/
-	get context() {
-		return this.inject(AlsProvider);
-	}
+	context;
 	/**
 	* Event manager to handle lifecycle events and custom events.
 	*/
-	get events() {
-		return this.inject(EventManager, { args: [() => this.log] });
-	}
+	events;
 	/**
 	* State manager to store arbitrary values.
 	*/
-	get store() {
-		this.events;
-		return this.inject(StateManager, { args: [this.init] });
-	}
+	store;
 	/**
 	* Codec manager for encoding and decoding data with different formats.
 	*
 	* Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
 	*/
-	get codec() {
-		return this.inject(CodecManager);
-	}
+	codec;
 	/**
 	* Get logger instance.
 	*/
@@ -1019,8 +1006,12 @@ var Alepha = class Alepha {
 	get env() {
 		return this.store.get("env") ?? {};
 	}
-	constructor(init = {}) {
-		this.init = init;
+	constructor(state = {}) {
+		this.store = this.inject(StateManager, { args: [state] });
+		this.events = this.inject(EventManager);
+		this.events.logFn = () => this.log;
+		this.context = this.inject(AlsProvider);
+		this.codec = this.inject(CodecManager);
 	}
 	set(target, value) {
 		this.store.set(target, value);
@@ -1087,7 +1078,7 @@ var Alepha = class Alepha {
 	isServerless() {
 		if (this.isBrowser()) return false;
 		if (this.env.VERCEL_REGION) return true;
-		if (this.env.ALEPHA_SERVERLESS) return true;
+		if (typeof global === "object" && typeof global.Cloudflare === "object") return true;
 		return false;
 	}
 	/**
@@ -1125,7 +1116,6 @@ var Alepha = class Alepha {
 			this.log?.warn("App is already starting, waiting for it to finish...");
 			return this.starting.promise;
 		}
-		this.codec;
 		this.starting = Promise.withResolvers();
 		const now = Date.now();
 		this.log?.info("Starting App...");
@@ -1305,6 +1295,19 @@ var Alepha = class Alepha {
 		return config;
 	}
 	/**
+	* Get all environment variable schemas and their parsed values.
+	*
+	* This is useful for DevTools to display all expected environment variables.
+	*/
+	getEnvSchemas() {
+		const result = [];
+		for (const [schema, values] of this.cacheEnv.entries()) result.push({
+			schema,
+			values
+		});
+		return result;
+	}
+	/**
 	* Dump the current dependency graph of the App.
 	*
 	* This method returns a record where the keys are the names of the services.
@@ -1459,33 +1462,27 @@ const isFileLike = (value) => {
 
 //#endregion
 //#region ../../src/core/providers/TypeProvider.ts
-const isUUID = TypeBoxFormat.IsUuid;
-const isEmail = TypeBoxFormat.IsEmail;
-const isURL = TypeBoxFormat.IsUrl;
-const isDateTime = TypeBoxFormat.IsDateTime;
-const isDate = TypeBoxFormat.IsDate;
-const isTime = TypeBoxFormat.IsTime;
-const isDuration = TypeBoxFormat.IsDuration;
+const isUUID = Format.IsUuid;
 var TypeGuard = class {
-	isBigInt = (value) => TypeBox.IsString(value) && "format" in value && value.format === "bigint";
-	isUUID = (value) => TypeBox.IsString(value) && "format" in value && value.format === "uuid";
-	isObject = TypeBox.IsObject;
-	isNumber = TypeBox.IsNumber;
-	isString = TypeBox.IsString;
-	isBoolean = TypeBox.IsBoolean;
-	isAny = TypeBox.IsAny;
-	isArray = TypeBox.IsArray;
-	isOptional = TypeBox.IsOptional;
-	isUnion = TypeBox.IsUnion;
-	isInteger = TypeBox.IsInteger;
-	isNull = TypeBox.IsNull;
-	isUndefined = TypeBox.IsUndefined;
-	isUnsafe = TypeBox.IsUnsafe;
-	isRecord = TypeBox.IsRecord;
-	isTuple = TypeBox.IsTuple;
-	isVoid = TypeBox.IsVoid;
-	isLiteral = TypeBox.IsLiteral;
-	isSchema = TypeBox.IsSchema;
+	isBigInt = (value) => Type.IsString(value) && "format" in value && value.format === "bigint";
+	isUUID = (value) => Type.IsString(value) && "format" in value && value.format === "uuid";
+	isObject = Type.IsObject;
+	isNumber = Type.IsNumber;
+	isString = Type.IsString;
+	isBoolean = Type.IsBoolean;
+	isAny = Type.IsAny;
+	isArray = Type.IsArray;
+	isOptional = Type.IsOptional;
+	isUnion = Type.IsUnion;
+	isInteger = Type.IsInteger;
+	isNull = Type.IsNull;
+	isUndefined = Type.IsUndefined;
+	isUnsafe = Type.IsUnsafe;
+	isRecord = Type.IsRecord;
+	isTuple = Type.IsTuple;
+	isVoid = Type.IsVoid;
+	isLiteral = Type.IsLiteral;
+	isSchema = Type.IsSchema;
 	isFile = isTypeFile;
 	isDateTime = (schema) => {
 		return t.schema.isString(schema) && schema.format === "date-time";
@@ -1501,9 +1498,9 @@ var TypeGuard = class {
 	};
 };
 var TypeProvider = class TypeProvider {
-	static format = TypeBoxFormat;
+	static format = Format;
 	static {
-		TypeBoxFormat.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
+		Format.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
 	}
 	static translateError(error, locale) {
 		if (!locale) return error.cause.message;
@@ -1902,6 +1899,192 @@ var TypeProvider = class TypeProvider {
 };
 const t = new TypeProvider();
 
+//#endregion
+//#region ../../src/core/helpers/jsonSchemaToTypeBox.ts
+/**
+* Converts a JSON Schema object to a TypeBox schema using Alepha's type system.
+*
+* This is useful when receiving JSON Schema from an API (e.g., configuration schemas)
+* and needing to use them with TypeBox-based form rendering or validation.
+*
+* **Supports:**
+* - Basic types: string, number, integer, boolean, null, object, array
+* - String formats: email, uuid, date-time, date, time, url/uri, binary, bigint, duration, color
+* - Enums (string enums)
+* - Nested objects with required/optional properties
+* - Arrays with item schemas
+* - Common validation options: minLength, maxLength, minimum, maximum, pattern
+*
+* **Not supported:**
+* - oneOf, anyOf, allOf, not (composition schemas)
+* - $ref (references)
+* - additionalProperties, patternProperties
+*
+* @param schema - JSON Schema object to convert
+* @returns TypeBox TSchema
+*
+* @example
+* ```ts
+* const jsonSchema = {
+*   type: "object",
+*   properties: {
+*     email: { type: "string", format: "email" },
+*     age: { type: "integer", minimum: 0 },
+*     active: { type: "boolean" },
+*   },
+*   required: ["email"]
+* };
+*
+* const typeBoxSchema = jsonSchemaToTypeBox(jsonSchema);
+* // Equivalent to:
+* // t.object({
+* //   email: t.email(),
+* //   age: t.optional(t.integer({ minimum: 0 })),
+* //   active: t.optional(t.boolean()),
+* // })
+* ```
+*/
+function jsonSchemaToTypeBox(schema) {
+	if (schema["~kind"]) return schema;
+	if (schema.const !== void 0) return t.const(schema.const);
+	if (schema.enum && Array.isArray(schema.enum)) {
+		if (schema.enum.every((v) => typeof v === "string")) return t.enum(schema.enum, filterUndefined({
+			title: schema.title,
+			description: schema.description,
+			default: schema.default
+		}));
+		return t.union(schema.enum.map((v) => t.const(v)));
+	}
+	switch (Array.isArray(schema.type) ? schema.type[0] : schema.type) {
+		case "string": return convertString(schema);
+		case "number": return convertNumber(schema);
+		case "integer": return convertInteger(schema);
+		case "boolean": return convertBoolean(schema);
+		case "null": return t.null();
+		case "object": return convertObject(schema);
+		case "array": return convertArray(schema);
+		default:
+			if (schema.properties) return convertObject(schema);
+			return t.any();
+	}
+}
+/**
+* Remove undefined values from an object.
+*/
+function filterUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== void 0));
+}
+/**
+* Convert JSON Schema string type to TypeBox.
+*/
+function convertString(schema) {
+	const options = filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minLength: schema.minLength,
+		maxLength: schema.maxLength,
+		pattern: schema.pattern
+	});
+	switch (schema.format) {
+		case "email": return t.email(options);
+		case "uuid": return t.uuid(options);
+		case "date-time": return t.datetime(options);
+		case "date": return t.date(options);
+		case "time": return t.time(options);
+		case "url":
+		case "uri": return t.url(options);
+		case "binary": return t.binary(options);
+		case "bigint": return t.bigint(options);
+		case "duration": return t.duration(options);
+		case "color": return t.text({
+			...options,
+			format: "color"
+		});
+		case "e164": return t.e164(options);
+		case "bcp47": return t.bcp47(options);
+		default:
+			if (schema.format) return t.text({
+				...options,
+				format: schema.format
+			});
+			return t.text(options);
+	}
+}
+/**
+* Convert JSON Schema number type to TypeBox.
+*/
+function convertNumber(schema) {
+	return t.number(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minimum: schema.minimum,
+		maximum: schema.maximum,
+		exclusiveMinimum: schema.exclusiveMinimum,
+		exclusiveMaximum: schema.exclusiveMaximum,
+		multipleOf: schema.multipleOf
+	}));
+}
+/**
+* Convert JSON Schema integer type to TypeBox.
+*/
+function convertInteger(schema) {
+	return t.integer(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minimum: schema.minimum,
+		maximum: schema.maximum,
+		exclusiveMinimum: schema.exclusiveMinimum,
+		exclusiveMaximum: schema.exclusiveMaximum,
+		multipleOf: schema.multipleOf
+	}));
+}
+/**
+* Convert JSON Schema boolean type to TypeBox.
+*/
+function convertBoolean(schema) {
+	return t.boolean(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default
+	}));
+}
+/**
+* Convert JSON Schema object type to TypeBox.
+*/
+function convertObject(schema) {
+	if (!schema.properties) return t.json(filterUndefined({
+		title: schema.title,
+		description: schema.description
+	}));
+	const required = new Set(schema.required ?? []);
+	const properties = {};
+	for (const [key, propSchema] of Object.entries(schema.properties)) {
+		let converted = jsonSchemaToTypeBox(propSchema);
+		if (!required.has(key)) converted = t.optional(converted);
+		properties[key] = converted;
+	}
+	return t.object(properties, filterUndefined({
+		title: schema.title,
+		description: schema.description
+	}));
+}
+/**
+* Convert JSON Schema array type to TypeBox.
+*/
+function convertArray(schema) {
+	const itemSchema = schema.items ? jsonSchemaToTypeBox(schema.items) : t.any();
+	return t.array(itemSchema, filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		minItems: schema.minItems,
+		maxItems: schema.maxItems,
+		uniqueItems: schema.uniqueItems
+	}));
+}
+
 //#endregion
 //#region ../../src/core/primitives/$env.ts
 /**
@@ -2094,6 +2277,20 @@ TypeProvider.prototype.page = (itemSchema) => pageSchema(itemSchema);
 
 //#endregion
 //#region ../../src/core/index.ts
+const AlephaCore = $module({
+	name: "alepha.core",
+	services: [
+		StateManager,
+		CodecManager,
+		EventManager,
+		AlsProvider,
+		Json,
+		JsonSchemaCodec,
+		SchemaCodec,
+		SchemaValidator
+	],
+	register: () => {}
+});
 /**
 * Run Alepha application, trigger start lifecycle.
 *
@@ -2125,7 +2322,7 @@ const run = (entry, opts) => {
 		withCluster(entry, opts);
 		return alepha;
 	}
-	(async () => {
+	setTimeout(async () => {
 		try {
 			await opts?.configure?.(alepha);
 			await alepha.start();
@@ -2155,7 +2352,7 @@ const run = (entry, opts) => {
 			alepha.log?.error("Alepha failed to start", error);
 			if (typeof process === "object") process.exit(1);
 		}
-	})();
+	});
 	return alepha;
 };
 AlsProvider.create = () => new AsyncLocalStorage();
@@ -2176,5 +2373,5 @@ const withCluster = (entry, opts) => {
 };
 
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, createPagination, createPrimitive, isClass, isDate, isDateTime, isDuration, isEmail, isFileLike, isTime, isTypeFile, isURL, isUUID, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaCore, 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 };
 //# sourceMappingURL=index.js.map