@velajs/vela 1.18.0 → 1.19.1

package/dist/config/config.tokens.d.ts

@@ -1,13 +0,0 @@
-import { InjectionToken } from '../container/types';
-export declare const CONFIG_OPTIONS: InjectionToken<Record<string, unknown>>;
-/**
- * Ambient environment record consumed by config-namespace factories
- * (`registerAs`). It is the multi-runtime substitute for stratal's
- * Cloudflare-specific `env` token: core never touches `process.env`.
- *
- * The token self-provides `{}` by default (so factories resolve even with no
- * platform binding), and stays OVERRIDABLE — a platform adapter
- * (`@velajs/cloudflare`) or a future `./config-node` subpath provides a global
- * `CONFIG_ENV` and that registration wins over the default.
- */
-export declare const CONFIG_ENV: InjectionToken<Record<string, unknown>>;

package/dist/config/config.tokens.js

@@ -1,14 +0,0 @@
-import { InjectionToken } from "../container/types.js";
-export const CONFIG_OPTIONS = new InjectionToken('CONFIG_OPTIONS');
-/**
- * Ambient environment record consumed by config-namespace factories
- * (`registerAs`). It is the multi-runtime substitute for stratal's
- * Cloudflare-specific `env` token: core never touches `process.env`.
- *
- * The token self-provides `{}` by default (so factories resolve even with no
- * platform binding), and stays OVERRIDABLE — a platform adapter
- * (`@velajs/cloudflare`) or a future `./config-node` subpath provides a global
- * `CONFIG_ENV` and that registration wins over the default.
- */ export const CONFIG_ENV = new InjectionToken('CONFIG_ENV', {
-    factory: ()=>({})
-});

package/dist/config/config.types.d.ts

@@ -1,41 +0,0 @@
-import type { AnyConfigNamespace } from './register-as';
-/**
- * A schema for validating the fully-merged config. Kept structural so zod stays
- * an OPTIONAL peer — a zod schema (has `.parse`) or a plain function both work;
- * core never imports zod. Throwing rejects the config.
- */
-export type ConfigSchema = ((config: Record<string, unknown>) => unknown) | {
-    parse: (config: unknown) => unknown;
-};
-/**
- * Options for {@link ConfigModule}.
- *
- * NOTE: `load` and `validateSchema` are **`forRoot`-only** — they are read
- * structurally from the call-time options bag. On the `forRootAsync` path the
- * options come from a DI-resolved factory, so only the flat `config` record is
- * supported there (async namespaces are out of scope; declare them via
- * `forRoot`).
- */
-export interface ConfigModuleOptions<T extends Record<string, unknown> = Record<string, unknown>> {
-    /** Flat config record — the pre-namespace `config` path (still supported). */
-    config?: T;
-    /** Config namespaces created via `registerAs()`, merged under their namespace name. `forRoot`-only. */
-    load?: AnyConfigNamespace[];
-    /** Eager validator for the flat `config` record; runs at `forRoot()` call time. */
-    validate?: (config: T) => T;
-    /** Schema validating the MERGED config (flat + namespaces); runs lazily on first read. `forRoot`-only. */
-    validateSchema?: ConfigSchema;
-    isGlobal?: boolean;
-}
-/**
- * All valid dot-notation paths of a config object type.
- * @example `ConfigPath<{ database: { url: string } }>` → `'database' | 'database.url'`
- */
-export type ConfigPath<T> = {
-    [K in keyof T & string]: T[K] extends Record<string, unknown> ? K | `${K}.${ConfigPath<T[K]>}` : K;
-}[keyof T & string];
-/**
- * The value type at a dot-notation path.
- * @example `ConfigPathValue<{ database: { url: string } }, 'database.url'>` → `string`
- */
-export type ConfigPathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? T[K] extends Record<string, unknown> ? ConfigPathValue<T[K], Rest> : never : never : P extends keyof T ? T[P] : never;

package/dist/config/config.types.js

@@ -1,4 +0,0 @@
-/**
- * The value type at a dot-notation path.
- * @example `ConfigPathValue<{ database: { url: string } }, 'database.url'>` → `string`
- */ export { };

package/dist/config/index.d.ts

@@ -1,7 +0,0 @@
-export { ConfigModule } from './config.module';
-export { ConfigService } from './config.service';
-export { ConfigStore } from './config.store';
-export { CONFIG_OPTIONS, CONFIG_ENV } from './config.tokens';
-export { registerAs } from './register-as';
-export type { ConfigNamespace, AnyConfigNamespace, InferConfigType, ConfigType } from './register-as';
-export type { ConfigModuleOptions, ConfigSchema, ConfigPath, ConfigPathValue } from './config.types';

package/dist/config/index.js

@@ -1,5 +0,0 @@
-export { ConfigModule } from "./config.module.js";
-export { ConfigService } from "./config.service.js";
-export { ConfigStore } from "./config.store.js";
-export { CONFIG_OPTIONS, CONFIG_ENV } from "./config.tokens.js";
-export { registerAs } from "./register-as.js";

package/dist/config/register-as.d.ts

@@ -1,52 +0,0 @@
-import type { InjectionToken, ProviderOptions } from '../container/types';
-/**
- * The result of {@link registerAs}: a namespaced config factory plus the DI
- * token it is provided under.
- */
-export interface ConfigNamespace<TKey extends string = string, TEnv = Record<string, unknown>, TConfig extends object = object> {
-    /** Injection token for this namespace's resolved config (`Symbol.for('vela:config:<ns>')`). */
-    readonly KEY: InjectionToken<TConfig>;
-    /** The namespace name (e.g. `'database'`). */
-    readonly namespace: TKey;
-    /** Factory receiving the ambient env and returning the namespace config. */
-    readonly factory: (env: TEnv) => TConfig;
-    /** Provider registration injecting {@link CONFIG_ENV} — spread into a module's providers. */
-    asProvider(): ProviderOptions<TConfig>;
-}
-/** Any config namespace — structural typing for the module `load` list. */
-export type AnyConfigNamespace = ConfigNamespace<string, any, object>;
-/**
- * Create a namespaced configuration factory (NestJS `registerAs` parity).
- *
- * The `KEY` is minted with `Symbol.for` so it keeps a stable identity across
- * module re-evaluation (HMR / repeated imports) — a fresh `InjectionToken`
- * would mint a new identity each eval and break dedup. It is typed as
- * `InjectionToken<TConfig>` purely for injection-site DX.
- *
- * @example
- * ```ts
- * export const dbConfig = registerAs('database', (env: Env) => ({
- *   url: env.DATABASE_URL,
- *   pool: 10,
- * }));
- * // ConfigModule.forRoot({ load: [dbConfig] });
- * // cfg.get('database.url');                              // via ConfigService
- * // constructor(@Inject(dbConfig.KEY) db: InferConfigType<typeof dbConfig>) {}
- * ```
- */
-export declare function registerAs<TKey extends string, TEnv, TConfig extends object>(namespace: TKey, factory: (env: TEnv) => TConfig): ConfigNamespace<TKey, TEnv, TConfig>;
-/**
- * Extract a namespace's config shape from a {@link registerAs} result.
- *
- * @example `type Db = InferConfigType<typeof dbConfig>` → `{ url: string; pool: number }`
- */
-export type InferConfigType<T> = T extends ConfigNamespace<string, any, infer C> ? C : never;
-/**
- * Zero-codegen typed config shape from a tuple of namespaces — pass as the
- * `ConfigService` generic to type dot-notation reads.
- *
- * @example `ConfigService<ConfigType<[typeof dbConfig, typeof mailConfig]>>`
- */
-export type ConfigType<L extends readonly AnyConfigNamespace[]> = {
-    [N in L[number] as N['namespace']]: InferConfigType<N>;
-};

package/dist/config/register-as.js

@@ -1,39 +0,0 @@
-// Config-namespace registration. Design ported from stratal's `registerAs`
-// (MIT, © Temitayo Fadojutimi) and reworked for vela's multi-runtime DI: env
-// enters through the `CONFIG_ENV` token instead of a Cloudflare-specific one.
-import { CONFIG_ENV } from "./config.tokens.js";
-/**
- * Create a namespaced configuration factory (NestJS `registerAs` parity).
- *
- * The `KEY` is minted with `Symbol.for` so it keeps a stable identity across
- * module re-evaluation (HMR / repeated imports) — a fresh `InjectionToken`
- * would mint a new identity each eval and break dedup. It is typed as
- * `InjectionToken<TConfig>` purely for injection-site DX.
- *
- * @example
- * ```ts
- * export const dbConfig = registerAs('database', (env: Env) => ({
- *   url: env.DATABASE_URL,
- *   pool: 10,
- * }));
- * // ConfigModule.forRoot({ load: [dbConfig] });
- * // cfg.get('database.url');                              // via ConfigService
- * // constructor(@Inject(dbConfig.KEY) db: InferConfigType<typeof dbConfig>) {}
- * ```
- */ export function registerAs(namespace, factory) {
-    const KEY = Symbol.for(`vela:config:${namespace}`);
-    return {
-        KEY,
-        namespace,
-        factory,
-        asProvider () {
-            return {
-                provide: KEY,
-                useFactory: factory,
-                inject: [
-                    CONFIG_ENV
-                ]
-            };
-        }
-    };
-}

package/dist/constants.d.ts

@@ -1,44 +0,0 @@
-export declare const METADATA_KEYS: {
-    readonly INJECTABLE: "vela:injectable";
-    readonly INJECT: "vela:inject";
-    readonly SCOPE: "vela:scope";
-    readonly MODULE: "vela:module";
-    readonly MODULE_OPTIONS: "vela:module-options";
-    readonly CONTROLLER: "vela:controller";
-    readonly ROUTES: "vela:routes";
-    readonly PARAMS: "vela:params";
-    readonly HTTP_CODE: "vela:http-code";
-    readonly RESPONSE_HEADERS: "vela:response-headers";
-    readonly REDIRECT: "vela:redirect";
-    readonly CATCH: "vela:catch";
-    readonly CRUD: "vela:crud";
-};
-export declare const HttpMethod: {
-    readonly GET: "GET";
-    readonly POST: "POST";
-    readonly PUT: "PUT";
-    readonly PATCH: "PATCH";
-    readonly DELETE: "DELETE";
-    readonly OPTIONS: "OPTIONS";
-    readonly HEAD: "HEAD";
-    readonly ALL: "ALL";
-};
-export type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];
-export declare const ParamType: {
-    readonly BODY: "body";
-    readonly QUERY: "query";
-    readonly PARAM: "param";
-    readonly HEADERS: "headers";
-    readonly REQUEST: "request";
-    readonly RESPONSE: "response";
-    readonly IP: "ip";
-    readonly COOKIE: "cookie";
-    readonly RAW_BODY: "raw_body";
-};
-export type ParamType = (typeof ParamType)[keyof typeof ParamType];
-export declare const Scope: {
-    readonly SINGLETON: "singleton";
-    readonly TRANSIENT: "transient";
-    readonly REQUEST: "request";
-};
-export type Scope = (typeof Scope)[keyof typeof Scope];

package/dist/constants.js

@@ -1,46 +0,0 @@
-export const METADATA_KEYS = {
-    // DI
-    INJECTABLE: 'vela:injectable',
-    INJECT: 'vela:inject',
-    SCOPE: 'vela:scope',
-    // Module
-    MODULE: 'vela:module',
-    MODULE_OPTIONS: 'vela:module-options',
-    // HTTP
-    CONTROLLER: 'vela:controller',
-    ROUTES: 'vela:routes',
-    PARAMS: 'vela:params',
-    HTTP_CODE: 'vela:http-code',
-    RESPONSE_HEADERS: 'vela:response-headers',
-    REDIRECT: 'vela:redirect',
-    // Pipeline
-    CATCH: 'vela:catch',
-    // CRUD
-    CRUD: 'vela:crud'
-};
-export const HttpMethod = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    PATCH: 'PATCH',
-    DELETE: 'DELETE',
-    OPTIONS: 'OPTIONS',
-    HEAD: 'HEAD',
-    ALL: 'ALL'
-};
-export const ParamType = {
-    BODY: 'body',
-    QUERY: 'query',
-    PARAM: 'param',
-    HEADERS: 'headers',
-    REQUEST: 'request',
-    RESPONSE: 'response',
-    IP: 'ip',
-    COOKIE: 'cookie',
-    RAW_BODY: 'raw_body'
-};
-export const Scope = {
-    SINGLETON: 'singleton',
-    TRANSIENT: 'transient',
-    REQUEST: 'request'
-};

package/dist/container/container.d.ts

@@ -1,154 +0,0 @@
-import { Scope } from '../constants';
-import type { ContainerOptions, Diagnostics, LazyResolutionHook, ModuleDescription, ModuleScope, ProviderOptions, Token, Type } from './types';
-/**
- * Per-module provider buckets. Each module instance owns its providers under
- * its `moduleId`; the same logical token can have distinct registrations in
- * different buckets, supporting multi-instance dynamic modules.
- *
- * The `__root__` bucket holds bootstrap-time framework primitives (Container,
- * ModuleRef, REQUEST_CONTEXT, etc.) and any `register()` call that doesn't
- * supply a `declaringModuleId`.
- */
-export declare class Container {
-    private providers;
-    private exporterIndex;
-    private resolutionStack;
-    private requestInstances;
-    private scopes;
-    private globals;
-    private diagnostics;
-    private root;
-    private disposables;
-    private lazyHook?;
-    private asyncDepth;
-    constructor(options?: ContainerOptions);
-    /** Install the lazy-module seam (bootstrap-time; root container only). */
-    setLazyHook(hook: LazyResolutionHook): void;
-    private claimLazyModule;
-    private maybeDrainSync;
-    register<T>(provider: Type<T> | ProviderOptions<T>, declaringModuleId?: string): this;
-    private registerClass;
-    private registerOptions;
-    private writeRegistration;
-    registerScope(scope: ModuleScope): void;
-    markGlobalToken(token: Token): void;
-    setRequestInstance(token: Token, value: unknown): void;
-    getDiagnostics(): Diagnostics;
-    resolve<T>(token: Token<T>, requestingModuleId?: string): T;
-    resolveAll<T>(token: Token<T>, requestingModuleId?: string): T[];
-    /**
-     * Find a single reachable registration for a token, applying the visibility
-     * walk: requester's bucket → globals → requester's importedModules
-     * (transitively, following re-exports).
-     *
-     * Returns `undefined` if no candidate exists. Throws
-     * `MultipleProvidersFoundError` if the imports walk yields more than one.
-     */
-    private findRegistration;
-    /** Typed bucket lookup — single seam where the Map<Token, Registration> erases T. */
-    private lookupInBucket;
-    /**
-     * Walk a scope's imports (and their imports' imports, …) collecting every
-     * registration reachable through re-export chains. A child only contributes
-     * if it explicitly exports the token — non-exported providers stay private.
-     */
-    private collectFromImports;
-    private findAllRegistrations;
-    /** True if any bucket has a registration for `token`. Sandbox-friendly. */
-    has(token: Token): boolean;
-    /** True if the specified module's bucket has a registration for `token`. */
-    hasInScope(token: Token, moduleId: string): boolean;
-    /** Module buckets that hold a registration for `token` (registration order). */
-    getOwnerModuleIds(token: Token): string[];
-    /**
-     * Force-replace a provider across module scopes — the supported form of the
-     * override loop test harnesses need (module-scoped resolution consults the
-     * module's own bucket first, so a root-only override would never win there).
-     *
-     * - `'all-existing'` (default): every non-root bucket that already holds the
-     *   token, plus `__root__` (so framework-internal lookups see it too).
-     * - `'root'`: only the `__root__` bucket.
-     * - `string[]`: exactly these bucket ids.
-     */
-    replaceProvider<T>(provider: Type<T> | ProviderOptions<T>, options?: {
-        buckets?: 'all-existing' | 'root' | string[];
-    }): this;
-    /**
-     * True when the token belongs exclusively to lazy modules that have not
-     * been materialized yet — resolving it would trigger materialization.
-     * Build-time probes (route-manager middleware priority, entrypoint
-     * snapshots) use this to defer instead of forcing the group.
-     */
-    isLazyPending(token: Token): boolean;
-    /**
-     * True when any registration of the token holds a constructed instance.
-     * Diagnostic helper (cold-start tests): checks WITHOUT resolving, so it
-     * never triggers lazy materialization.
-     */
-    isInstantiated(token: Token): boolean;
-    getProviderScope(token: Token): Scope | undefined;
-    getTokens(): Token[];
-    /**
-     * Every statically-provided (useValue) instance across ALL module buckets.
-     * Unlike resolving a token (which yields only the first bucket's registration),
-     * this surfaces per-instance values — e.g. one BindingRef per multi-instance
-     * binding module — so framework adapters can initialize all of them.
-     */
-    getUseValues(): unknown[];
-    /**
-     * Serializable description of every loaded module instance (load order),
-     * plus the `__root__` bucket (bootstrap primitives) when non-empty —
-     * the `vela module graph` seam. Reads registration state only: safe pre-
-     * and post-bootstrap, never constructs, never claims lazy modules.
-     */
-    getModuleDescriptions(): ModuleDescription[];
-    /**
-     * Compute request-scope bubbling for every registration (call once at
-     * bootstrap, after all providers are registered). A provider whose declared
-     * scope is not REQUEST but which (transitively) depends on a request-scoped
-     * provider is marked `effectiveScope = REQUEST`, so it is rebuilt per request
-     * instead of capturing the first request's instance — matching NestJS.
-     */
-    computeEffectiveScopes(): void;
-    /** The dependency tokens a registration would resolve when constructed. */
-    private dependencyTokensOf;
-    private tryFindRegistration;
-    /**
-     * Create a child container for request-scoped resolution.
-     * The child shares the parent's providers but caches REQUEST-scoped
-     * instances separately per child (per request).
-     */
-    createChild(): Container;
-    createDetached(): Container;
-    clear(): void;
-    /** Whether this container has any tracked disposables (cheap request-path check). */
-    hasDisposables(): boolean;
-    /**
-     * Dispose container-constructed instances (Symbol.asyncDispose /
-     * Symbol.dispose / .dispose()) in reverse creation order (LIFO). Errors are
-     * logged and skipped so one bad teardown never blocks the rest.
-     *
-     * A REQUEST child disposes only its own request-scoped instances; the root
-     * disposes shared SINGLETONs and clears their cached instance so a dev HMR
-     * generation cannot leak a stale graph. Shared provider maps are left intact
-     * for a request child (they belong to the root).
-     */
-    dispose(): Promise<void>;
-    private resolveRegistration;
-    private resolveClass;
-    /**
-     * Resolve one factory `inject` dependency. Since 1.11 the declaring module's
-     * scope is consulted FIRST (proper visibility semantics — a `forRootAsync`
-     * factory can inject providers reachable through its module's imports); on
-     * any failure the legacy no-requester lookup (root bucket, then first
-     * exporter) is kept as fallback, so every previously-resolving graph still
-     * resolves.
-     */
-    private resolveFactoryDependency;
-    private resolveFactoryDependencyAsync;
-    private resolveFactory;
-    resolveAsync<T>(token: Token<T>, requestingModuleId?: string): Promise<T>;
-    private resolveAsyncInner;
-    private createLazyProxy;
-    private tokenToString;
-}