@goatlab/fluent-pouchdb 0.7.10 → 0.7.12

package/dist/PouchDBConnector.d.ts

@@ -0,0 +1,115 @@
+import type { AnyObject } from '@goatlab/js-utils';
+import { z } from 'zod';
+export interface PouchDBConnectorParams<Input, Output> {
+    entity: any;
+    dataSource: PouchDB.Database;
+    inputSchema: z.ZodType<Input>;
+    outputSchema?: z.ZodType<Output>;
+}
+interface FluentQuery<T> {
+    where?: any;
+    select?: any;
+    include?: any;
+    orderBy?: any[];
+    limit?: number;
+    offset?: number;
+    paginated?: {
+        page: number;
+        perPage: number;
+    };
+}
+interface FindByIdFilter<T> {
+    select?: any;
+    include?: any;
+    limit?: number;
+}
+interface LoadedResult<T> {
+}
+type QueryOutput<T, U> = any;
+interface FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
+    insert(data: InputDTO): Promise<OutputDTO>;
+    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    updateById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    replaceById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    deleteById(id: string): Promise<string>;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO> | null>;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<QueryOutput<FindByIdFilter<ModelDTO>, ModelDTO>>;
+    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>>;
+    pluck(path: any, query?: FluentQuery<ModelDTO>): Promise<any[]>;
+    clear(): Promise<boolean>;
+}
+declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
+    protected outputKeys: string[];
+    protected modelRelations: any[];
+    isMongoDB: boolean;
+    protected relationQuery?: any;
+    findFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO> | null>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<QueryOutput<FindByIdFilter<ModelDTO>, ModelDTO>>;
+    requireFirst<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>>;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    setRelatedQuery(query: any): void;
+    abstract insert(data: InputDTO): Promise<OutputDTO>;
+    abstract insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    abstract updateById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    abstract replaceById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    abstract deleteById(id: string): Promise<string>;
+    abstract findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    abstract pluck(path: any, query?: FluentQuery<ModelDTO>): Promise<any[]>;
+    abstract clear(): Promise<boolean>;
+}
+export declare class PouchDBConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = ModelDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
+    private readonly dataSource;
+    private readonly inputSchema;
+    private readonly outputSchema;
+    private readonly entity;
+    constructor({ entity, dataSource, inputSchema, outputSchema }: PouchDBConnectorParams<InputDTO, OutputDTO>);
+    /**
+     *
+     * @param data
+     */
+    insert(data: InputDTO): Promise<OutputDTO>;
+    /**
+     *
+     * @param data
+     */
+    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    /**
+     * PATCH operation
+     * @param data
+     */
+    updateById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    /**
+     *
+     * PUT operation. All fields not included in the data
+     *  param will be set to null
+     *
+     * @param id
+     * @param data
+     */
+    replaceById(id: string, data: Partial<InputDTO>): Promise<OutputDTO>;
+    /**
+     *
+     * Returns the PouchDB Database, you can use it
+     * form more complex queries
+     *
+     * @param query
+     */
+    raw(): PouchDB.Database;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    getPouchDBWhere(where?: FluentQuery<ModelDTO>['where']): PouchDB.Find.FindRequest<any>;
+    /**
+     *
+     * @param id
+     */
+    deleteById(id: string): Promise<string>;
+    loadFirst(query?: FluentQuery<ModelDTO>): PouchDBConnector<ModelDTO, InputDTO, OutputDTO>;
+    loadById(id: string): LoadedResult<this>;
+    protected clone(): any;
+    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<QueryOutput<T, ModelDTO> | null>;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO>[]>;
+    pluck(path: any, query?: FluentQuery<ModelDTO>): Promise<any[]>;
+    clear(): Promise<boolean>;
+}
+export {};