alepha 0.13.3 → 0.13.4

package/dist/core/index.d.ts

@@ -130,169 +130,6 @@ interface LoggerInterface {
   error(message: string, data?: unknown): void;
 }
 //#endregion
-//#region src/core/primitives/$inject.d.ts
-/**
- * Get the instance of the specified type from the context.
- *
- * ```ts
- * class A { }
- * class B {
- *   a = $inject(A);
- * }
- * ```
- */
-declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
-declare class InjectPrimitive extends Primitive {}
-interface InjectOptions<T extends object = any> {
-  /**
-   * - 'transient' → Always a new instance on every inject. Zero caching.
-   * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
-   * - 'scoped' → One instance per AsyncLocalStorage context.
-   *   - A new scope is created when Alepha handles a request, a scheduled job, a queue worker task...
-   *   - You can also start a manual scope via alepha.context.run(() => { ... }).
-   *   - When the scope ends, the scoped registry is discarded.
-   *
-   * @default "singleton"
-   */
-  lifetime?: "transient" | "singleton" | "scoped";
-  /**
-   * Constructor arguments to pass when creating a new instance.
-   */
-  args?: ConstructorParameters<InstantiableClass<T>>;
-  /**
-   * Parent that requested the instance.
-   *
-   * @internal
-   */
-  parent?: Service | null;
-}
-//#endregion
-//#region src/core/primitives/$module.d.ts
-/**
- * Wrap Services and Primitives into a Module.
- *
- * - A module is just a Service with some extra {@link Module}.
- * - You must attach a `name` to it.
- * - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
- *
- * @example
- * ```ts
- * import { $module } from "alepha";
- * import { MyService } from "./MyService.ts";
- *
- * // export MyService, so it can be used everywhere (optional)
- * export * from "./MyService.ts";
- *
- * export default $module({
- *  name: "my.project.module",
- *  // MyService will have a module context "my.project.module"
- *  services: [MyService],
- * });
- * ```
- *
- * ### Why Modules?
- *
- * #### Logging
- *
- * By default, AlephaLogger will log the module name in the logs.
- * This helps to identify where the logs are coming from.
- *
- * You can also set different log levels for different modules.
- * It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
- *
- * #### Modulith
- *
- * Force to structure your application in modules, even if it's a single deployable unit.
- * It helps to keep a clean architecture and avoid monolithic applications.
- *
- * A strict mode flag will probably come to enforce module boundaries.
- * -> Throwing errors when a service from another module is injected.
- * But it's not implemented yet.
- *
- * ### When not to use Modules?
- *
- * Small applications does not need modules. It's better to keep it simple.
- * Modules are more useful when the application grows and needs to be structured.
- * If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
- * Meaning that if you have 100 actions, you should have at least 3 modules.
- */
-declare const $module: <T extends object = {}>(options: ModulePrimitiveOptions) => Service<Module>;
-interface ModulePrimitiveOptions {
-  /**
-   * Name of the module.
-   *
-   * It should be in the format of `project.module.submodule`.
-   */
-  name: string;
-  /**
-   * List all services related to this module.
-   *
-   * If you don't declare 'register' function, all services will be registered automatically.
-   * If you declare 'register' function, you must handle the registration of ALL services manually.
-   */
-  services?: Array<Service>;
-  /**
-   * List of $primitives to register in the module.
-   */
-  primitives?: Array<PrimitiveFactoryLike>;
-  /**
-   * By default, module will register ALL services.
-   * You can override this behavior by providing a register function.
-   * It's useful when you want to register services conditionally or in a specific order.
-   *
-   * Again, if you declare 'register', you must handle the registration of ALL services manually.
-   */
-  register?: (alepha: Alepha) => void;
-}
-/**
- * Base class for all modules.
- */
-declare abstract class Module {
-  abstract readonly options: ModulePrimitiveOptions;
-  abstract register(alepha: Alepha): void;
-  static NAME_REGEX: RegExp;
-  /**
-   * Check if a Service is a Module.
-   */
-  static is(ctor: Service): boolean;
-  /**
-   * Get the Module of a Service.
-   *
-   * Returns undefined if the Service is not part of a Module.
-   */
-  static of(ctor: Service): Service<Module> | undefined;
-}
-/**
- * Helper type to add Module metadata to a Service.
- */
-type WithModule<T extends object = any> = T & {
-  [MODULE]?: Service;
-};
-//#endregion
-//#region src/core/providers/AlsProvider.d.ts
-type AsyncLocalStorageData = any;
-declare class AlsProvider {
-  static create: () => AsyncLocalStorage<AsyncLocalStorageData> | undefined;
-  als?: AsyncLocalStorage<AsyncLocalStorageData>;
-  constructor();
-  createContextId(): string;
-  run<R>(callback: () => R, data?: Record<string, any>): R;
-  exists(): boolean;
-  get<T>(key: string): T | undefined;
-  set<T>(key: string, value: T): void;
-}
-//#endregion
-//#region src/core/providers/Json.d.ts
-/**
- * Mimics the JSON global object with stringify and parse methods.
- *
- * Used across the codebase via dependency injection.
- */
-declare class Json {
-  stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
-  parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
-}
-//#endregion
 //#region src/core/errors/AlephaError.d.ts
 /**
  * Default error class for Alepha.
@@ -675,6 +512,225 @@ interface TTextOptions extends TStringOptions$1 {
 }
 declare const t: TypeProvider;
 //#endregion
+//#region src/core/primitives/$atom.d.ts
+/**
+ * Define an atom for state management.
+ *
+ * Atom lets you define a piece of state with a name, schema, and default value.
+ *
+ * By default, Alepha state is just a simple key-value store.
+ * Using atoms allows you to have type safety, validation, and default values for your state.
+ *
+ * You control how state is structured and validated.
+ *
+ * Features:
+ * - Set a schema for validation
+ * - Set a default value for initial state
+ * - Rules, like read-only, custom validation, etc.
+ * - Automatic getter access in services with {@link $use}
+ * - SSR support (server state automatically serialized and hydrated on client)
+ * - React integration (useAtom hook for automatic component re-renders)
+ * - Middleware
+ * - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
+ * - State migrations (version upgrades when schema changes)
+ * - Documentation generation & devtools integration
+ *
+ * Common use cases:
+ * - user preferences
+ * - feature flags
+ * - configuration options
+ * - session data
+ *
+ * Atom must contain only serializable data.
+ * Avoid storing complex objects like class instances, functions, or DOM elements.
+ * If you need to store complex data, consider using identifiers or references instead.
+ */
+declare const $atom: {
+  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
+  [KIND]: string;
+};
+type AtomOptions<T extends TAtomObject, N extends string> = {
+  name: N;
+  schema: T;
+  description?: string;
+} & (T extends TOptionalAdd<T> ? {
+  default?: Static<T>;
+} : {
+  default: Static<T>;
+});
+declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
+  readonly options: AtomOptions<T, N>;
+  get schema(): T;
+  get key(): N;
+  constructor(options: AtomOptions<T, N>);
+}
+type TProperties$2 = any;
+type TAtomObject = TObject<any> | TArray$1;
+type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
+//#endregion
+//#region src/core/primitives/$inject.d.ts
+/**
+ * Get the instance of the specified type from the context.
+ *
+ * ```ts
+ * class A { }
+ * class B {
+ *   a = $inject(A);
+ * }
+ * ```
+ */
+declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
+declare class InjectPrimitive extends Primitive {}
+interface InjectOptions<T extends object = any> {
+  /**
+   * - 'transient' → Always a new instance on every inject. Zero caching.
+   * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
+   * - 'scoped' → One instance per AsyncLocalStorage context.
+   *   - A new scope is created when Alepha handles a request, a scheduled job, a queue worker task...
+   *   - You can also start a manual scope via alepha.context.run(() => { ... }).
+   *   - When the scope ends, the scoped registry is discarded.
+   *
+   * @default "singleton"
+   */
+  lifetime?: "transient" | "singleton" | "scoped";
+  /**
+   * Constructor arguments to pass when creating a new instance.
+   */
+  args?: ConstructorParameters<InstantiableClass<T>>;
+  /**
+   * Parent that requested the instance.
+   *
+   * @internal
+   */
+  parent?: Service | null;
+}
+//#endregion
+//#region src/core/primitives/$module.d.ts
+/**
+ * Wrap Services and Primitives into a Module.
+ *
+ * - A module is just a Service with some extra {@link Module}.
+ * - You must attach a `name` to it.
+ * - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
+ *
+ * @example
+ * ```ts
+ * import { $module } from "alepha";
+ * import { MyService } from "./MyService.ts";
+ *
+ * // export MyService, so it can be used everywhere (optional)
+ * export * from "./MyService.ts";
+ *
+ * export default $module({
+ *  name: "my.project.module",
+ *  // MyService will have a module context "my.project.module"
+ *  services: [MyService],
+ * });
+ * ```
+ *
+ * ### Why Modules?
+ *
+ * #### Logging
+ *
+ * By default, AlephaLogger will log the module name in the logs.
+ * This helps to identify where the logs are coming from.
+ *
+ * You can also set different log levels for different modules.
+ * It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
+ *
+ * #### Modulith
+ *
+ * Force to structure your application in modules, even if it's a single deployable unit.
+ * It helps to keep a clean architecture and avoid monolithic applications.
+ *
+ * A strict mode flag will probably come to enforce module boundaries.
+ * -> Throwing errors when a service from another module is injected.
+ * But it's not implemented yet.
+ *
+ * ### When not to use Modules?
+ *
+ * Small applications does not need modules. It's better to keep it simple.
+ * Modules are more useful when the application grows and needs to be structured.
+ * If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
+ * Meaning that if you have 100 actions, you should have at least 3 modules.
+ */
+declare const $module: <T extends object = {}>(options: ModulePrimitiveOptions) => Service<Module>;
+interface ModulePrimitiveOptions {
+  /**
+   * Name of the module.
+   *
+   * It should be in the format of `project.module.submodule`.
+   */
+  name: string;
+  /**
+   * List all services related to this module.
+   *
+   * If you don't declare 'register' function, all services will be registered automatically.
+   * If you declare 'register' function, you must handle the registration of ALL services manually.
+   */
+  services?: Array<Service>;
+  /**
+   * List of $primitives to register in the module.
+   */
+  primitives?: Array<PrimitiveFactoryLike>;
+  /**
+   * By default, module will register ALL services.
+   * You can override this behavior by providing a register function.
+   * It's useful when you want to register services conditionally or in a specific order.
+   *
+   * Again, if you declare 'register', you must handle the registration of ALL services manually.
+   */
+  register?: (alepha: Alepha) => void;
+}
+/**
+ * Base class for all modules.
+ */
+declare abstract class Module {
+  abstract readonly options: ModulePrimitiveOptions;
+  abstract register(alepha: Alepha): void;
+  static NAME_REGEX: RegExp;
+  /**
+   * Check if a Service is a Module.
+   */
+  static is(ctor: Service): boolean;
+  /**
+   * Get the Module of a Service.
+   *
+   * Returns undefined if the Service is not part of a Module.
+   */
+  static of(ctor: Service): Service<Module> | undefined;
+}
+/**
+ * Helper type to add Module metadata to a Service.
+ */
+type WithModule<T extends object = any> = T & {
+  [MODULE]?: Service;
+};
+//#endregion
+//#region src/core/providers/AlsProvider.d.ts
+type AsyncLocalStorageData = any;
+declare class AlsProvider {
+  static create: () => AsyncLocalStorage<AsyncLocalStorageData> | undefined;
+  als?: AsyncLocalStorage<AsyncLocalStorageData>;
+  constructor();
+  createContextId(): string;
+  run<R>(callback: () => R, data?: Record<string, any>): R;
+  exists(): boolean;
+  get<T>(key: string): T | undefined;
+  set<T>(key: string, value: T): void;
+}
+//#endregion
+//#region src/core/providers/Json.d.ts
+/**
+ * Mimics the JSON global object with stringify and parse methods.
+ *
+ * Used across the codebase via dependency injection.
+ */
+declare class Json {
+  stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+  parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
+}
+//#endregion
 //#region src/core/providers/SchemaCodec.d.ts
 declare abstract class SchemaCodec {
   /**
@@ -844,62 +900,6 @@ declare class EventManager {
   }): Promise<void>;
 }
 //#endregion
-//#region src/core/primitives/$atom.d.ts
-/**
- * Define an atom for state management.
- *
- * Atom lets you define a piece of state with a name, schema, and default value.
- *
- * By default, Alepha state is just a simple key-value store.
- * Using atoms allows you to have type safety, validation, and default values for your state.
- *
- * You control how state is structured and validated.
- *
- * Features:
- * - Set a schema for validation
- * - Set a default value for initial state
- * - Rules, like read-only, custom validation, etc.
- * - Automatic getter access in services with {@link $use}
- * - SSR support (server state automatically serialized and hydrated on client)
- * - React integration (useAtom hook for automatic component re-renders)
- * - Middleware
- * - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
- * - State migrations (version upgrades when schema changes)
- * - Documentation generation & devtools integration
- *
- * Common use cases:
- * - user preferences
- * - feature flags
- * - configuration options
- * - session data
- *
- * Atom must contain only serializable data.
- * Avoid storing complex objects like class instances, functions, or DOM elements.
- * If you need to store complex data, consider using identifiers or references instead.
- */
-declare const $atom: {
-  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
-  [KIND]: string;
-};
-type AtomOptions<T extends TAtomObject, N extends string> = {
-  name: N;
-  schema: T;
-  description?: string;
-} & (T extends TOptionalAdd<T> ? {
-  default?: Static<T>;
-} : {
-  default: Static<T>;
-});
-declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
-  readonly options: AtomOptions<T, N>;
-  get schema(): T;
-  get key(): N;
-  constructor(options: AtomOptions<T, N>);
-}
-type TProperties$2 = any;
-type TAtomObject = TObject<any> | TArray$1;
-type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
-//#endregion
 //#region src/core/providers/StateManager.d.ts
 interface AtomWithValue {
   atom: Atom;
@@ -1176,6 +1176,8 @@ declare class Alepha {
    */
   get env(): Readonly<Env>;
   constructor(init?: 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;
   /**
    * True when start() is called.
    *

package/dist/core/index.js

@@ -283,7 +283,7 @@ const $module = (options) => {
 * Base class for all modules.
 */
 var Module = class Module {
-	static NAME_REGEX = /^[a-z]+(\.[a-z][a-z0-9-]*)*$/;
+	static NAME_REGEX = /^[a-z-]+(\.[a-z-][a-z0-9-]*)*$/;
 	/**
 	* Check if a Service is a Module.
 	*/
@@ -1022,6 +1022,10 @@ var Alepha = class Alepha {
 	constructor(init = {}) {
 		this.init = init;
 	}
+	set(target, value) {
+		this.store.set(target, value);
+		return this;
+	}
 	/**
 	* True when start() is called.
 	*