lakutata 2.0.54 → 2.0.56

package/vendor/TypeDef.13.d.ts

@@ -1,107 +1,360 @@
-import { k as OrderByCondition } from './TypeDef.4.js';
+import { P as Provider, B as BaseObject, I as IBaseObjectConstructor, a as Container, M as Module, C as Component } from './TypeDef.3.js';
+import { D as DTO, J as JSONSchema, F as FunctionSchema } from './TypeDef.5.js';
+import { A as ActionPattern, I as IPatRun } from './TypeDef.10.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { E as Exception } from './TypeDef.7.js';
 
 /**
- * Describes all index options.
+ * Context types
  */
-interface IndexOptions {
+declare enum ContextType {
+    CLI = "CLI",
+    HTTP = "HTTP",
+    SERVICE = "SERVICE"
+}
+type ContextParams<T extends {} = {}> = T & Record<string, any>;
+/**
+ * Base context class
+ */
+declare class BaseContext<T extends Record<string, any> = {}> extends DTO {
+    readonly type: ContextType;
+    data: ActionPattern<T>;
+    constructor(params: ContextParams);
+}
+
+declare class CLIContext<T extends Record<string, any> = {}> extends BaseContext<T> {
+    readonly type: ContextType;
+    command: string;
+    constructor(params: ContextParams<{
+        readonly command: string;
+        readonly data: Record<string, any>;
+    }>);
+}
+
+declare class HTTPContext<T extends Record<string, any> = {}> extends BaseContext<T> {
+    readonly type: ContextType;
+    readonly route: string;
+    readonly method: string;
+    readonly request: IncomingMessage;
+    readonly response: ServerResponse;
+    constructor(params: ContextParams<{
+        readonly route: string;
+        readonly method: string;
+        readonly request: IncomingMessage;
+        readonly response: ServerResponse;
+        readonly data: Record<string, any>;
+    }>);
+}
+
+declare class ServiceContext<T extends Record<string, any> = {}> extends BaseContext<T> {
+    readonly type: ContextType;
+    input: ActionPattern<T>;
+    constructor(params: ContextParams<{
+        readonly data: ActionPattern;
+    }>);
+}
+
+/**
+ * For action decorator
+ */
+type ControllerProperty<ClassPrototype extends Controller> = Exclude<keyof ClassPrototype, keyof Controller>;
+/**
+ * Controller base class
+ */
+declare class Controller extends Provider {
     /**
-     * Indicates if this composite index must be unique or not.
+     * Context, possible be cli context, http context or service context
+     * @protected
      */
-    unique?: boolean;
+    protected readonly context: CLIContext | HTTPContext | ServiceContext;
+}
+
+type AccessControlRuleHandler<T extends BaseContext<Record<string, any>>> = (context: T, input?: ActionPattern<any>) => Promise<boolean>;
+declare abstract class AccessControlRule<T extends BaseContext<Record<string, any>> = BaseContext<Record<string, any>>> extends BaseObject {
+    protected readonly context: T;
+    protected readonly input: ActionPattern<any>;
+    protected readonly actions: HTTPActionInfo[] | ServiceActionInfo[] | CLIActionInfo[];
+    protected readonly targetAction: HTTPActionInfo | ServiceActionInfo | CLIActionInfo;
+    abstract get supportContextTypes(): ContextType[];
     /**
-     * The SPATIAL modifier indexes the entire column and does not allow indexed columns to contain NULL values.
-     * Works only in MySQL and PostgreSQL.
+     * Rule handler
      */
-    spatial?: boolean;
+    abstract rule(): Promise<boolean>;
+}
+
+type ActionPatternMap = Map<ActionPattern, ActionDetails>;
+type ActionDetails<ClassPrototype extends Controller = Controller, DTOConstructor extends typeof DTO = typeof DTO> = {
+    pattern: ActionPattern;
+    constructor: IBaseObjectConstructor<ClassPrototype>;
+    method: string | number | symbol;
+    dtoConstructor: DTOConstructor;
+    jsonSchema: JSONSchema;
+    getActionInfo: () => ActionInfo;
+} & ActionInfo;
+type ActionInfo = {
+    id: string;
+    acl: boolean;
+    action: string;
+    name: string;
+    description: string;
+    groups: string[];
+    rule?: AccessControlRuleHandler<any>;
+};
+
+type PatternManagerOptions = {
+    globMatch?: boolean;
+};
+declare class PatternManager implements IPatRun {
+    #private;
+    constructor(options?: PatternManagerOptions);
     /**
-     * The FULLTEXT modifier indexes the entire column and does not allow prefixing.
-     * Works only in MySQL.
+     * Register a pattern, and the object that will be returned if an input matches.
+     * Both keys and values are considered to be strings.
+     * Other types are converted to strings.
+     * @param pattern
+     * @param obj
      */
-    fulltext?: boolean;
+    add(pattern: Record<string, any>, obj: any): this;
     /**
-     * NULL_FILTERED indexes are particularly useful for indexing sparse columns, where most rows contain a NULL value.
-     * In these cases, the NULL_FILTERED index can be considerably smaller and more efficient to maintain than
-     * a normal index that includes NULL values.
-     *
-     * Works only in Spanner.
+     * Remove this pattern, and it's object, from the matcher.
+     * @param pattern
      */
-    nullFiltered?: boolean;
+    remove(pattern: Record<string, any>): this;
     /**
-     * Fulltext parser.
-     * Works only in MySQL.
+     * Return the unique match for this subject, or null if not found.
+     * The properties of the subject are matched against the patterns previously added, and the most specifc pattern wins.
+     * Unknown properties in the subject are ignored.
+     * You can optionally provide a second boolean parameter, exact. If true, then all properties of the subject must match.
+     *
+     * If the optional third boolean parameter collect is true, then find returns an array of all sub matches
+     * (i.e. run find on each element of the power set of the subject pattern elements, and collate in breadth first order).
+     * Thus, {a:1,b:2} will generate {a:1},{b:2},{a:1,b:2} searches.
+     * If exact is true, only increasing sub patterns in lexicographical order are chosen.
+     * Thus, {a:1,b:2} will generate {a:1},{a:1,b:2}, omitting {b:2}. (You probably want to set exact to false!).
+     * @param subject
+     * @param exact
      */
-    parser?: string;
+    find(subject: Record<string, any>, exact?: boolean): any;
     /**
-     * Index filter condition.
+     * Return the list of registered patterns that contain this partial pattern.
+     * You can use wildcards for property values.
+     * Omitted values are not equivalent to a wildcard of "*", you must specify each property explicitly.
+     * @param partialPattern
      */
-    where?: string;
+    list(partialPattern?: Record<string, any> | undefined): {
+        match: Record<string, any>;
+        data: any;
+    }[];
     /**
-     * If true, the index only references documents with the specified field.
-     * These indexes use less space but behave differently in some situations (particularly sorts).
-     * This option is only supported for mongodb database.
+     * Generate a string representation of the decision tree for debugging.
      */
-    sparse?: boolean;
+    toJSON(): string;
+}
+
+declare class AccessControl extends BaseObject {
+    protected readonly runtimeContainer: Container;
+    protected readonly actions: HTTPActionInfo[] | ServiceActionInfo[] | CLIActionInfo[];
+    protected readonly target: HTTPActionInfo | ServiceActionInfo | CLIActionInfo;
+    protected readonly context: CLIContext | HTTPContext | ServiceContext;
+    protected readonly input: Record<string, any>;
+    protected readonly allowCallback: () => void;
+    protected readonly denyCallback: (error?: Error | Exception) => void;
+    protected readonly rules: (IBaseObjectConstructor<AccessControlRule> | AccessControlRuleHandler<any>)[];
+    protected readonly accessControlRuleConstructorDTO: FunctionSchema<typeof AccessControlRule>;
     /**
-     * Builds the index in the background so that building an index an does not block other database activities.
-     * This option is only supported for mongodb database.
+     * Initializer
+     * @protected
      */
-    background?: boolean;
+    protected init(): Promise<void>;
     /**
-     * Create the index using the CONCURRENTLY modifier
-     * Works only in postgres.
+     * Match rules
+     * @protected
      */
-    concurrent?: boolean;
+    protected match(): Promise<boolean>;
     /**
-     * Specifies a time to live, in seconds.
-     * This option is only supported for mongodb database.
+     * Run access control and return result
+     * @param rules
+     * @param runtimeContainer
+     * @param context
+     * @param input
+     * @param details
+     * @param getActionsCallback
      */
-    expireAfterSeconds?: number;
+    static run(rules: IBaseObjectConstructor<AccessControlRule>[], runtimeContainer: Container, context: CLIContext | HTTPContext | ServiceContext, input: Record<string, any>, details: ActionDetails, getActionsCallback: (type: ContextType) => BaseActionInfo[]): Promise<[boolean, Error | Exception]>;
 }
 
+type CLIEntrypoint = (module: Module, cliMap: CLIMap, handler: CLIEntrypointHandler, registerDestroy: EntrypointDestroyerRegistrar) => void;
+type HTTPEntrypoint = (module: Module, routeMap: HTTPRouteMap, handler: HTTPEntrypointHandler, registerDestroy: EntrypointDestroyerRegistrar) => void;
+type ServiceEntrypoint = (module: Module, handler: ServiceEntrypointHandler, registerDestroy: EntrypointDestroyerRegistrar) => void;
+type CLIMap = Map<string, JSONSchema>;
+type HTTPRouteMap<HTTPMethods = string> = Map<string, Set<HTTPMethods>>;
+type CLIEntrypointHandler<T = unknown> = (context: CLIContext, abortController?: AbortController) => Promise<T>;
+type HTTPEntrypointHandler<T = unknown> = (context: HTTPContext, abortController?: AbortController) => Promise<T>;
+type ServiceEntrypointHandler<T = unknown> = (context: ServiceContext, abortController?: AbortController) => Promise<T>;
+type EntrypointDestroyer = () => void | Promise<void>;
+type EntrypointDestroyerRegistrar = (destroyer: EntrypointDestroyer) => void;
+type EntrypointOptions = {
+    rules?: IBaseObjectConstructor<AccessControlRule>[];
+    controllers: IBaseObjectConstructor<Controller>[];
+    cli?: CLIEntrypoint | CLIEntrypoint[];
+    http?: HTTPEntrypoint | HTTPEntrypoint[];
+    service?: ServiceEntrypoint | ServiceEntrypoint[];
+};
+interface BaseActionInfo {
+    readonly id: string;
+    readonly acl: boolean;
+    readonly name: string;
+    readonly groups: string[];
+    readonly controller: string;
+    readonly method: string;
+    readonly jsonSchema: JSONSchema;
+}
+interface HTTPActionInfo extends BaseActionInfo {
+    readonly route: string;
+}
+interface ServiceActionInfo extends BaseActionInfo {
+    readonly pattern: ActionPattern;
+}
+interface CLIActionInfo extends BaseActionInfo {
+    readonly command: string;
+}
+/**
+ * Build cli entrypoint
+ * @param entrypoint
+ * @constructor
+ */
+declare const BuildCLIEntrypoint: (entrypoint: CLIEntrypoint) => CLIEntrypoint;
+/**
+ * Build http entrypoint
+ * @param entrypoint
+ * @constructor
+ */
+declare const BuildHTTPEntrypoint: (entrypoint: HTTPEntrypoint) => HTTPEntrypoint;
+/**
+ * Build service entrypoint
+ * @param entrypoint
+ * @constructor
+ */
+declare const BuildServiceEntrypoint: (entrypoint: ServiceEntrypoint) => ServiceEntrypoint;
+/**
+ * Build entrypoints options for Entrypoint component
+ * @param options
+ * @constructor
+ */
+declare const BuildEntrypoints: (options: EntrypointOptions) => EntrypointOptions;
 /**
- * Describes all entity's options.
+ * Entrypoint Component
  */
-interface EntityOptions {
+declare class Entrypoint extends Component {
+    protected readonly CLIActionPatternMap: ActionPatternMap;
+    protected readonly HTTPActionPatternMap: ActionPatternMap;
+    protected readonly ServiceActionPatternMap: ActionPatternMap;
+    protected readonly CLIActionPatternManager: PatternManager;
+    protected readonly HTTPActionPatternManager: PatternManager;
+    protected readonly ServiceActionPatternManager: PatternManager;
+    protected readonly entrypointDestroyers: EntrypointDestroyer[];
+    protected readonly httpActionInfoMap: Map<string, HTTPActionInfo>;
+    protected readonly serviceActionInfoMap: Map<string, ServiceActionInfo>;
+    protected readonly cliActionInfoMap: Map<string, CLIActionInfo>;
+    protected readonly accessControl: IBaseObjectConstructor<AccessControl>;
+    protected readonly controllers: IBaseObjectConstructor<Controller>[];
+    protected readonly rules: IBaseObjectConstructor<AccessControlRule>[];
+    protected readonly cli?: CLIEntrypoint | CLIEntrypoint[];
+    protected readonly http?: HTTPEntrypoint | HTTPEntrypoint[];
+    protected readonly service?: ServiceEntrypoint | ServiceEntrypoint[];
+    /**
+     * Initializer
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Http action info getter
+     * @constructor
+     */
+    get HTTP_ACTIONS(): HTTPActionInfo[];
+    /**
+     * Service action info getter
+     * @constructor
+     */
+    get SERVICE_ACTIONS(): ServiceActionInfo[];
+    /**
+     * Cli action info getter
+     * @constructor
+     */
+    get CLI_ACTIONS(): CLIActionInfo[];
+    /**
+     * Destroyer
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    /**
+     * Find duplicate action names
+     * @protected
+     * @param actionInfoMap
+     */
+    protected findDuplicateActionNames(actionInfoMap: Map<string, BaseActionInfo>): string[];
     /**
-     * Table name.
-     * If not specified then naming strategy will generate table name from entity name.
+     * Run access control
+     * @param rules
+     * @param runtimeContainer
+     * @param context
+     * @param input
+     * @param details
+     * @protected
      */
-    name?: string;
+    protected runAccessControl(rules: IBaseObjectConstructor<AccessControlRule>[], runtimeContainer: Container, context: CLIContext | HTTPContext | ServiceContext, input: Record<string, any>, details: ActionDetails): Promise<void>;
     /**
-     * Specifies a default order by used for queries from this table when no explicit order by is specified.
+     * Run controller's method and return its result (without AbortController)
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @protected
      */
-    orderBy?: OrderByCondition | ((object: any) => OrderByCondition | any);
+    protected runControllerMethodWithoutAbortController<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor): Promise<unknown>;
     /**
-     * Table's database engine type (like "InnoDB", "MyISAM", etc).
-     * It is used only during table creation.
-     * If you update this value and table is already created, it will not change table's engine type.
-     * Note that not all databases support this option.
+     * Run controller's method and return its result (with AbortController)
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @param abortController
+     * @protected
      */
-    engine?: string;
+    protected runControllerMethodWithAbortController<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor, abortController: AbortController): Promise<unknown>;
     /**
-     * Database name. Used in Mysql and Sql Server.
+     * Run controller's method and return its result
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @param abortController
+     * @protected
      */
-    database?: string;
+    protected runControllerMethod<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor, abortController?: AbortController): Promise<unknown>;
     /**
-     * Schema name. Used in Postgres and Sql Server.
+     * Register
+     * @param eps
+     * @param registerFunc
+     * @protected
      */
-    schema?: string;
+    protected register<T>(eps: any | any[] | undefined, registerFunc: (entrypoint: T) => void): void;
     /**
-     * Indicates if schema synchronization is enabled or disabled for this entity.
-     * If it will be set to false then schema sync will and migrations ignore this entity.
-     * By default schema synchronization is enabled for all entities.
+     * Register CLI entrypoint
+     * @param entrypoint
+     * @protected
      */
-    synchronize?: boolean;
+    protected registerCLIEntrypoint(entrypoint: CLIEntrypoint): void;
     /**
-     * If set to 'true' this option disables Sqlite's default behaviour of secretly creating
-     * an integer primary key column named 'rowid' on table creation.
-     * @see https://www.sqlite.org/withoutrowid.html.
+     * Register http entrypoint
+     * @param entrypoint
+     * @protected
      */
-    withoutRowid?: boolean;
+    protected registerHTTPEntrypoint(entrypoint: HTTPEntrypoint): void;
     /**
-     * Table comment. Not supported by all database types.
+     * Register service entrypoint
+     * @param entrypoint
+     * @protected
      */
-    comment?: string;
+    protected registerServiceEntrypoint(entrypoint: ServiceEntrypoint): void;
 }
 
-export type { EntityOptions as E, IndexOptions as I };
+export { BuildCLIEntrypoint as k, BuildHTTPEntrypoint as l, BuildServiceEntrypoint as m, BuildEntrypoints as n, Entrypoint as o, ContextType as p, BaseContext as q, CLIContext as r, HTTPContext as s, ServiceContext as t, Controller as v, AccessControlRule as w };
+export type { AccessControlRuleHandler as A, BaseActionInfo as B, CLIEntrypoint as C, EntrypointDestroyer as E, HTTPEntrypoint as H, ServiceEntrypoint as S, CLIMap as a, HTTPRouteMap as b, CLIEntrypointHandler as c, HTTPEntrypointHandler as d, ServiceEntrypointHandler as e, EntrypointDestroyerRegistrar as f, EntrypointOptions as g, HTTPActionInfo as h, ServiceActionInfo as i, CLIActionInfo as j, ControllerProperty as u };

package/vendor/TypeDef.3.d.ts

@@ -979,5 +979,5 @@ declare class Container {
     destroy(): Promise<void>;
 }
 
-export { BaseObject as B, Component as C, Module as M, OverridableNamedObjectOptions as O, Provider as P, ModuleOptions as a, ModuleConfigLoader as b, LoadObjectOptions as c, Container as g, LoadAnonymousObjectOptions as h, LoadNamedObjectOptions as i, ModuleLoadObjectsOptions as j, OverridableObjectOptions as k };
-export type { EventAndListener as E, IBaseObjectConstructor as I, LifetimeType as L, ConstructorOptions as d, event as e, ListenerFn as f };
+export { BaseObject as B, Component as C, Module as M, OverridableNamedObjectOptions as O, Provider as P, Container as a, ModuleOptions as b, ModuleConfigLoader as c, LoadObjectOptions as d, LoadAnonymousObjectOptions as h, LoadNamedObjectOptions as i, ModuleLoadObjectsOptions as j, OverridableObjectOptions as k };
+export type { EventAndListener as E, IBaseObjectConstructor as I, LifetimeType as L, ConstructorOptions as e, event as f, ListenerFn as g };

package/vendor/TypeDef.5.d.ts

@@ -4137,4 +4137,4 @@ declare class DTO extends DataValidator {
 }
 
 export { DTO as D };
-export type { JSONSchema as J, Schema$1 as S };
+export type { FunctionSchema as F, JSONSchema as J, Schema$1 as S };

package/vendor/TypeDef.7.d.ts

@@ -1,12 +1,21 @@
-interface IPatRun {
-    add(pattern: Record<string, any>, obj: any): void;
-    remove(pattern: Record<string, any>): void;
-    find(subject: Record<string, any>, exact?: boolean): any;
-    list(partialPattern?: Record<string, any>): {
-        match: Record<string, any>;
-        data: any;
-    }[];
-    toJSON(): string;
+/**
+ * 异常抽象类
+ */
+declare abstract class Exception extends Error {
+    abstract errno: number | string;
+    readonly appId: string;
+    readonly appName: string;
+    readonly errMsg: string;
+    readonly err: string;
+    constructor(template: string, data: unknown[] | Record<string, any>);
+    constructor(message: string);
+    constructor(error: Error);
+    constructor();
+    /**
+     * 获取错误名称
+     * @returns {string}
+     */
+    get name(): string;
 }
 
-export type { IPatRun as I };
+export { Exception as E };

package/vendor/TypeDef.8.d.ts

@@ -1,21 +1,3 @@
-/**
- * 异常抽象类
- */
-declare abstract class Exception extends Error {
-    abstract errno: number | string;
-    readonly appId: string;
-    readonly appName: string;
-    readonly errMsg: string;
-    readonly err: string;
-    constructor(template: string, data: unknown[] | Record<string, any>);
-    constructor(message: string);
-    constructor(error: Error);
-    constructor();
-    /**
-     * 获取错误名称
-     * @returns {string}
-     */
-    get name(): string;
-}
+type MethodDecorator<ClassPrototype, Method, Property = string | symbol> = (target: ClassPrototype, propertyKey: Property, descriptor: TypedPropertyDescriptor<Method>) => TypedPropertyDescriptor<Method> | void;
 
-export { Exception as E };
+export type { MethodDecorator as M };

package/vendor/TypeDef.9.d.ts

@@ -1,3 +1,6 @@
-type ActionPattern<T extends Record<string, any> = {}> = Record<string, any> & T;
+interface IConstructor<T = any> {
+    new (...args: any[]): T;
+    [prop: string]: any;
+}
 
-export type { ActionPattern as A };
+export type { IConstructor as I };

package/vendor/TypeDef.14.d.ts

@@ -1,72 +0,0 @@
-import { P as Provider } from './TypeDef.3.js';
-import { D as DTO } from './TypeDef.5.js';
-import { A as ActionPattern } from './TypeDef.9.js';
-import { IncomingMessage, ServerResponse } from 'node:http';
-
-/**
- * Context types
- */
-declare enum ContextType {
-    CLI = "CLI",
-    HTTP = "HTTP",
-    SERVICE = "SERVICE"
-}
-type ContextParams<T extends {} = {}> = T & Record<string, any>;
-/**
- * Base context class
- */
-declare class BaseContext<T extends Record<string, any> = {}> extends DTO {
-    readonly type: ContextType;
-    data: ActionPattern<T>;
-    constructor(params: ContextParams);
-}
-
-declare class CLIContext<T extends Record<string, any> = {}> extends BaseContext<T> {
-    readonly type: ContextType;
-    command: string;
-    constructor(params: ContextParams<{
-        readonly command: string;
-        readonly data: Record<string, any>;
-    }>);
-}
-
-declare class HTTPContext<T extends Record<string, any> = {}> extends BaseContext<T> {
-    readonly type: ContextType;
-    readonly route: string;
-    readonly method: string;
-    readonly request: IncomingMessage;
-    readonly response: ServerResponse;
-    constructor(params: ContextParams<{
-        readonly route: string;
-        readonly method: string;
-        readonly request: IncomingMessage;
-        readonly response: ServerResponse;
-        readonly data: Record<string, any>;
-    }>);
-}
-
-declare class ServiceContext<T extends Record<string, any> = {}> extends BaseContext<T> {
-    readonly type: ContextType;
-    input: ActionPattern<T>;
-    constructor(params: ContextParams<{
-        readonly data: ActionPattern;
-    }>);
-}
-
-/**
- * For action decorator
- */
-type ControllerProperty<ClassPrototype extends Controller> = Exclude<keyof ClassPrototype, keyof Controller>;
-/**
- * Controller base class
- */
-declare class Controller extends Provider {
-    /**
-     * Context, possible be cli context, http context or service context
-     * @protected
-     */
-    protected readonly context: CLIContext | HTTPContext | ServiceContext;
-}
-
-export { BaseContext as B, Controller as C, HTTPContext as H, ServiceContext as S, CLIContext as a, ContextType as b };
-export type { ControllerProperty as c };