@declaro/core 2.0.0-beta.9 → 2.0.0-y.0

package/dist/app/app-context.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '../context/context';
+/**
+ * Get the name of the app making the current request via header x-app. (returns "default" when no app was provided).
+ *
+ * @param context
+ * @returns the name of the app in a string.
+ */
+export declare function useApp(context: Context): string;

package/dist/app/app-lifecycle.d.ts

@@ -0,0 +1,4 @@
+import { Context, ContextListener } from '../context/context';
+export declare function onInit(context: Context, listener: ContextListener): void;
+export declare function onStart(context: Context, listener: ContextListener): void;
+export declare function onDestroy(context: Context, listener: ContextListener): void;

package/dist/app/app.d.ts

@@ -0,0 +1,22 @@
+import { Context, ContextMiddleware, ContextListener } from '../context/context';
+export type AppConfig = {
+    context?: Context;
+    init?: ContextMiddleware;
+    start?: ContextMiddleware;
+    destroy?: ContextMiddleware;
+};
+export declare class App {
+    readonly context: Context;
+    constructor(context: Context);
+    static Events: {
+        Init: string;
+        Start: string;
+        Destroy: string;
+    };
+    init(): Promise<void>;
+    onInit(listener: ContextListener): this;
+    start(): Promise<void>;
+    onStart(listener: ContextListener): void;
+    destroy(): Promise<void>;
+    onDestroy(listener: ContextListener): void;
+}

package/dist/app/index.d.ts

@@ -1,20 +1,3 @@
-import { ContextMiddleware } from '../context';
-export type AppMeta = {
-    /**
-     * A human-friendly title for your app
-     */
-    title: string;
-    /**
-     * A unique parameterized name for your app
-     */
-    name: string;
-    /**
-     * A human-friendly description for your app
-     */
-    description: string;
-};
-export type App = {
-    meta: AppMeta;
-    context: ContextMiddleware;
-};
-export declare function defineApp(meta: AppMeta, configureContext: ContextMiddleware): App;
+export * from './app-context';
+export * from './app-lifecycle';
+export * from './app';

package/dist/auth/permission-validator.d.ts

@@ -0,0 +1,34 @@
+export declare enum PermissionRuleType {
+    ALL_OF = "ALL_OF",
+    NONE_OF = "NONE_OF",
+    SOME_OF = "SOME_OF"
+}
+export type RulePermission = string | PermissionValidator;
+export type PermissionRule = {
+    type: PermissionRuleType;
+    permissions: RulePermission[];
+    errorMessage: string;
+};
+export declare class PermissionError extends Error {
+    rule: PermissionRule;
+    permissions: RulePermission[];
+    constructor(message: string, rule: PermissionRule, permissions: RulePermission[]);
+}
+export type PermissionValidationResults = {
+    valid: boolean;
+    errorMessage: string;
+    errors: PermissionError[];
+};
+export declare class PermissionValidator {
+    readonly rules: PermissionRule[];
+    static create(): PermissionValidator;
+    addRule(...rule: PermissionRule[]): this;
+    extend(...validators: PermissionValidator[]): this;
+    allOf(permissions: RulePermission[], errorMessage?: string): this;
+    noneOf(permissions: RulePermission[], errorMessage?: string): this;
+    someOf(permissions: RulePermission[], errorMessage?: string): this;
+    private validateRule;
+    private hasPermission;
+    validate(permissions?: string[]): boolean;
+    safeValidate(permissions?: string[]): PermissionValidationResults;
+}

package/dist/auth/permission-validator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/context/context.d.ts

@@ -1,38 +1,113 @@
+import { Class, PromiseOrValue, UnwrapPromise } from '../typescript';
 import { Validator } from '../validation';
 import { ContextConsumer } from './context-consumer';
+export type AppScope = {};
+export type RequestScope = {};
+export type AppContext = Context<AppScope>;
+export type RequestContext = Context<RequestScope>;
 export type ContextMiddleware = (context: Context) => any | Promise<any>;
-export type ContextState = Record<PropertyKey, ContextAttribute<StateValue<any>>>;
+export type ContextState<TContext extends Context> = Record<PropertyKey, ContextAttribute<TContext, StateValue<any>>>;
 export type ContextResolver<T> = (context: Context) => StateValue<T>;
 export type StateValue<T> = T;
-export type ContextAttribute<T> = {
+export declare enum DependencyType {
+    VALUE = "VALUE",
+    FACTORY = "FACTORY",
+    CLASS = "CLASS"
+}
+export type FactoryFn<T, A extends any[]> = (...args: A) => T;
+export type ValueLoader<C extends Context, T> = (context: C) => T;
+export type FilterKeysByType<TScope, TValue> = {
+    [Key in keyof TScope]: TScope[Key] extends TValue ? Key : never;
+}[keyof TScope];
+export type FilterKeysByAsyncType<TScope, TValue> = {
+    [Key in keyof TScope]: TScope[Key] extends PromiseOrValue<TValue> ? Key : never;
+}[keyof TScope];
+export type FilterArgsByType<TScope, TArgs extends any[]> = {
+    [Key in keyof TArgs]: FilterKeysByType<TScope, TArgs[Key]>;
+};
+export type FilterAsyncArgsByType<TScope, TArgs extends any[]> = {
+    [Key in keyof TArgs]: FilterKeysByAsyncType<TScope, TArgs[Key]>;
+};
+export type ContextAttribute<TContext extends Context<any>, TValue> = {
     key: PropertyKey;
-    value?: T;
+    value?: ValueLoader<TContext, TValue>;
+    type: DependencyType;
+    resolveOptions: ResolveOptions;
+    cachedValue?: TValue;
+    inject: PropertyKey[];
+};
+export type ScopeKey<S extends object> = keyof S;
+export type ContextListener = (context: Context) => any;
+export type ResolveOptions = {
+    strict?: boolean;
+    eager?: boolean;
+    singleton?: boolean;
 };
-export type ContextListener = (context: Context, ...args: any[]) => any;
-export declare class Context {
+export declare function defaultResolveOptions(): ResolveOptions;
+export type ContextOptions = {
+    defaultResolveOptions?: ResolveOptions;
+};
+export declare class Context<Scope extends object = any> {
     private readonly state;
     private readonly emitter;
+    readonly scope: Scope;
+    protected readonly defaultResolveOptions: ResolveOptions;
+    constructor(options?: ContextOptions);
     /**
      * Set a value in context, to be injected later.
      *
      * @param key
      * @param payload
+     * @deprecated Use `provideValue` instead, or you can register the same dependency as a factory with `provideFactory` or class with `provideClass`.
+     */
+    provide<K extends ScopeKey<Scope>>(key: K, payload: Scope[K]): void;
+    /**
+     * Manually register a dependency. This should normally be used by utils or integrations that need to register dependencies in creative ways. For normal use cases, using `provideValue`, `provideFactory`, or `provideClass` is sufficient.
+     *
+     * @param key The key to register the dependency under
+     * @param dep The dependency record
+     */
+    register<K extends ScopeKey<Scope>>(key: K, dep: ContextAttribute<this, Scope[K]>): void;
+    /**
+     * Register a value in context scope.
+     *
+     * @param key The key to register the dependency under
+     * @param value The value to register
+     */
+    registerValue<K extends ScopeKey<Scope>>(key: K, value: Scope[K], defaultResolveOptions?: ResolveOptions): this;
+    /**
+     * Register a dependency as a factory in context scope.
+     *
+     * @param key The key to register the dependency under
+     * @param factory A factory function that will be called to generate the value when it is requested.
+     * @param inject An array of keys to use when injecting factory args.
+     * @returns A chainable instance of context
      */
-    provide<T>(key: PropertyKey, payload: StateValue<T>): void;
+    registerFactory<K extends ScopeKey<Scope>, A extends any[]>(key: K, factory: FactoryFn<Scope[K], A>, inject?: FilterArgsByType<Scope, A>, defaultResolveOptions?: ResolveOptions): this;
+    registerAsyncFactory<K extends FilterKeysByType<Scope, Promise<any>>, A extends any[]>(key: K, factory: FactoryFn<Scope[K], A>, inject?: FilterAsyncArgsByType<Scope, A>, defaultResolveOptions?: ResolveOptions): this;
+    registerClass<K extends FilterKeysByType<Scope, InstanceType<T>>, T extends Class<Scope[K]>>(key: K, Class: T, inject?: FilterArgsByType<Scope, ConstructorParameters<T>>, defaultResolveOptions?: ResolveOptions): this;
+    registerAsyncClass<K extends FilterKeysByType<Scope, InstanceType<any>>, T extends Class<UnwrapPromise<Scope[K]>>>(key: K, Class: T, inject?: FilterAsyncArgsByType<Scope, ConstructorParameters<T>>, defaultResolveOptions?: ResolveOptions): this;
+    getAllDependencies<K extends ScopeKey<Scope>>(key: K): ContextAttribute<this, any>[];
+    getAllDependents<K extends ScopeKey<Scope>>(key: K): ContextAttribute<this, any>[];
+    introspect<K extends ScopeKey<Scope>>(key: K): ContextState<this>[K];
+    protected _cacheIsValid<K extends ScopeKey<Scope>>(key: K): boolean;
+    protected _resolveValue<K extends ScopeKey<Scope>>(key: K, resolveOptions?: ResolveOptions): Scope[K];
     /**
      * Extract a value from context.
      *
      * @param key
      * @returns
+     * @deprecated Use `resolve` instead
      */
-    inject<T = any>(key: PropertyKey): T | undefined;
+    inject<T = any>(key: ScopeKey<Scope>): T | undefined;
+    resolve<K extends ScopeKey<Scope>>(key: K, resolveOptions?: ResolveOptions): Scope[K];
     /**
      * Ensure that only one copy of this instance exists in this context. Provides the instance if it doesn't exist yet, otherwise inject the cached instance.
      *
      * @param key
      * @param instance
      */
-    singleton<T = any>(key: PropertyKey, instance: T): T;
+    singleton<T = any>(key: ScopeKey<Scope>, instance: T): T;
     /**
      * Instantiate a ContextConsumer class
      *
@@ -46,7 +121,7 @@ export declare class Context {
      * @param contexts
      * @returns
      */
-    extend(...contexts: Context[]): ContextState;
+    extend(...contexts: Context[]): this;
     /**
      * Modify context with middleware
      *
@@ -60,13 +135,13 @@ export declare class Context {
      * @param validators
      * @returns
      */
-    validate(...validators: Validator<Context>[]): import('../validation').Validation<Context>;
+    validate(...validators: Validator<Context>[]): import('..').Validation<Context<any>>;
     /**
      * Validate context ensuring at least one validator is valid
      * @param validators
      * @returns
      */
-    validateAny(...validators: Validator<Context>[]): import('../validation').Validation<any>;
+    validateAny(...validators: Validator<Context>[]): import('..').Validation<any>;
     /**
      * Add a callback to listen for an event in this context.
      *
@@ -74,7 +149,7 @@ export declare class Context {
      * @param listener
      * @returns
      */
-    on(event: string, listener: ContextListener): () => boolean;
+    on(event: string, listener: ContextListener): () => void;
     /**
      * Emit an event in this context
      *
@@ -82,5 +157,5 @@ export declare class Context {
      * @param args
      * @returns
      */
-    emit(event: string, ...args: any[]): Promise<void>;
+    emit(event: string): Promise<void>;
 }

package/dist/context/legacy-context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/errors/errors.d.ts

@@ -0,0 +1,36 @@
+export interface IError {
+    code: number;
+    message: string;
+    meta: any;
+}
+export declare abstract class BaseError extends Error implements IError {
+    readonly meta: any;
+    readonly code: number;
+    constructor(message: string, meta?: any);
+    toJSON(): {
+        code: number;
+        message: string;
+        meta: any;
+    };
+    toString(): string;
+}
+export declare class SystemError extends BaseError {
+    readonly code: number;
+    constructor(message: string, meta?: any);
+}
+export declare class ValidationError extends BaseError {
+    readonly code: number;
+    constructor(message: string, meta?: any);
+}
+export declare class NotFoundError extends BaseError {
+    readonly code: number;
+    constructor(message: string, meta?: any);
+}
+export declare class UnauthorizedError extends BaseError {
+    readonly code: number;
+    constructor(message: string, meta?: any);
+}
+export declare class ForbiddenError extends BaseError {
+    readonly code: number;
+    constructor(message: string, meta?: any);
+}

package/dist/events/event-manager.d.ts

@@ -1,11 +1,16 @@
-export type Listener = (...args: any[]) => any;
-export declare class EventManager<T> {
+export interface IEvent {
+    type: string;
+}
+export type Listener = (event: IEvent) => any;
+export declare class EventManager<E extends IEvent = IEvent> {
     protected readonly listeners: {
         [key: string]: Listener[];
     };
     getListeners(event: string): Listener[];
-    on(event: string, listener: Listener): () => boolean;
-    emitAsync(event: string, ...args: any[]): Promise<void>;
-    emitAll(event: string, ...args: any[]): Promise<void>;
-    emit(event: string, ...args: any[]): void;
+    getEvents(): string[];
+    on(event: string | string[], listener: Listener): () => void;
+    emitAsync(event: E): Promise<void>;
+    emitAll(event: E): Promise<void>;
+    emit(event: E): void;
+    protected getListenerArray(event: string): Listener[];
 }

package/dist/http/headers.d.ts

@@ -0,0 +1,4 @@
+import { Context } from '../context/context';
+export type HeaderMap = Record<string, string>;
+export declare function useHeaders(context: Context): import('http').IncomingHttpHeaders;
+export declare function useHeader(context: Context, header: string): string | string[];

package/dist/http/headers.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http/request-context.d.ts

@@ -0,0 +1,12 @@
+import { Context, ContextMiddleware } from '../context/context';
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const REQUEST_CONTEXT_MIDDLEWARE: unique symbol;
+export declare function useRequestMiddleware(context: Context): ContextMiddleware[];
+export declare function provideRequestMiddleware(context: Context, ...middleware: ContextMiddleware[]): ContextMiddleware[];
+export declare const REQUEST_NODE_MIDDLEWARE: unique symbol;
+export type NodeListener = (req: IncomingMessage, res: ServerResponse) => void;
+export type NodePromisifiedHandler = (req: IncomingMessage, res: ServerResponse) => Promise<any>;
+export type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
+export type AllNodeMiddleware = NodeListener | NodePromisifiedHandler | NodeMiddleware;
+export declare function useNodeMiddleware(context: Context): AllNodeMiddleware[];
+export declare function provideNodeMiddleware(context: Context, ...middleware: AllNodeMiddleware[]): AllNodeMiddleware[];

package/dist/http/request-context.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http/request.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '../context/context';
+import { IncomingMessage } from 'http';
+export declare const REQUEST: unique symbol;
+export interface Request extends IncomingMessage {
+}
+export declare function provideRequest(context: Context, request: Request): void;
+export declare function useRequest(context: Context): Request;
+export declare function useRequestMethod(context: Context): string;

package/dist/http/request.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http/url.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '../context/context';
+import { URL } from 'whatwg-url';
+export declare function useRequestURL(context: Context): URL;
+export declare function useRequestURLString(context: Context): string;
+export declare function useRequestDomain(context: Context): string;
+export declare function useRequestPath(context: Context): string;
+export declare function useRequestQuery(context: Context): Record<string, string>;
+export declare function useFormattedQueryParam(context: Context, key: string): void;

package/dist/http/url.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,13 +1,19 @@
 export * from './typescript';
 export * from './app';
-export * from './server';
-export * from './context';
+export * from './context/context';
+export * from './context/context-consumer';
+export * from './context/validators';
 export * from './dataflow';
 export * from './events';
 export * from './validation';
 export * from './timing';
 export * from './schema';
 export * from './helpers';
-export * from './interfaces';
+export * from './errors/errors';
 export * from './schema/formats';
 export * from './pipelines';
+export * from './http/headers';
+export * from './http/request-context';
+export * from './http/request';
+export * from './http/url';
+export * from './auth/permission-validator';