@clairejs/server 3.4.0 → 3.5.2

package/dist/common/FileOperation.d.ts

@@ -1,5 +1,5 @@
-export declare enum FileOperation {
-    GET = "getObject",
-    PUT = "putObject",
-    DELETE = "deleteObject"
-}
+export declare enum FileOperation {
+    GET = "getObject",
+    PUT = "putObject",
+    DELETE = "deleteObject"
+}

package/dist/common/ServerModelMetadata.d.ts

@@ -1,10 +1,10 @@
-import { ModelFieldMetadata, ModelMetadata } from "@clairejs/core";
-import { IPrincipal } from "./auth/IPrincipal";
-import { UriMapperHandler } from "../http/file-upload/types";
-export interface ServerModelFieldMetadata extends ModelFieldMetadata {
-    uriMapper?: UriMapperHandler<any>;
-    userResolver?: (principal: IPrincipal) => any;
-}
-export interface ServerModelMetadata extends ModelMetadata {
-    fields: ServerModelFieldMetadata[];
-}
+import { ModelFieldMetadata, ModelMetadata } from "@clairejs/core";
+import { IPrincipal } from "./auth/IPrincipal";
+import { UriMapperHandler } from "../http/file-upload/types";
+export interface ServerModelFieldMetadata extends ModelFieldMetadata {
+    uriMapper?: UriMapperHandler<any>;
+    userResolver?: (principal: IPrincipal) => any;
+}
+export interface ServerModelMetadata extends ModelMetadata {
+    fields: ServerModelFieldMetadata[];
+}

package/dist/common/auth/AbstractPrincipalResolver.d.ts

@@ -1,4 +1,4 @@
-import { IPrincipal } from "./IPrincipal";
-export declare abstract class AbstractPrincipalResolver<T extends IPrincipal = IPrincipal> {
-    abstract resolvePrincipal(authData?: any): Promise<T | undefined>;
-}
+import { IPrincipal } from "./IPrincipal";
+export declare abstract class AbstractPrincipalResolver<T extends IPrincipal = IPrincipal> {
+    abstract resolvePrincipal(authData?: any): Promise<T | undefined>;
+}

package/dist/common/auth/IPrincipal.d.ts

@@ -1,4 +1,4 @@
-export interface IPrincipal {
-    id: any;
-    hasTfa?: boolean;
-}
+export interface IPrincipal {
+    id: any;
+    hasTfa?: boolean;
+}

package/dist/common/constants.d.ts

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

package/dist/common/request/EndpointMetadata.d.ts

@@ -1,40 +1,40 @@
-import { Constructor, DtoMetadata, HttpMethod, SocketMethod, ObjectFieldMetadata } from "@clairejs/core";
-import { RequestDataSource } from "./types";
-import { AbstractAccessCondition } from "../../http/security/AbstractAccessCondition";
-export interface EndpointMetadata extends ObjectFieldMetadata {
-    /**
-     * Basic HTTP information, name property is handler function name.
-     */
-    httpMethod: HttpMethod | SocketMethod;
-    url: string;
-    /**
-     * User-friendly display name of endpoint.
-     */
-    displayName?: string;
-    bodyValidationDto?: DtoMetadata;
-    queriesValidationDto?: DtoMetadata;
-    paramsValidationDto?: DtoMetadata;
-    responseValidationDto?: DtoMetadata;
-    params?: {
-        [index: number]: {
-            source?: RequestDataSource;
-            diClass?: Constructor<any>;
-        };
-    };
-    /**
-     * This endpoint requires tfa
-     */
-    tfaRequired?: boolean;
-    /**
-     * Allow public access to this endpoint.
-     */
-    openAccess?: boolean;
-    /**
-     * Metadata of access condition to allow a conditional access to the endpoint.
-     */
-    accessConditions?: Constructor<AbstractAccessCondition>[];
-    /**
-     * Group of permission of this endpoint.
-     */
-    permissionGroup?: string;
-}
+import { Constructor, DtoMetadata, HttpMethod, SocketMethod, ObjectFieldMetadata } from "@clairejs/core";
+import { RequestDataSource } from "./types";
+import { AbstractAccessCondition } from "../../http/security/AbstractAccessCondition";
+export interface EndpointMetadata extends ObjectFieldMetadata {
+    /**
+     * Basic HTTP information, name property is handler function name.
+     */
+    httpMethod: HttpMethod | SocketMethod;
+    url: string;
+    /**
+     * User-friendly display name of endpoint.
+     */
+    displayName?: string;
+    bodyValidationDto?: DtoMetadata;
+    queriesValidationDto?: DtoMetadata;
+    paramsValidationDto?: DtoMetadata;
+    responseValidationDto?: DtoMetadata;
+    params?: {
+        [index: number]: {
+            source?: RequestDataSource;
+            diClass?: Constructor<any>;
+        };
+    };
+    /**
+     * This endpoint requires tfa
+     */
+    tfaRequired?: boolean;
+    /**
+     * Allow public access to this endpoint.
+     */
+    openAccess?: boolean;
+    /**
+     * Metadata of access condition to allow a conditional access to the endpoint.
+     */
+    accessConditions?: Constructor<AbstractAccessCondition>[];
+    /**
+     * Group of permission of this endpoint.
+     */
+    permissionGroup?: string;
+}

package/dist/common/request/HttpData.d.ts

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

package/dist/common/request/HttpEndpoint.d.ts

@@ -1,8 +1,8 @@
-import { HttpMethod, SocketMethod } from "@clairejs/core";
-export declare const getEndpointId: (endpoint: HttpEndpoint) => string;
-export interface HttpEndpoint {
-    mount?: string;
-    httpMethod?: HttpMethod | SocketMethod;
-    controller: any;
-    handlerFunctionName: string;
-}
+import { HttpMethod, SocketMethod } from "@clairejs/core";
+export declare const getEndpointId: (endpoint: HttpEndpoint) => string;
+export interface HttpEndpoint {
+    mount?: string;
+    httpMethod?: HttpMethod | SocketMethod;
+    controller: any;
+    handlerFunctionName: string;
+}

package/dist/common/request/JobData.d.ts

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

package/dist/common/request/MountedEndpointInfo.d.ts

@@ -1,6 +1,6 @@
-import { EndpointMetadata } from "./EndpointMetadata";
-import { HttpEndpoint } from "./HttpEndpoint";
-export interface MountedEndpointInfo {
-    endpointMetadata: EndpointMetadata;
-    endpoint: HttpEndpoint;
-}
+import { EndpointMetadata } from "./EndpointMetadata";
+import { HttpEndpoint } from "./HttpEndpoint";
+export interface MountedEndpointInfo {
+    endpointMetadata: EndpointMetadata;
+    endpoint: HttpEndpoint;
+}

package/dist/common/request/RequestOptions.d.ts

@@ -1,6 +1,6 @@
-export interface RequestOptions {
-    method: string;
-    rawPath: string;
-    headers?: any;
-    body?: any;
-}
+export interface RequestOptions {
+    method: string;
+    rawPath: string;
+    headers?: any;
+    body?: any;
+}

package/dist/common/request/SocketData.d.ts

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

package/dist/common/request/types.d.ts

@@ -1 +1 @@
-export declare type RequestDataSource = "body" | "params" | "queries" | "headers" | "socket" | "raw";
+export declare type RequestDataSource = "body" | "params" | "queries" | "headers" | "socket" | "raw";

package/dist/database/QueryOperator.d.ts

@@ -1,15 +1,15 @@
-export declare type MultiOperandOps = "_and" | "_or";
-export declare type Op = "_eq" | "_neq" | "_in"
-/**
- * Does not belong to array
- */
- | "_nin" | "_sub" | "_isub" | "_usub" | "_iusub" | "_regex" | "_gt" | "_lt" | "_gte" | "_lte" | MultiOperandOps;
-export declare type SingleOperator<T> = {
-    [key in Exclude<Op, MultiOperandOps>]?: {
-        [name in keyof T]?: any;
-    };
-};
-export declare type MultileOperator<T> = {
-    [key in MultiOperandOps]?: (SingleOperator<T> | MultileOperator<T>)[];
-};
-export declare type QueryCondition<T> = SingleOperator<T> | MultileOperator<T>;
+export declare type MultiOperandOps = "_and" | "_or";
+export declare type Op = "_eq" | "_neq" | "_in"
+/**
+ * Does not belong to array
+ */
+ | "_nin" | "_sub" | "_isub" | "_usub" | "_iusub" | "_regex" | "_gt" | "_lt" | "_gte" | "_lte" | MultiOperandOps;
+export declare type SingleOperator<T> = {
+    [key in Exclude<Op, MultiOperandOps>]?: {
+        [name in keyof T]?: any;
+    };
+};
+export declare type MultileOperator<T> = {
+    [key in MultiOperandOps]?: (SingleOperator<T> | MultileOperator<T>)[];
+};
+export declare type QueryCondition<T> = SingleOperator<T> | MultileOperator<T>;

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

@@ -1,20 +1,20 @@
-import { ModelMetadata, AbstractModel, IInit, Constructor } from "@clairejs/core";
-import { IQueryProvider } from "./IQueryProvider";
-import { IQuery } from "./IQuery";
-import { ITransaction } from "../transaction/ITransaction";
-import { ITransactionFactory } from "../transaction/ITransactionFactory";
-export declare type ConnectionHolder<T> = {
-    connection: T;
-};
-export declare abstract class AbstractDatabaseAdapter implements IInit, IQueryProvider, ITransactionFactory {
-    protected modelMetadata: ModelMetadata[];
-    protected models: Constructor<AbstractModel>[];
-    protected modelConnections: {
-        [key: string]: ConnectionHolder<any>;
-    };
-    protected constructor();
-    abstract createTransaction(): Promise<ITransaction>;
-    abstract use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
-    init(): Promise<void>;
-    exit(): void;
-}
+import { ModelMetadata, AbstractModel, IInit, Constructor } from "@clairejs/core";
+import { IQueryProvider } from "./IQueryProvider";
+import { IQuery } from "./IQuery";
+import { ITransaction } from "../transaction/ITransaction";
+import { ITransactionFactory } from "../transaction/ITransactionFactory";
+export declare type ConnectionHolder<T> = {
+    connection: T;
+};
+export declare abstract class AbstractDatabaseAdapter implements IInit, IQueryProvider, ITransactionFactory {
+    protected modelMetadata: ModelMetadata[];
+    protected models: Constructor<AbstractModel>[];
+    protected modelConnections: {
+        [key: string]: ConnectionHolder<any>;
+    };
+    protected constructor();
+    abstract createTransaction(): Promise<ITransaction>;
+    abstract use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
+    init(): Promise<void>;
+    exit(): void;
+}

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

@@ -1,53 +1,53 @@
-import { AbstractModel, ModelMetadata, Constructor } from "@clairejs/core";
-import { QueryCondition } from "../QueryOperator";
-import { IGroupBy, IJoin, IQuery, ISelect, IWhere, JoinMode, OrderDirective } from "./IQuery";
-export declare abstract class AbstractQuery<T extends AbstractModel> implements IQuery<T> {
-    readonly metadata: ModelMetadata;
-    readonly model: Constructor<T>;
-    protected constructor(model: Constructor<AbstractModel>);
-    abstract join<K extends AbstractModel>(model: Constructor<K>, leftField: keyof T, rightField: keyof K, joinMode?: JoinMode): IJoin<T & K> & IWhere<T & K> & IGroupBy<T & K> & ISelect<T & K>;
-    abstract getById<K extends keyof T>(id: number, options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K> | undefined>;
-    abstract getByIds<K extends keyof T>(ids: number[], options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K>[]>;
-    abstract getOne<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K> | undefined>;
-    abstract getMany<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        order?: OrderDirective<T>;
-        projection?: K[];
-        limit?: number;
-        page?: number;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<{
-        total: number;
-        records: Pick<T, K>[];
-    }>;
-    abstract getRecords<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        order?: OrderDirective<T>;
-        projection?: K[];
-        limit?: number;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<Pick<T, K>[]>;
-    abstract createOne(modelInstance: Partial<T>): Promise<T>;
-    abstract count(queries?: QueryCondition<T>, options?: {
-        distinct?: keyof T;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<number>;
-    abstract createMany(modelInstances: Partial<T>[]): Promise<T[]>;
-    abstract updateOne(modelInstance: T): Promise<T>;
-    abstract updateMany(queries: QueryCondition<T>, update: Partial<T>, returning?: boolean): Promise<number[]>;
-    abstract deleteOne(modelInstance: T): Promise<T>;
-    abstract deleteMany(queries: QueryCondition<T>, returning?: boolean): Promise<T[]>;
-    abstract rawQuery(...args: any[]): Promise<any>;
-    protected convertToLogicObjects<K extends keyof T>(dataObjects: T[], projection?: K[]): Pick<T, K>[];
-    protected convertToDataObjects(modelInstances: Partial<T>[], forUpdate?: boolean): any[];
-}
+import { AbstractModel, ModelMetadata, Constructor } from "@clairejs/core";
+import { QueryCondition } from "../QueryOperator";
+import { IGroupBy, IJoin, IQuery, ISelect, IWhere, JoinMode, OrderDirective } from "./IQuery";
+export declare abstract class AbstractQuery<T extends AbstractModel> implements IQuery<T> {
+    readonly metadata: ModelMetadata;
+    readonly model: Constructor<T>;
+    protected constructor(model: Constructor<AbstractModel>);
+    abstract join<K extends AbstractModel>(model: Constructor<K>, leftField: keyof T, rightField: keyof K, joinMode?: JoinMode): IJoin<T & K> & IWhere<T & K> & IGroupBy<T & K> & ISelect<T & K>;
+    abstract getById<K extends keyof T>(id: number, options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K> | undefined>;
+    abstract getByIds<K extends keyof T>(ids: number[], options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K>[]>;
+    abstract getOne<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K> | undefined>;
+    abstract getMany<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        order?: OrderDirective<T>;
+        projection?: K[];
+        limit?: number;
+        page?: number;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<{
+        total: number;
+        records: Pick<T, K>[];
+    }>;
+    abstract getRecords<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        order?: OrderDirective<T>;
+        projection?: K[];
+        limit?: number;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<Pick<T, K>[]>;
+    abstract createOne(modelInstance: Partial<T>): Promise<T>;
+    abstract count(queries?: QueryCondition<T>, options?: {
+        distinct?: keyof T;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<number>;
+    abstract createMany(modelInstances: Partial<T>[]): Promise<T[]>;
+    abstract updateOne(modelInstance: T): Promise<T>;
+    abstract updateMany(queries: QueryCondition<T>, update: Partial<T>, returning?: boolean): Promise<number[]>;
+    abstract deleteOne(modelInstance: T): Promise<T>;
+    abstract deleteMany(queries: QueryCondition<T>, returning?: boolean): Promise<T[]>;
+    abstract rawQuery(...args: any[]): Promise<any>;
+    protected convertToLogicObjects<K extends keyof T>(dataObjects: T[], projection?: K[]): Pick<T, K>[];
+    protected convertToDataObjects(modelInstances: Partial<T>[], forUpdate?: boolean): any[];
+}

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

@@ -1,17 +1,17 @@
-import { AbstractModel, AbstractLogger, Constructor } from "@clairejs/core";
-import { ITransaction } from "../transaction/ITransaction";
-import { AbstractDatabaseAdapter } from "./AbstractDatabaseAdapter";
-import { IQuery } from "./IQuery";
-import { SqlProvider } from "./providers";
-export declare class DefaultSqlDatabaseAdapter extends AbstractDatabaseAdapter {
-    readonly logger: AbstractLogger;
-    private readonly sqlProvider;
-    private readonly dbConnection;
-    private readonly modelAdapters;
-    constructor(sqlProvider: SqlProvider, connectionString: string, logger: AbstractLogger);
-    createTransaction(): Promise<ITransaction>;
-    init(): Promise<void>;
-    exit(): number;
-    use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
-    private generateSchemaObject;
-}
+import { AbstractModel, AbstractLogger, Constructor } from "@clairejs/core";
+import { ITransaction } from "../transaction/ITransaction";
+import { AbstractDatabaseAdapter } from "./AbstractDatabaseAdapter";
+import { IQuery } from "./IQuery";
+import { SqlProvider } from "./providers";
+export declare class DefaultSqlDatabaseAdapter extends AbstractDatabaseAdapter {
+    readonly logger: AbstractLogger;
+    private readonly sqlProvider;
+    private readonly dbConnection;
+    private readonly modelAdapters;
+    constructor(sqlProvider: SqlProvider, connectionString: string, logger: AbstractLogger);
+    createTransaction(): Promise<ITransaction>;
+    init(): Promise<void>;
+    exit(): number;
+    use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
+    private generateSchemaObject;
+}

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

@@ -1,77 +1,77 @@
-import { AbstractModel, Constructor, OrderDirection } from "@clairejs/core";
-import { QueryCondition } from "../QueryOperator";
-import { Aggregator, HavingCondition } from "./aggregators";
-/**
- * Query condition based on a interface/class.
- */
-export declare type JoinMode = "inner" | "left" | "right";
-export declare type OrderDirective<K> = [keyof K, OrderDirection][] | "random";
-export interface ISelect<T> {
-    count(): Promise<number>;
-    rows<K>(mapping: {
-        [field in keyof K]: Aggregator<T>;
-    }, options?: {
-        order?: OrderDirective<T>;
-        limit?: number;
-        page?: number;
-    }): Promise<{
-        total: number;
-        records: K[];
-    }>;
-}
-export interface IHaving<T> {
-    having(conditions: HavingCondition<T>): ISelect<T>;
-}
-export interface IGroupBy<T> {
-    groupBy(fields: (keyof T)[]): IHaving<T> & ISelect<T>;
-}
-export interface IWhere<T> {
-    where(queries?: QueryCondition<T>): IGroupBy<T> & ISelect<T>;
-}
-export interface IJoin<T extends AbstractModel> {
-    join<K extends AbstractModel>(model: Constructor<K>, leftField: keyof T, rightField: keyof K, joinMode?: JoinMode): IJoin<T & K> & IWhere<T & K> & IGroupBy<T & K> & ISelect<T & K>;
-}
-export interface IQuery<T extends AbstractModel> extends IJoin<T> {
-    createOne(modelInstance: Partial<T>): Promise<T>;
-    getById<K extends keyof T>(id: number, options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K> | undefined>;
-    getByIds<K extends keyof T>(ids: number[], options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K>[]>;
-    getOne<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        projection?: K[];
-    }): Promise<Pick<T, K> | undefined>;
-    count(queries?: QueryCondition<T>, options?: {
-        distinct?: keyof T;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<number>;
-    getMany<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        order?: OrderDirective<T>;
-        projection?: K[];
-        limit?: number;
-        page?: number;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<{
-        total: number;
-        records: Pick<T, K>[];
-    }>;
-    getRecords<K extends keyof T>(queries?: QueryCondition<T>, options?: {
-        order?: OrderDirective<T>;
-        projection?: K[];
-        limit?: number;
-    }, includes?: {
-        modelId: string;
-        queries: QueryCondition<any>;
-    }[]): Promise<Pick<T, K>[]>;
-    createMany(modelInstances: Partial<T>[]): Promise<T[]>;
-    updateOne(modelInstance: T): Promise<T>;
-    updateMany(queries: QueryCondition<T> | undefined, update: Partial<T>, returning?: boolean): Promise<number[]>;
-    deleteOne(modelInstance: T): Promise<T>;
-    deleteMany(queries?: QueryCondition<T>, returning?: boolean): Promise<T[]>;
-    rawQuery(...args: any[]): Promise<any>;
-}
+import { AbstractModel, Constructor, OrderDirection } from "@clairejs/core";
+import { QueryCondition } from "../QueryOperator";
+import { Aggregator, HavingCondition } from "./aggregators";
+/**
+ * Query condition based on a interface/class.
+ */
+export declare type JoinMode = "inner" | "left" | "right";
+export declare type OrderDirective<K> = [keyof K, OrderDirection][] | "random";
+export interface ISelect<T> {
+    count(): Promise<number>;
+    rows<K>(mapping: {
+        [field in keyof K]: Aggregator<T>;
+    }, options?: {
+        order?: OrderDirective<T>;
+        limit?: number;
+        page?: number;
+    }): Promise<{
+        total: number;
+        records: K[];
+    }>;
+}
+export interface IHaving<T> {
+    having(conditions: HavingCondition<T>): ISelect<T>;
+}
+export interface IGroupBy<T> {
+    groupBy(fields: (keyof T)[]): IHaving<T> & ISelect<T>;
+}
+export interface IWhere<T> {
+    where(queries?: QueryCondition<T>): IGroupBy<T> & ISelect<T>;
+}
+export interface IJoin<T extends AbstractModel> {
+    join<K extends AbstractModel>(model: Constructor<K>, leftField: keyof T, rightField: keyof K, joinMode?: JoinMode): IJoin<T & K> & IWhere<T & K> & IGroupBy<T & K> & ISelect<T & K>;
+}
+export interface IQuery<T extends AbstractModel> extends IJoin<T> {
+    createOne(modelInstance: Partial<T>): Promise<T>;
+    getById<K extends keyof T>(id: number, options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K> | undefined>;
+    getByIds<K extends keyof T>(ids: number[], options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K>[]>;
+    getOne<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        projection?: K[];
+    }): Promise<Pick<T, K> | undefined>;
+    count(queries?: QueryCondition<T>, options?: {
+        distinct?: keyof T;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<number>;
+    getMany<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        order?: OrderDirective<T>;
+        projection?: K[];
+        limit?: number;
+        page?: number;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<{
+        total: number;
+        records: Pick<T, K>[];
+    }>;
+    getRecords<K extends keyof T>(queries?: QueryCondition<T>, options?: {
+        order?: OrderDirective<T>;
+        projection?: K[];
+        limit?: number;
+    }, includes?: {
+        modelId: string;
+        queries: QueryCondition<any>;
+    }[]): Promise<Pick<T, K>[]>;
+    createMany(modelInstances: Partial<T>[]): Promise<T[]>;
+    updateOne(modelInstance: T): Promise<T>;
+    updateMany(queries: QueryCondition<T> | undefined, update: Partial<T>, returning?: boolean): Promise<number[]>;
+    deleteOne(modelInstance: T): Promise<T>;
+    deleteMany(queries?: QueryCondition<T>, returning?: boolean): Promise<T[]>;
+    rawQuery(...args: any[]): Promise<any>;
+}

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

@@ -1,9 +1,9 @@
-import { AbstractModel, Constructor } from "@clairejs/core";
-import { IQuery } from "./IQuery";
-export interface IQueryProvider {
-    /**
-     * Use a model to provide the query interface for this model.
-     * @param model the model to get query interface
-     */
-    use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
-}
+import { AbstractModel, Constructor } from "@clairejs/core";
+import { IQuery } from "./IQuery";
+export interface IQueryProvider {
+    /**
+     * Use a model to provide the query interface for this model.
+     * @param model the model to get query interface
+     */
+    use<T extends AbstractModel>(model: Constructor<T>): IQuery<T>;
+}

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

@@ -1,21 +1,21 @@
-import { MultiOperandOps, Op } from "../QueryOperator";
-export declare type AggregatorFn = "count" | "sum" | "avg" | "min" | "max" | "join" | "is";
-export interface Aggregator<T> {
-    fn: AggregatorFn;
-    field: keyof T;
-    args?: any;
-}
-export declare type SingleHaving<T> = {
-    [key in Exclude<Op, MultiOperandOps>]?: [Aggregator<T>, any];
-};
-export declare type MultileHaving<T> = {
-    [key in MultiOperandOps]?: (SingleHaving<T> | MultileHaving<T>)[];
-};
-export declare type HavingCondition<T> = SingleHaving<T> | MultileHaving<T>;
-export declare const _count: <T>(field: keyof T, distinct?: boolean | undefined) => Aggregator<T>;
-export declare const _sum: <T>(field: keyof T) => Aggregator<T>;
-export declare const _avg: <T>(field: keyof T) => Aggregator<T>;
-export declare const _min: <T>(field: keyof T) => Aggregator<T>;
-export declare const _max: <T>(field: keyof T) => Aggregator<T>;
-export declare const _join: <T>(field: keyof T, symbol: string) => Aggregator<T>;
-export declare const _is: <T>(field: keyof T) => Aggregator<T>;
+import { MultiOperandOps, Op } from "../QueryOperator";
+export declare type AggregatorFn = "count" | "sum" | "avg" | "min" | "max" | "join" | "is";
+export interface Aggregator<T> {
+    fn: AggregatorFn;
+    field: keyof T;
+    args?: any;
+}
+export declare type SingleHaving<T> = {
+    [key in Exclude<Op, MultiOperandOps>]?: [Aggregator<T>, any];
+};
+export declare type MultileHaving<T> = {
+    [key in MultiOperandOps]?: (SingleHaving<T> | MultileHaving<T>)[];
+};
+export declare type HavingCondition<T> = SingleHaving<T> | MultileHaving<T>;
+export declare const _count: <T>(field: keyof T, distinct?: boolean | undefined) => Aggregator<T>;
+export declare const _sum: <T>(field: keyof T) => Aggregator<T>;
+export declare const _avg: <T>(field: keyof T) => Aggregator<T>;
+export declare const _min: <T>(field: keyof T) => Aggregator<T>;
+export declare const _max: <T>(field: keyof T) => Aggregator<T>;
+export declare const _join: <T>(field: keyof T, symbol: string) => Aggregator<T>;
+export declare const _is: <T>(field: keyof T) => Aggregator<T>;