@goatlab/fluent-firebase 0.6.14 → 0.7.0

package/dist/Firebase.d.ts

@@ -1,7 +1,9 @@
 import * as admin from 'firebase-admin';
 import { getAuth as firebaseGetAuth } from 'firebase-admin/auth';
 export declare type FirebaseUser = admin.auth.DecodedIdToken;
-export declare const Firebase: Readonly<{
+declare class FirebaseClass {
     verifyIdToken: (token: string) => Promise<import("firebase-admin/auth").DecodedIdToken>;
     getAuth: typeof firebaseGetAuth;
-}>;
+}
+export declare const Firebase: FirebaseClass;
+export {};

package/dist/Firebase.js

@@ -4,8 +4,10 @@ exports.Firebase = void 0;
 const tslib_1 = require("tslib");
 const admin = tslib_1.__importStar(require("firebase-admin"));
 const auth_1 = require("firebase-admin/auth");
-exports.Firebase = (() => {
-    const verifyIdToken = (token) => admin.auth().verifyIdToken(token);
-    const getAuth = auth_1.getAuth;
-    return Object.freeze({ verifyIdToken, getAuth });
-})();
+class FirebaseClass {
+    constructor() {
+        this.verifyIdToken = (token) => admin.auth().verifyIdToken(token);
+        this.getAuth = auth_1.getAuth;
+    }
+}
+exports.Firebase = new FirebaseClass();

package/dist/FirebaseConnector.d.ts

@@ -1,41 +1,36 @@
 import * as admin from 'firebase-admin';
-import { BaseFirestoreRepository } from 'fireorm';
-import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '@goatlab/fluent';
-import { BaseConnector, DataSource, FluentConnectorInterface } from '@goatlab/fluent';
-export declare const createFirebaseRepository: (Entity: any, dataSource: DataSource) => {
-    repository: BaseFirestoreRepository<import("fireorm").IEntity>;
-    name: string;
-    path: string;
-    keys: string[];
-    relations: {};
-};
-export declare class FirebaseConnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, DaoOutput<InputDTO, OutputDTO>> {
-    private repository;
+import { AnyObject, FluentQuery, LoadedResult, QueryOutput } from '@goatlab/fluent';
+import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
+import { z } from 'zod';
+import { FindByIdFilter } from '@goatlab/fluent';
+import { SingleQueryOutput } from '@goatlab/fluent';
+export interface FirebaseConnectorParams<Input, Output> {
+    entity: any;
+    inputSchema: z.ZodType<Input>;
+    outputSchema?: z.ZodType<Output>;
+}
+export declare class FirebaseConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
+    private readonly inputSchema;
+    private readonly outputSchema;
     private readonly collection;
-    constructor(Entity: any, dataSource: DataSource, relationQuery?: any);
-    get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    getPaginated(): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
-    all(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    find(filter?: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    paginate(paginator: Paginator): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
+    private readonly entity;
+    constructor({ entity, inputSchema, outputSchema }: FirebaseConnectorParams<InputDTO, OutputDTO>);
+    insert(data: InputDTO): Promise<OutputDTO>;
+    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
     raw(): admin.firestore.CollectionReference<ModelDTO>;
-    insert(data: InputDTO, forcedId?: string | number): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    insertMany(data: InputDTO[], forcedId?: string | number): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    batchInsert(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    replaceById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    clear({ sure }: Sure): Promise<unknown>;
-    deleteById(id: string): Promise<string>;
-    findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    findByIds(ids: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[] | null>;
-    private getPage;
-    private getPaginatorLimit;
-    private getPopulate;
-    private getGeneratedQuery;
-    private getFilters;
-    private getOrderBy;
-    private getLimit;
-    private getSkip;
-    private getSelect;
+    rawFirebase(): admin.firestore.Firestore;
+    protected loadRelatedData(data: any[], loadedKeys: AnyObject): Promise<admin.firestore.DocumentData[]>;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    loadFirst(query?: FluentQuery<ModelDTO>): FirebaseConnector<ModelDTO, InputDTO, OutputDTO>;
+    private getGeneratedQueries;
+    private getFirebaseWhereQuery;
+    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
+    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
+    clear(): Promise<boolean>;
     private deleteQueryBatch;
+    loadById(id: string): LoadedResult<this>;
+    protected clone(): any;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO>>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
 }