@goatlab/fluent 0.6.24 → 0.6.30

package/dist/BaseConnector.d.ts

@@ -1,89 +1,59 @@
-import { TypedPathWrapper } from 'typed-path';
 import { Collection } from '@goatlab/js-utils';
-import { Filter, LogicOperator, Primitives, PrimitivesArray } from './types';
-import { ValidationError } from 'class-validator';
-export interface FluentConnectorInterface<InputDTO, OutputDTO> {
-    get(): Promise<OutputDTO[]>;
-    all(filter: Filter): Promise<OutputDTO[]>;
-    findById(id: string): Promise<OutputDTO>;
-    findByIds(id: string[]): Promise<OutputDTO[]>;
-    find(filter: Filter): Promise<OutputDTO[]>;
-    deleteById(id: string): Promise<string>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
+import { FindByIdFilter, FluentHasManyParams, FluentBelongsToParams, FluentBelongsToManyParams, FluentQuery, LogicOperator, Primitives, PrimitivesArray, QueryFieldSelector, QueryOutput, SingleQueryOutput } from './types';
+export interface FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
     insert(data: InputDTO): Promise<OutputDTO>;
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    loadFirst(query?: FluentQuery<ModelDTO>): any;
+    loadById(id: string): any;
+    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
+    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
+    clear(): Promise<boolean>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
 }
 export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
-    generatedKeyPath: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never> & {
-        $path: (path: import("typed-path").TypedPathKey[]) => string;
-        $raw: (path: import("typed-path").TypedPathKey[]) => string[];
-        $rawPath: (path: import("typed-path").TypedPathKey[]) => import("typed-path").TypedPathKey[];
-        toString: (path: import("typed-path").TypedPathKey[]) => () => string;
-        valueOf: (path: import("typed-path").TypedPathKey[]) => () => string;
-        [Symbol.toStringTag]: (path: import("typed-path").TypedPathKey[]) => string;
-    }>;
     protected outputKeys: string[];
-    protected chainReference: any[];
-    protected whereArray: any[];
-    protected orWhereArray: any[];
-    protected selectArray: any[];
-    protected forceSelectArray: any[];
-    protected orderByArray: any[];
-    protected limitNumber: number;
-    protected offsetNumber: number;
-    protected populateArray: any[];
-    protected chunk: any;
-    protected pullSize: any;
-    protected ownerId: any;
-    protected paginator: any;
-    protected rawQuery: any;
-    protected getFirst: boolean;
-    protected relations: any;
-    protected loadModels: boolean;
-    protected relationQuery: any;
+    protected relatedQuery?: {
+        entity: new () => ModelDTO;
+        query?: FluentQuery<ModelDTO>;
+        repository?: any;
+        key?: string;
+        pivot?: any;
+    };
+    protected chunk: null;
+    protected pullSize: null;
+    protected paginator: undefined;
+    protected rawQuery: undefined;
     protected modelRelations: any;
     isMongoDB: boolean;
     constructor();
-    findByIds(ids: string[]): Promise<OutputDTO[]>;
-    get(): Promise<OutputDTO[]>;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
     updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    owner(user: string): this;
-    own(user: string): this;
-    first(): Promise<OutputDTO | null>;
-    collect(): Promise<Collection<OutputDTO>>;
-    select(paths: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>>[] | TypedPathWrapper<string[], Record<never, never>[]>): this;
-    forceSelect(paths: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>>[] | TypedPathWrapper<string[], Record<never, never>[]>): this;
-    offset(offset: number): this;
-    populate(...relations: any[]): this;
-    skip(offset: number): this;
-    where(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives | PrimitivesArray): this;
-    andWhere(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives | Primitives[]): this;
-    orWhere(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives): this;
-    limit(limit: number): this;
-    take(limit: number): this;
-    pluck(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>): Promise<string[]>;
-    orderBy(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, order?: 'asc' | 'desc', orderType?: 'string' | 'number' | 'date'): this;
-    protected jsApplySelect(data: any): any[];
-    protected jsApplyOrderBy(data: any): any[];
-    protected reset(): void;
-    load(): Promise<this>;
-    loadFirst(): Promise<this>;
-    getLoadedData(): OutputDTO[] | OutputDTO;
-    with(entities: any): this;
-    attach(data: InputDTO | OutputDTO): Promise<OutputDTO[]>;
-    associate(id: string): any;
-    protected hasMany<T>(Repository: any, relationName: string): T;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO> | null>;
+    collect(query: FluentQuery<ModelDTO>): Promise<Collection<OutputDTO>>;
+    pluck(path: QueryFieldSelector<ModelDTO>, query?: FluentQuery<ModelDTO>): Promise<Primitives[]>;
+    protected setRelatedQuery(r: {
+        entity: new () => ModelDTO;
+        query?: FluentQuery<ModelDTO>;
+        repository?: any;
+        key?: string;
+    }): void;
+    associate(data: InputDTO | OutputDTO): Promise<OutputDTO[]>;
+    attach(id: string): Promise<any>;
+    protected hasMany<T extends FluentHasManyParams<T>>(r: T): InstanceType<T['repository']>;
+    protected belongsTo<T extends FluentBelongsToParams<T>>(r: T): InstanceType<T['repository']>;
     protected hasOne(): void;
-    protected belongsTo<T>(Repository: any, relationName: string): T;
-    protected belongsToMany<T, R>(Repository: any, Pivot: any, relationName: string): T;
-    withPivot(): this;
+    protected belongsToMany<T extends FluentBelongsToManyParams<T>>(r: T): InstanceType<T['repository']>;
     protected hasManyThrough(): void;
-    private prepareInput;
-    validateInput(validationClass: {
-        new (): ModelDTO;
-    }, input: InputDTO): Promise<{
-        errors: ValidationError[] | null;
-        result: Awaited<InputDTO>;
-    }>;
+    protected clearEmpties(object: any): any;
+    private isAnyObject;
+    protected extractConditions(conditions: FluentQuery<ModelDTO>['where'][]): {
+        operator: LogicOperator;
+        element: string;
+        value: Primitives | PrimitivesArray;
+    }[];
+    protected jsApplySelect(select: FluentQuery<ModelDTO>['select'], data: ModelDTO[]): ModelDTO[];
 }