alepha 0.13.6 → 0.13.8

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Validator } from "typebox/compile";
-import * as TypeBox from "typebox";
-import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TInterface, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPartial, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid } from "typebox";
-import TypeBoxFormat from "typebox/format";
-import * as TypeBoxValue from "typebox/value";
+import * as typebox0 from "typebox";
+import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TInterface, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPartial, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid, Type } from "typebox";
+import Format from "typebox/format";
+import * as Value from "typebox/value";
 import { TLocalizedValidationError } from "typebox/error";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
@@ -216,33 +216,27 @@ type StreamLike = ReadableStream | ReadableStream$1 | Readable | NodeJS.Readable
 type TStream = TUnsafe$1<StreamLike>;
 //#endregion
 //#region ../../src/core/providers/TypeProvider.d.ts
-declare const isUUID: typeof TypeBoxFormat.IsUuid;
-declare const isEmail: typeof TypeBoxFormat.IsEmail;
-declare const isURL: typeof TypeBoxFormat.IsUrl;
-declare const isDateTime: typeof TypeBoxFormat.IsDateTime;
-declare const isDate: typeof TypeBoxFormat.IsDate;
-declare const isTime: typeof TypeBoxFormat.IsTime;
-declare const isDuration: typeof TypeBoxFormat.IsDuration;
+declare const isUUID: typeof Format.IsUuid;
 declare class TypeGuard {
   isBigInt: (value: TSchema$1) => value is TString$1;
   isUUID: (value: TSchema$1) => value is TString$1;
-  isObject: typeof TypeBox.IsObject;
-  isNumber: typeof TypeBox.IsNumber;
-  isString: typeof TypeBox.IsString;
-  isBoolean: typeof TypeBox.IsBoolean;
-  isAny: typeof TypeBox.IsAny;
-  isArray: typeof TypeBox.IsArray;
-  isOptional: typeof TypeBox.IsOptional;
-  isUnion: typeof TypeBox.IsUnion;
-  isInteger: typeof TypeBox.IsInteger;
-  isNull: typeof TypeBox.IsNull;
-  isUndefined: typeof TypeBox.IsUndefined;
-  isUnsafe: typeof TypeBox.IsUnsafe;
-  isRecord: typeof TypeBox.IsRecord;
-  isTuple: typeof TypeBox.IsTuple;
-  isVoid: typeof TypeBox.IsVoid;
-  isLiteral: typeof TypeBox.IsLiteral;
-  isSchema: typeof TypeBox.IsSchema;
+  isObject: typeof Type.IsObject;
+  isNumber: typeof Type.IsNumber;
+  isString: typeof Type.IsString;
+  isBoolean: typeof Type.IsBoolean;
+  isAny: typeof Type.IsAny;
+  isArray: typeof Type.IsArray;
+  isOptional: typeof Type.IsOptional;
+  isUnion: typeof Type.IsUnion;
+  isInteger: typeof Type.IsInteger;
+  isNull: typeof Type.IsNull;
+  isUndefined: typeof Type.IsUndefined;
+  isUnsafe: typeof Type.IsUnsafe;
+  isRecord: typeof Type.IsRecord;
+  isTuple: typeof Type.IsTuple;
+  isVoid: typeof Type.IsVoid;
+  isLiteral: typeof Type.IsLiteral;
+  isSchema: typeof Type.IsSchema;
   isFile: (value: TSchema$1) => value is TFile;
   isDateTime: (schema: unknown) => boolean;
   isDate: (schema: unknown) => boolean;
@@ -260,7 +254,7 @@ declare module "typebox" {
   }
 }
 declare class TypeProvider {
-  static format: typeof TypeBoxFormat;
+  static format: typeof Format;
   static translateError(error: TypeBoxError, locale?: string): string;
   static setLocale(locale: string): void;
   static isValidBigInt(value: string | number): boolean;
@@ -307,16 +301,16 @@ declare class TypeProvider {
    * It can be overridden in the array options.
    */
   static DEFAULT_ARRAY_MAX_ITEMS: number;
-  raw: typeof TypeBox.Type;
-  any: typeof TypeBox.Any;
-  void: typeof TypeBox.Void;
-  undefined: typeof TypeBox.Undefined;
-  record: typeof TypeBox.Record;
-  union: typeof TypeBox.Union;
-  tuple: typeof TypeBox.Tuple;
-  null: typeof TypeBox.Null;
-  const: typeof TypeBox.Literal;
-  options: typeof TypeBox.Options;
+  raw: typeof Type;
+  any: typeof Type.Any;
+  void: typeof Type.Void;
+  undefined: typeof Type.Undefined;
+  record: typeof Type.Record;
+  union: typeof Type.Union;
+  tuple: typeof Type.Tuple;
+  null: typeof Type.Null;
+  const: typeof Type.Literal;
+  options: typeof Type.Options;
   /**
    * Type guards to check the type of schema.
    * This is not a runtime type check, but a compile-time type guard.
@@ -372,7 +366,7 @@ declare class TypeProvider {
    * Create a schema for a JSON object.
    * This is a record with string keys and any values.
    */
-  json(options?: TSchemaOptions): TRecord$1<string, TAny$1>;
+  json<T = any>(options?: TSchemaOptions): TRecord$1<string, TAny$1>;
   /**
    * Create a schema for a boolean.
    */
@@ -405,13 +399,13 @@ declare class TypeProvider {
   /**
    * Create a schema that maps all properties of an object schema to nullable.
    */
-  nullify: <T extends TSchema$1>(schema: T, options?: TObjectOptions$1) => TypeBox.TMappedInstantiate<{}, {
+  nullify: <T extends TSchema$1>(schema: T, options?: TObjectOptions$1) => typebox0.TMappedInstantiate<{}, {
     callstack: [];
-  }, TypeBox.TIdentifier<"K">, TypeBox.TKeyOfInstantiate<{}, {
+  }, Type.TIdentifier<"K">, typebox0.TKeyOfInstantiate<{}, {
     callstack: [];
-  }, T>, TypeBox.TRef<"K">, TUnion$1<[TypeBox.TIndexInstantiate<{}, {
+  }, T>, Type.TRef<"K">, TUnion$1<[typebox0.TIndexInstantiate<{}, {
     callstack: [];
-  }, T, TypeBox.TRef<"K">>, TNull$1]>>;
+  }, T, Type.TRef<"K">>, TNull$1]>>;
   /**
    * Create a schema for a string enum.
    */
@@ -475,7 +469,7 @@ declare class TypeProvider {
   valueLabel: (options?: TObjectOptions$1) => TObject$1<{
     value: TString$1;
     label: TString$1;
-    description: TypeBox.TOptional<TString$1>;
+    description: Type.TOptional<TString$1>;
   }>;
   datetime: (options?: TStringOptions$1) => TString$1;
   date: (options?: TStringOptions$1) => TString$1;
@@ -759,7 +753,7 @@ declare class JsonSchemaCodec extends SchemaCodec {
 //#endregion
 //#region ../../src/core/providers/SchemaValidator.d.ts
 declare class SchemaValidator {
-  protected cache: Map<TSchema$1, Validator<TypeBox.TProperties, TSchema$1, unknown, unknown>>;
+  protected cache: Map<TSchema$1, Validator<typebox0.TProperties, TSchema$1, unknown, unknown>>;
   /**
    * Validate the value against the provided schema.
    *
@@ -863,7 +857,7 @@ declare class CodecManager {
 //#endregion
 //#region ../../src/core/providers/EventManager.d.ts
 declare class EventManager {
-  protected logFn?: () => LoggerInterface | undefined;
+  logFn?: () => LoggerInterface | undefined;
   /**
    * List of events that can be triggered. Powered by $hook().
    */
@@ -909,7 +903,7 @@ declare class StateManager<State$1 extends object = State> {
   protected readonly als: AlsProvider;
   protected readonly events: EventManager;
   protected readonly codec: JsonSchemaCodec;
-  protected readonly atoms: Map<keyof State$1, Atom<TObject$1<TypeBox.TProperties>, string>>;
+  protected readonly atoms: Map<keyof State$1, Atom<TObject$1<typebox0.TProperties>, string>>;
   protected store: Partial<State$1>;
   constructor(store?: Partial<State$1>);
   getAtoms(context?: boolean): Array<AtomWithValue>;
@@ -922,8 +916,8 @@ declare class StateManager<State$1 extends object = State> {
   /**
    * Set a value in the state
    */
-  set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>): this;
-  set<Key extends keyof State$1>(target: Key, value: State$1[Key] | undefined): this;
+  set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>, options?: SetStateOptions): this;
+  set<Key extends keyof State$1>(target: Key, value: State$1[Key] | undefined, options?: SetStateOptions): this;
   /**
    * Mutate a value in the state.
    */
@@ -940,7 +934,7 @@ declare class StateManager<State$1 extends object = State> {
   /**
    * Push a value to an array in the state
    */
-  push<Key extends keyof OnlyArray<State$1>>(key: Key, value: NonNullable<State$1[Key]> extends Array<infer U> ? U : never): this;
+  push<Key extends keyof OnlyArray<State$1>>(key: Key, ...value: Array<NonNullable<State$1[Key]> extends Array<infer U> ? U : never>): this;
   /**
    * Clear all state
    */
@@ -951,6 +945,10 @@ declare class StateManager<State$1 extends object = State> {
   keys(): (keyof State$1)[];
 }
 type OnlyArray<T extends object> = { [K in keyof T]: NonNullable<T[K]> extends Array<any> ? K : never };
+interface SetStateOptions {
+  skipContext?: boolean;
+  skipEvents?: boolean;
+}
 //#endregion
 //#region ../../src/core/Alepha.d.ts
 /**
@@ -1107,12 +1105,6 @@ declare class Alepha {
    * A promise that resolves when the App has started.
    */
   protected starting?: PromiseWithResolvers<this>;
-  /**
-   * Initial state of the container.
-   *
-   * > Used to initialize the StateManager.
-   */
-  protected init: Partial<State>;
   /**
    * During the instantiation process, we keep a list of pending instantiations.
    * > It allows us to detect circular dependencies.
@@ -1152,21 +1144,21 @@ declare class Alepha {
    *
    * Mocked for browser environments.
    */
-  get context(): AlsProvider;
+  context: AlsProvider;
   /**
    * Event manager to handle lifecycle events and custom events.
    */
-  get events(): EventManager;
+  events: EventManager;
   /**
    * State manager to store arbitrary values.
    */
-  get store(): StateManager<State>;
+  store: StateManager<State>;
   /**
    * Codec manager for encoding and decoding data with different formats.
    *
    * Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
    */
-  get codec(): CodecManager;
+  codec: CodecManager;
   /**
    * Get logger instance.
    */
@@ -1175,7 +1167,7 @@ declare class Alepha {
    * The environment variables for the App.
    */
   get env(): Readonly<Env>;
-  constructor(init?: Partial<State>);
+  constructor(state?: Partial<State>);
   set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>): this;
   set<Key extends keyof State>(target: Key, value: State[Key] | undefined): this;
   /**
@@ -1328,6 +1320,15 @@ declare class Alepha {
    * @return The schema object with environment variables applied.
    */
   parseEnv<T extends TObject$1>(schema: T): Static$1<T>;
+  /**
+   * Get all environment variable schemas and their parsed values.
+   *
+   * This is useful for DevTools to display all expected environment variables.
+   */
+  getEnvSchemas(): Array<{
+    schema: TSchema;
+    values: Record<string, any>;
+  }>;
   /**
    * Dump the current dependency graph of the App.
    *
@@ -1473,33 +1474,6 @@ interface Hooks {
   };
 }
 //#endregion
-//#region ../../src/core/interfaces/Run.d.ts
-interface RunOptions {
-  /**
-   * Environment variables to be used by the application.
-   * It will be merged with the current process environment.
-   */
-  env?: Env;
-  /**
-   * A callback that will be executed before the application starts.
-   */
-  configure?: (alepha: Alepha) => Async<void>;
-  /**
-   * A callback that will be executed once the application is ready.
-   * This is useful for initializing resources or starting background tasks.
-   */
-  ready?: (alepha: Alepha) => Async<void>;
-  /**
-   * If true, the application will .stop() after the ready callback is executed.
-   * Useful for one-time tasks!
-   */
-  once?: boolean;
-  /**
-   * If true, the application will run in cluster mode.
-   */
-  cluster?: boolean;
-}
-//#endregion
 //#region ../../src/core/constants/OPTIONS.d.ts
 /**
  * Used for primitives options.
@@ -1675,6 +1649,84 @@ declare function createPagination<T>(entities: T[], limit?: number, offset?: num
   direction: "asc" | "desc";
 }>): Page<T>;
 //#endregion
+//#region ../../src/core/helpers/jsonSchemaToTypeBox.d.ts
+/**
+ * JSON Schema representation for conversion to TypeBox.
+ */
+interface JsonSchemaObject {
+  type?: string | string[];
+  properties?: Record<string, JsonSchemaObject>;
+  required?: string[];
+  items?: JsonSchemaObject;
+  enum?: (string | number | boolean)[];
+  const?: unknown;
+  format?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  minLength?: number;
+  maxLength?: number;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  pattern?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  "~kind"?: string;
+  oneOf?: JsonSchemaObject[];
+  anyOf?: JsonSchemaObject[];
+  allOf?: JsonSchemaObject[];
+  not?: JsonSchemaObject;
+  $ref?: string;
+}
+/**
+ * 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()),
+ * // })
+ * ```
+ */
+declare function jsonSchemaToTypeBox(schema: JsonSchemaObject): TSchema$1;
+//#endregion
 //#region ../../src/core/interfaces/Pagination.d.ts
 /**
  * Generic pagination request parameters.
@@ -1908,7 +1960,35 @@ declare const pageQuerySchema: TObject<{
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
+//#region ../../src/core/interfaces/Run.d.ts
+interface RunOptions {
+  /**
+   * Environment variables to be used by the application.
+   * It will be merged with the current process environment.
+   */
+  env?: Env;
+  /**
+   * A callback that will be executed before the application starts.
+   */
+  configure?: (alepha: Alepha) => Async<void>;
+  /**
+   * A callback that will be executed once the application is ready.
+   * This is useful for initializing resources or starting background tasks.
+   */
+  ready?: (alepha: Alepha) => Async<void>;
+  /**
+   * If true, the application will .stop() after the ready callback is executed.
+   * Useful for one-time tasks!
+   */
+  once?: boolean;
+  /**
+   * If true, the application will run in cluster mode.
+   */
+  cluster?: boolean;
+}
+//#endregion
 //#region ../../src/core/index.d.ts
+declare const AlephaCore: Service<Module>;
 /**
  * Run Alepha application, trigger start lifecycle.
  *
@@ -1925,5 +2005,5 @@ type PageQuery = Static<typeof pageQuerySchema>;
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => Alepha;
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, ContainerLockedError, ContextPrimitive, DecodeOptions, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Hook, HookOptions, HookPrimitive, Hooks, InjectOptions, InjectPrimitive, InstantiableClass, JsonSchemaCodec, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModulePrimitiveOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactory, PrimitiveFactoryLike, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxErrorParams, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, 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, AbstractClass, Alepha, AlephaCore, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, ContainerLockedError, ContextPrimitive, DecodeOptions, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Format, Hook, HookOptions, HookPrimitive, Hooks, InjectOptions, InjectPrimitive, InstantiableClass, JsonSchemaCodec, JsonSchemaObject, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModulePrimitiveOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactory, PrimitiveFactoryLike, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SetStateOptions, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, Type, TypeBoxError, TypeBoxErrorParams, TypeGuard, TypeProvider, Value, WithModule, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.d.ts.map