@clairejs/server 3.4.0 → 3.5.2

package/dist/database/adapter/providers.d.ts

@@ -1,8 +1,8 @@
-export declare enum NoSqlProvider {
-    MONGODB = "mongodb",
-    DYNAMODB = "dynamodb"
-}
-export declare enum SqlProvider {
-    MYSQL = "mysql",
-    POSTGRES = "postgres"
-}
+export declare enum NoSqlProvider {
+    MONGODB = "mongodb",
+    DYNAMODB = "dynamodb"
+}
+export declare enum SqlProvider {
+    MYSQL = "mysql",
+    POSTGRES = "postgres"
+}

package/dist/database/decorators.d.ts

@@ -1,2 +1,2 @@
-import { TransactionLink } from "./transaction/TransactionLink";
-export declare const Transactional: (link: TransactionLink) => (prototype: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+import { TransactionLink } from "./transaction/TransactionLink";
+export declare const Transactional: (link: TransactionLink) => (prototype: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/database/migrator/AbstractDatabaseMigrator.d.ts

@@ -1,4 +1,4 @@
-export declare abstract class AbstractDatabaseMigrator {
-    abstract migrate(migrationDirectory: string): Promise<void>;
-    abstract rollback(migrationDirectory: string): Promise<void>;
-}
+export declare abstract class AbstractDatabaseMigrator {
+    abstract migrate(migrationDirectory: string): Promise<void>;
+    abstract rollback(migrationDirectory: string): Promise<void>;
+}

package/dist/database/migrator/DefaultSqlDatabaseMigrator.d.ts

@@ -1,27 +1,27 @@
-import { AbstractLogger } from "@clairejs/core";
-import { SqlProvider } from "../adapter/providers";
-import { AbstractDatabaseMigrator } from "./AbstractDatabaseMigrator";
-export declare class DefaultSqlDatabaseMigrator extends AbstractDatabaseMigrator {
-    readonly cliPath: string;
-    readonly sqlProvider: SqlProvider;
-    readonly connectionString: string;
-    readonly logger: AbstractLogger;
-    private static readonly COMMENT_BLOCK_REGEX_PATTERN;
-    private static readonly MIGRATION_TEMPLATE;
-    private readonly databaseURL;
-    private readonly modelMetadata;
-    constructor(cliPath: string, sqlProvider: SqlProvider, connectionString: string, logger: AbstractLogger);
-    private getUniqueConstraintGroups;
-    private generateFieldPropertiesQuery;
-    private getUniqueConstraintUpDown;
-    private getSqlCascadeAction;
-    private getForeignKeyConstraintUpDown;
-    private getAddColumnUpDown;
-    private generateCreateTableQuery;
-    private isBooleanDiff;
-    private runProcess;
-    rollback(migrationDirectory: string): Promise<void>;
-    migrate(migrationDirectory: string): Promise<void>;
-    private remove;
-    private getLeanModelMetadata;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { SqlProvider } from "../adapter/providers";
+import { AbstractDatabaseMigrator } from "./AbstractDatabaseMigrator";
+export declare class DefaultSqlDatabaseMigrator extends AbstractDatabaseMigrator {
+    readonly cliPath: string;
+    readonly sqlProvider: SqlProvider;
+    readonly connectionString: string;
+    readonly logger: AbstractLogger;
+    private static readonly COMMENT_BLOCK_REGEX_PATTERN;
+    private static readonly MIGRATION_TEMPLATE;
+    private readonly databaseURL;
+    private readonly modelMetadata;
+    constructor(cliPath: string, sqlProvider: SqlProvider, connectionString: string, logger: AbstractLogger);
+    private getUniqueConstraintGroups;
+    private generateFieldPropertiesQuery;
+    private getUniqueConstraintUpDown;
+    private getSqlCascadeAction;
+    private getForeignKeyConstraintUpDown;
+    private getAddColumnUpDown;
+    private generateCreateTableQuery;
+    private isBooleanDiff;
+    private runProcess;
+    rollback(migrationDirectory: string): Promise<void>;
+    migrate(migrationDirectory: string): Promise<void>;
+    private remove;
+    private getLeanModelMetadata;
+}

package/dist/database/transaction/ITransaction.d.ts

@@ -1,10 +1,10 @@
-import { AbstractModel } from "@clairejs/core";
-import { IQuery } from "../adapter/IQuery";
-import { IQueryProvider } from "../adapter/IQueryProvider";
-import { TransactionState } from "./TransactionState";
-export interface ITransaction extends IQueryProvider {
-    getState(): TransactionState;
-    use<T extends AbstractModel>(model: new (...args: any[]) => T): IQuery<T>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-}
+import { AbstractModel } from "@clairejs/core";
+import { IQuery } from "../adapter/IQuery";
+import { IQueryProvider } from "../adapter/IQueryProvider";
+import { TransactionState } from "./TransactionState";
+export interface ITransaction extends IQueryProvider {
+    getState(): TransactionState;
+    use<T extends AbstractModel>(model: new (...args: any[]) => T): IQuery<T>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/dist/database/transaction/ITransactionFactory.d.ts

@@ -1,4 +1,4 @@
-import { ITransaction } from "./ITransaction";
-export interface ITransactionFactory {
-    createTransaction(): Promise<ITransaction>;
-}
+import { ITransaction } from "./ITransaction";
+export interface ITransactionFactory {
+    createTransaction(): Promise<ITransaction>;
+}

package/dist/database/transaction/ITransactionProvider.d.ts

@@ -1,4 +1,4 @@
-import { ITransaction } from "./ITransaction";
-export interface ITransactionProvider {
-    getCurrentTransaction(): Promise<ITransaction>;
-}
+import { ITransaction } from "./ITransaction";
+export interface ITransactionProvider {
+    getCurrentTransaction(): Promise<ITransaction>;
+}

package/dist/database/transaction/TransactionLink.d.ts

@@ -1,14 +1,14 @@
-export declare enum TransactionLink {
-    /**
-     * Create new transaction when executing the handler function.
-     */
-    CREATE_NEW = "create_new",
-    /**
-     * Inherit the transaction from the caller function and create if not exist.
-     */
-    INHERIT_OR_CREATE = "inherit_or_create",
-    /**
-     * Inherit the transaction from the caller function and throw error if not existed.
-     */
-    INHERIT_OR_THROW = "inherit_or_throw"
-}
+export declare enum TransactionLink {
+    /**
+     * Create new transaction when executing the handler function.
+     */
+    CREATE_NEW = "create_new",
+    /**
+     * Inherit the transaction from the caller function and create if not exist.
+     */
+    INHERIT_OR_CREATE = "inherit_or_create",
+    /**
+     * Inherit the transaction from the caller function and throw error if not existed.
+     */
+    INHERIT_OR_THROW = "inherit_or_throw"
+}

package/dist/database/transaction/TransactionObjectMetadata.d.ts

@@ -1,4 +1,4 @@
-import { ObjectMetadata } from "@clairejs/core";
-export interface TransactionObjectMetadata extends ObjectMetadata {
-    transactional?: boolean;
-}
+import { ObjectMetadata } from "@clairejs/core";
+export interface TransactionObjectMetadata extends ObjectMetadata {
+    transactional?: boolean;
+}

package/dist/database/transaction/TransactionState.d.ts

@@ -1,5 +1,5 @@
-export declare enum TransactionState {
-    EXECUTING = "executing",
-    COMMITTED = "commited",
-    ROLLED_BACK = "rolled_back"
-}
+export declare enum TransactionState {
+    EXECUTING = "executing",
+    COMMITTED = "commited",
+    ROLLED_BACK = "rolled_back"
+}

package/dist/database/util/transaction-provider.d.ts

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

package/dist/http/auth/AbstractHttpAuthorizationProvider.d.ts

@@ -1,9 +1,9 @@
-import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { HttpRequest } from "../common/HttpRequest";
-export declare abstract class AbstractHttpAuthorizationProvider<T extends IPrincipal = IPrincipal> {
-    abstract getPrincipalResolver(): AbstractPrincipalResolver<T>;
-    abstract resolvePrincipal(req: HttpRequest): Promise<T | undefined>;
-    abstract authorize(principal: T | undefined, req: HttpRequest, endpoint: MountedEndpointInfo): Promise<void>;
-}
+import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { HttpRequest } from "../common/HttpRequest";
+export declare abstract class AbstractHttpAuthorizationProvider<T extends IPrincipal = IPrincipal> {
+    abstract getPrincipalResolver(): AbstractPrincipalResolver<T>;
+    abstract resolvePrincipal(req: HttpRequest): Promise<T | undefined>;
+    abstract authorize(principal: T | undefined, req: HttpRequest, endpoint: MountedEndpointInfo): Promise<void>;
+}

package/dist/http/auth/AbstractRbacAuthProvider.d.ts

@@ -1,18 +1,18 @@
-import { AbstractLogger } from "@clairejs/core";
-import { HttpRequest } from "../common/HttpRequest";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { RbacCache } from "./rbac";
-import { AbstractHttpAuthorizationProvider } from "./AbstractHttpAuthorizationProvider";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
-export declare abstract class AbstractRbacAuthProvider<T extends IPrincipal> extends AbstractHttpAuthorizationProvider<T> {
-    readonly authDataResolver: (req: HttpRequest) => string;
-    readonly principalResolver: AbstractPrincipalResolver<T>;
-    readonly logger: AbstractLogger;
-    constructor(authDataResolver: (req: HttpRequest) => string, principalResolver: AbstractPrincipalResolver<T>, logger: AbstractLogger);
-    getPrincipalResolver(): AbstractPrincipalResolver<T>;
-    abstract getRbacCache(): Promise<RbacCache | undefined>;
-    abstract getRolesOfPrincipal(principal: T): Promise<number[]>;
-    resolvePrincipal(req: HttpRequest): Promise<T | undefined>;
-    authorize(principal: T | undefined, request: HttpRequest, endpoint: MountedEndpointInfo): Promise<void>;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { HttpRequest } from "../common/HttpRequest";
+import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { RbacCache } from "./rbac";
+import { AbstractHttpAuthorizationProvider } from "./AbstractHttpAuthorizationProvider";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
+export declare abstract class AbstractRbacAuthProvider<T extends IPrincipal> extends AbstractHttpAuthorizationProvider<T> {
+    readonly authDataResolver: (req: HttpRequest) => string;
+    readonly principalResolver: AbstractPrincipalResolver<T>;
+    readonly logger: AbstractLogger;
+    constructor(authDataResolver: (req: HttpRequest) => string, principalResolver: AbstractPrincipalResolver<T>, logger: AbstractLogger);
+    getPrincipalResolver(): AbstractPrincipalResolver<T>;
+    abstract getRbacCache(): Promise<RbacCache | undefined>;
+    abstract getRolesOfPrincipal(principal: T): Promise<number[]>;
+    resolvePrincipal(req: HttpRequest): Promise<T | undefined>;
+    authorize(principal: T | undefined, request: HttpRequest, endpoint: MountedEndpointInfo): Promise<void>;
+}

package/dist/http/auth/RedisRbacAuthProvider.d.ts

@@ -1,23 +1,23 @@
-import { AbstractLogger } from "@clairejs/core";
-import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-import { AbstractCacheService } from "../../service/AbstractCacheService";
-import { HttpRequest } from "../common/HttpRequest";
-import { AbstractRbacAuthProvider } from "./AbstractRbacAuthProvider";
-import { RbacCache } from "./rbac";
-export declare class RedisRbacAuthProvider<T extends IPrincipal> extends AbstractRbacAuthProvider<T> {
-    readonly serviceId: string;
-    readonly rbacChannel: string;
-    readonly principalChannel: string;
-    readonly authDataResolver: (req: HttpRequest) => any;
-    readonly principalResolver: AbstractPrincipalResolver<T>;
-    readonly cacheService: AbstractCacheService;
-    readonly logger: AbstractLogger;
-    readonly redisDataRetentionDurationMs: number;
-    private lastRbacFetchTimestamp;
-    private principalCache;
-    private rbacCache?;
-    constructor(serviceId: string, rbacChannel: string, principalChannel: string, authDataResolver: (req: HttpRequest) => any, principalResolver: AbstractPrincipalResolver<T>, cacheService: AbstractCacheService, logger: AbstractLogger, redisDataRetentionDurationMs?: number);
-    getRbacCache(): Promise<RbacCache | undefined>;
-    getRolesOfPrincipal(principal: T): Promise<number[]>;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+import { AbstractCacheService } from "../../service/AbstractCacheService";
+import { HttpRequest } from "../common/HttpRequest";
+import { AbstractRbacAuthProvider } from "./AbstractRbacAuthProvider";
+import { RbacCache } from "./rbac";
+export declare class RedisRbacAuthProvider<T extends IPrincipal> extends AbstractRbacAuthProvider<T> {
+    readonly serviceId: string;
+    readonly rbacChannel: string;
+    readonly principalChannel: string;
+    readonly authDataResolver: (req: HttpRequest) => any;
+    readonly principalResolver: AbstractPrincipalResolver<T>;
+    readonly cacheService: AbstractCacheService;
+    readonly logger: AbstractLogger;
+    readonly redisDataRetentionDurationMs: number;
+    private lastRbacFetchTimestamp;
+    private principalCache;
+    private rbacCache?;
+    constructor(serviceId: string, rbacChannel: string, principalChannel: string, authDataResolver: (req: HttpRequest) => any, principalResolver: AbstractPrincipalResolver<T>, cacheService: AbstractCacheService, logger: AbstractLogger, redisDataRetentionDurationMs?: number);
+    getRbacCache(): Promise<RbacCache | undefined>;
+    getRolesOfPrincipal(principal: T): Promise<number[]>;
+}

package/dist/http/auth/SocketRbacAuthProvider.d.ts

@@ -1,25 +1,25 @@
-import { AbstractLogger, IInit, IClientSocket } from "@clairejs/core";
-import { AbstractRbacAuthProvider } from "./AbstractRbacAuthProvider";
-import { RbacCache } from "./rbac";
-import { HttpRequest } from "../common/HttpRequest";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
-export declare class SocketRbacAuthProvider<T extends IPrincipal> extends AbstractRbacAuthProvider<T> implements IInit {
-    readonly rbacCacheChannel: string;
-    readonly principalCacheChannel: string;
-    readonly authDataResolver: (req: HttpRequest) => any;
-    readonly principalResolver: AbstractPrincipalResolver<T>;
-    readonly logger: AbstractLogger;
-    readonly socketProvider: () => Promise<IClientSocket>;
-    socket?: IClientSocket;
-    rbacCache?: RbacCache;
-    idResolvers: {
-        principalId: number;
-        resolvers: ((roleIds: number[]) => void)[];
-    }[];
-    constructor(rbacCacheChannel: string, principalCacheChannel: string, authDataResolver: (req: HttpRequest) => any, principalResolver: AbstractPrincipalResolver<T>, logger: AbstractLogger, socketProvider: () => Promise<IClientSocket>);
-    exit(): void;
-    init(): Promise<void>;
-    getRbacCache(): Promise<RbacCache | undefined>;
-    getRolesOfPrincipal(principal: T): Promise<number[]>;
-}
+import { AbstractLogger, IInit, IClientSocket } from "@clairejs/core";
+import { AbstractRbacAuthProvider } from "./AbstractRbacAuthProvider";
+import { RbacCache } from "./rbac";
+import { HttpRequest } from "../common/HttpRequest";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
+export declare class SocketRbacAuthProvider<T extends IPrincipal> extends AbstractRbacAuthProvider<T> implements IInit {
+    readonly rbacCacheChannel: string;
+    readonly principalCacheChannel: string;
+    readonly authDataResolver: (req: HttpRequest) => any;
+    readonly principalResolver: AbstractPrincipalResolver<T>;
+    readonly logger: AbstractLogger;
+    readonly socketProvider: () => Promise<IClientSocket>;
+    socket?: IClientSocket;
+    rbacCache?: RbacCache;
+    idResolvers: {
+        principalId: number;
+        resolvers: ((roleIds: number[]) => void)[];
+    }[];
+    constructor(rbacCacheChannel: string, principalCacheChannel: string, authDataResolver: (req: HttpRequest) => any, principalResolver: AbstractPrincipalResolver<T>, logger: AbstractLogger, socketProvider: () => Promise<IClientSocket>);
+    exit(): void;
+    init(): Promise<void>;
+    getRbacCache(): Promise<RbacCache | undefined>;
+    getRolesOfPrincipal(principal: T): Promise<number[]>;
+}

package/dist/http/auth/rbac.d.ts

@@ -1,34 +1,34 @@
-export interface RbacRolePolicy {
-    roleId: number;
-    policyId: number;
-}
-export interface RbacRole {
-    roleId: number;
-    isSuperRole: boolean;
-    isAnonymousRole: boolean;
-}
-export interface RbacPolicyPermissionCondition {
-    policyPermissionId: number;
-    conditionName: string;
-    conditionValue: string;
-}
-export interface RbacPolicyPermission {
-    id: number;
-    policyId: number;
-    permission: string;
-}
-export interface RbacPolicy {
-    policyId: number;
-    isUserDefined: boolean;
-}
-export interface PrincipalRole {
-    principalId: number;
-    roleIds: number[];
-}
-export interface RbacCache {
-    roles?: RbacRole[];
-    policies?: RbacPolicy[];
-    rolePolicies?: RbacRolePolicy[];
-    policyPermissions?: RbacPolicyPermission[];
-    policyPermissionConditions?: RbacPolicyPermissionCondition[];
-}
+export interface RbacRolePolicy {
+    roleId: number;
+    policyId: number;
+}
+export interface RbacRole {
+    roleId: number;
+    isSuperRole: boolean;
+    isAnonymousRole: boolean;
+}
+export interface RbacPolicyPermissionCondition {
+    policyPermissionId: number;
+    conditionName: string;
+    conditionValue: string;
+}
+export interface RbacPolicyPermission {
+    id: number;
+    policyId: number;
+    permission: string;
+}
+export interface RbacPolicy {
+    policyId: number;
+    isUserDefined: boolean;
+}
+export interface PrincipalRole {
+    principalId: number;
+    roleIds: number[];
+}
+export interface RbacCache {
+    roles?: RbacRole[];
+    policies?: RbacPolicy[];
+    rolePolicies?: RbacRolePolicy[];
+    policyPermissions?: RbacPolicyPermission[];
+    policyPermissionConditions?: RbacPolicyPermissionCondition[];
+}

package/dist/http/common/HttpRequest.d.ts

@@ -1,37 +1,37 @@
-import { HttpMethod, SocketMethod } from "@clairejs/core";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-import { IServerSocket } from "../../socket/IServerSocket";
-import { IPrincipal } from "../../common/auth/IPrincipal";
-export declare class HttpRequest {
-    private valueHolder;
-    private method;
-    private pathName;
-    private headers;
-    private params;
-    private query;
-    private body;
-    private hash;
-    private authInfo?;
-    constructor(options: {
-        method: HttpMethod | SocketMethod;
-        pathName: string;
-        headers?: any;
-        hash?: string;
-        query?: any;
-        params?: any;
-        body?: any;
-        socket?: IServerSocket;
-    }, endpointMetadata?: EndpointMetadata);
-    private jsonParsing;
-    getAuthInfo(): IPrincipal | undefined;
-    setAuthInfo(authInfo?: IPrincipal): void;
-    getHeaders(): any;
-    getMethod(): HttpMethod | SocketMethod;
-    getHash(): string;
-    getPathName(): string;
-    getValue<T extends any>(key: string): T;
-    setValue<T extends any>(key: string, value: T): void;
-    getParams<T extends any>(): T;
-    getQuery<T extends any>(): T;
-    getBody<T extends any>(): T;
-}
+import { HttpMethod, SocketMethod } from "@clairejs/core";
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { IServerSocket } from "../../socket/IServerSocket";
+import { IPrincipal } from "../../common/auth/IPrincipal";
+export declare class HttpRequest {
+    private valueHolder;
+    private method;
+    private pathName;
+    private headers;
+    private params;
+    private query;
+    private body;
+    private hash;
+    private authInfo?;
+    constructor(options: {
+        method: HttpMethod | SocketMethod;
+        pathName: string;
+        headers?: any;
+        hash?: string;
+        query?: any;
+        params?: any;
+        body?: any;
+        socket?: IServerSocket;
+    }, endpointMetadata?: EndpointMetadata);
+    private jsonParsing;
+    getAuthInfo(): IPrincipal | undefined;
+    setAuthInfo(authInfo?: IPrincipal): void;
+    getHeaders(): any;
+    getMethod(): HttpMethod | SocketMethod;
+    getHash(): string;
+    getPathName(): string;
+    getValue<T extends any>(key: string): T;
+    setValue<T extends any>(key: string, value: T): void;
+    getParams<T extends any>(): T;
+    getQuery<T extends any>(): T;
+    getBody<T extends any>(): T;
+}

package/dist/http/common/HttpResponse.d.ts

@@ -1,25 +1,25 @@
-/// <reference types="node" />
-declare type Dict = {
-    [key: string]: string;
-};
-export declare class HttpResponse<T> {
-    value?: T;
-    code: number;
-    headers: Dict;
-    cookies: Dict;
-}
-export declare class ResponseBuilder<T> {
-    response: HttpResponse<T>;
-    protected constructor();
-    status(code: number): this;
-    header(name: string, value: string): this;
-    cookie(name: string, value: string): this;
-    get(): HttpResponse<T>;
-    static json<T>(jsonValue?: T): ResponseBuilder<T>;
-    static html(htmlValue?: string): ResponseBuilder<unknown>;
-    static binary(buffer?: Buffer): ResponseBuilder<unknown>;
-    static success(): HttpResponse<unknown>;
-    static notFound(data?: any): HttpResponse<unknown>;
-    static accessDenied(data?: any): HttpResponse<unknown>;
-}
-export {};
+/// <reference types="node" />
+declare type Dict = {
+    [key: string]: string;
+};
+export declare class HttpResponse<T> {
+    value?: T;
+    code: number;
+    headers: Dict;
+    cookies: Dict;
+}
+export declare class ResponseBuilder<T> {
+    response: HttpResponse<T>;
+    protected constructor();
+    status(code: number): this;
+    header(name: string, value: string): this;
+    cookie(name: string, value: string): this;
+    get(): HttpResponse<T>;
+    static json<T>(jsonValue?: T): ResponseBuilder<T>;
+    static html(htmlValue?: string): ResponseBuilder<unknown>;
+    static binary(buffer?: Buffer): ResponseBuilder<unknown>;
+    static success(): HttpResponse<unknown>;
+    static notFound(data?: any): HttpResponse<unknown>;
+    static accessDenied(data?: any): HttpResponse<unknown>;
+}
+export {};

package/dist/http/controller/AbstractHttpController.d.ts

@@ -1,10 +1,10 @@
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-import { ITransactionProvider } from "../../database/transaction/ITransactionProvider";
-import { ITransactionFactory } from "../../database/transaction/ITransactionFactory";
-export declare abstract class AbstractHttpController implements ITransactionProvider, ITransactionFactory {
-    protected readonly databaseAdapter: ITransactionFactory;
-    constructor(databaseAdapter: ITransactionFactory);
-    createTransaction(): Promise<import("../..").ITransaction>;
-    getCurrentTransaction(): Promise<import("../..").ITransaction>;
-    getEndpointMetadata(): Readonly<EndpointMetadata>[];
-}
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { ITransactionProvider } from "../../database/transaction/ITransactionProvider";
+import { ITransactionFactory } from "../../database/transaction/ITransactionFactory";
+export declare abstract class AbstractHttpController implements ITransactionProvider, ITransactionFactory {
+    protected readonly databaseAdapter: ITransactionFactory;
+    constructor(databaseAdapter: ITransactionFactory);
+    createTransaction(): Promise<import("../..").ITransaction>;
+    getCurrentTransaction(): Promise<import("../..").ITransaction>;
+    getEndpointMetadata(): Readonly<EndpointMetadata>[];
+}

package/dist/http/controller/AbstractHttpMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { HttpRequest } from "../common/HttpRequest";
-import { HttpResponse } from "../common/HttpResponse";
-export declare abstract class AbstractHttpMiddleware {
-    abstract intercept(request: HttpRequest): Promise<HttpResponse<any> | undefined>;
-}
+import { HttpRequest } from "../common/HttpRequest";
+import { HttpResponse } from "../common/HttpResponse";
+export declare abstract class AbstractHttpMiddleware {
+    abstract intercept(request: HttpRequest): Promise<HttpResponse<any> | undefined>;
+}

package/dist/http/controller/AbstractHttpRequestHandler.d.ts

@@ -1,16 +1,16 @@
-import { AbstractLogger } from "@clairejs/core";
-import { HttpData } from "../../common/request/HttpData";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { HttpResponse } from "../common/HttpResponse";
-import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
-import { ControllerMetadata } from "./ControllerMetadata";
-export declare abstract class AbstractHttpRequestHandler {
-    readonly mountPoint: string;
-    readonly logger: AbstractLogger;
-    private mountedEndpointInfo?;
-    constructor(mountPoint: string, logger: AbstractLogger);
-    protected resolverMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
-    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
-    abstract getMiddleware(): AbstractHttpMiddleware[];
-    abstract handle(httpData: HttpData): Promise<HttpResponse<any>>;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { HttpData } from "../../common/request/HttpData";
+import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { HttpResponse } from "../common/HttpResponse";
+import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
+import { ControllerMetadata } from "./ControllerMetadata";
+export declare abstract class AbstractHttpRequestHandler {
+    readonly mountPoint: string;
+    readonly logger: AbstractLogger;
+    private mountedEndpointInfo?;
+    constructor(mountPoint: string, logger: AbstractLogger);
+    protected resolverMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
+    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+    abstract getMiddleware(): AbstractHttpMiddleware[];
+    abstract handle(httpData: HttpData): Promise<HttpResponse<any>>;
+}

package/dist/http/controller/ControllerMetadata.d.ts

@@ -1,6 +1,6 @@
-import { ObjectMetadata } from "@clairejs/core";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
-export interface ControllerMetadata extends ObjectMetadata {
-    fields: EndpointMetadata[];
-    permissionGroup?: string;
-}
+import { ObjectMetadata } from "@clairejs/core";
+import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+export interface ControllerMetadata extends ObjectMetadata {
+    fields: EndpointMetadata[];
+    permissionGroup?: string;
+}