@nu-art/firebase-backend 0.500.0 → 0.500.6

package/firestore/FirestoreTransaction.js

@@ -1,153 +0,0 @@
-/*
- * Firebase is a simpler Typescript wrapper to all of firebase services.
- *
- * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { DocWrapper, } from './FirestoreCollection.js';
-import { BadImplementationException, merge } from '@nu-art/ts-common';
-import { FirestoreInterface } from './FirestoreInterface.js';
-export class FirestoreTransaction {
-    transaction;
-    constructor(transaction) {
-        this.transaction = transaction;
-    }
-    async _query(collection, ourQuery) {
-        const query = FirestoreInterface.buildQuery(collection, ourQuery);
-        return (await this.transaction.get(query)).docs;
-    }
-    async _queryUnique(collection, ourQuery) {
-        const results = await this._query(collection, ourQuery);
-        return FirestoreInterface.assertUniqueDocument(results, ourQuery, collection.name);
-    }
-    async _queryItem(collection, instance) {
-        const ourQuery = FirestoreInterface.buildUniqueQuery(collection, instance);
-        const results = await this._query(collection, ourQuery);
-        return FirestoreInterface.assertUniqueDocument(results, ourQuery, collection.name);
-    }
-    async query(collection, ourQuery) {
-        return (await this._query(collection, ourQuery)).map(result => result.data());
-    }
-    async queryItem(collection, instance) {
-        const ourQuery = FirestoreInterface.buildUniqueQuery(collection, instance);
-        return this.queryUnique(collection, ourQuery);
-    }
-    async queryUnique(collection, ourQuery) {
-        const doc = await this._queryUnique(collection, ourQuery);
-        if (!doc)
-            return;
-        return doc.data();
-    }
-    async insert(collection, instance, _id) {
-        const doc = collection.createDocumentReference(_id);
-        try {
-            await this.transaction.create(doc, instance);
-        }
-        catch (e) {
-            console.error('Failed creating object: ', instance, e);
-            throw e;
-        }
-        return instance;
-    }
-    async insertAll(collection, instances, _ids) {
-        return await Promise.all(instances.map((instance, i) => this.insert(collection, instance, _ids?.[i])));
-    }
-    //------------------------
-    async upsert(collection, instance, _id) {
-        return (await this.upsert_Read(collection, instance, _id))();
-    }
-    async upsert_Read(collection, instance, _id) {
-        const ref = await this.getOrCreateDocument(collection, instance, _id);
-        return async () => {
-            try {
-                await this.transaction.set(ref, instance);
-            }
-            catch (e) {
-                console.error('Failed creating object: ', instance, e);
-                throw e;
-            }
-            return instance;
-        };
-    }
-    async getOrCreateDocument(collection, instance, _id) {
-        let ref = (await this._queryItem(collection, instance))?.ref;
-        if (!ref)
-            ref = collection.createDocumentReference(_id);
-        return ref;
-    }
-    async upsertAll(collection, instances, _ids) {
-        if (instances.length > 500)
-            throw new BadImplementationException('Firestore transaction supports maximum 500 at a time');
-        return (await this.upsertAll_Read(collection, instances, _ids))();
-    }
-    async upsertAll_Read(collection, instances, _ids) {
-        const writes = await Promise.all(instances.map(async (instance, i) => this.upsert_Read(collection, instance, _ids?.[i])));
-        return async () => Promise.all(writes.map(async (_write) => _write()));
-    }
-    async patch(collection, instance) {
-        return (await this.patch_Read(collection, instance))();
-    }
-    async patch_Read(collection, instance) {
-        const doc = await this._queryItem(collection, instance);
-        if (!doc)
-            throw new BadImplementationException(`Patching a non existent doc for query ${FirestoreInterface.buildUniqueQuery(collection, instance)}`);
-        return async () => {
-            const patchedInstance = merge(await doc.data(), instance);
-            this.transaction.set(doc.ref, patchedInstance);
-            return patchedInstance;
-        };
-    }
-    async delete(collection, ourQuery) {
-        return await (await this.delete_Read(collection, ourQuery))();
-    }
-    async delete_Read(collection, ourQuery) {
-        const docs = await this._query(collection, ourQuery);
-        if (docs.length > 500)
-            throw new BadImplementationException(`Trying to delete ${docs.length} documents. Not allowed more then 5oo in a single transaction`);
-        return async () => {
-            const toReturn = docs.map(doc => doc.data());
-            await Promise.all(docs.map(async (doc) => this.transaction.delete(doc.ref)));
-            return toReturn;
-        };
-    }
-    async deleteItem(collection, instance) {
-        return this.deleteUnique(collection, FirestoreInterface.buildUniqueQuery(collection, instance));
-    }
-    async deleteUnique(collection, ourQuery) {
-        const write = await this.deleteUnique_Read(collection, ourQuery);
-        if (!write)
-            return;
-        return write();
-    }
-    async deleteUnique_Read(collection, ourQuery) {
-        const doc = (await this._queryUnique(collection, ourQuery));
-        if (!doc)
-            return;
-        return async () => {
-            const result = doc.data();
-            await this.transaction.delete(doc.ref);
-            return result;
-        };
-    }
-    async newQueryUnique(collection, ourQuery) {
-        const doc = await this._queryUnique(collection, ourQuery);
-        if (!doc || !doc.exists)
-            return;
-        return new DocWrapper(collection.wrapper, doc);
-    }
-    async newQuery(collection, ourQuery) {
-        const docs = await this._query(collection, ourQuery);
-        return docs.filter(doc => doc.exists).map(doc => new DocWrapper(collection.wrapper, doc));
-    }
-}

package/firestore-v3/DocWrapperV3.d.ts

@@ -1,33 +0,0 @@
-import { DB_Prototype } from '@nu-art/db-api-shared';
-import { TS_Object, UniqueId } from '@nu-art/ts-common';
-import { FirestoreType_DocumentReference } from '../firestore/types.js';
-import { Transaction } from 'firebase-admin/firestore';
-import { FirestoreCollectionV3 } from './FirestoreCollectionV3.js';
-import type { firestore as Fa } from 'firebase-admin';
-export type UpdateObject<DBType extends TS_Object> = {
-    _id: UniqueId;
-} & Fa.UpdateData<DBType>;
-export declare class DocWrapperV3<Proto extends DB_Prototype> {
-    readonly ref: FirestoreType_DocumentReference<Proto['dbType']>;
-    readonly collection: FirestoreCollectionV3<Proto>;
-    data?: Proto['dbType'];
-    protected constructor(collection: FirestoreCollectionV3<Proto>, ref: FirestoreType_DocumentReference<Proto['dbType']>, data?: Proto['dbType']);
-    fromCache: () => Proto["dbType"] | undefined;
-    cleanCache: () => DocWrapperV3<Proto>;
-    private assertId;
-    get: (transaction?: Transaction) => Promise<Proto["dbType"] | undefined>;
-    prepareForCreate: (preDBItem: Proto["uiType"], transaction?: Transaction, upgrade?: boolean) => Promise<Proto["dbType"]>;
-    create: (preDBItem: Proto["uiType"], transaction?: Transaction) => Promise<Proto["dbType"]>;
-    prepareForSet: (updatedDBItem: Proto["dbType"], dbItem?: Proto["dbType"], transaction?: Transaction, upgrade?: boolean) => Promise<Proto["dbType"]>;
-    set: (item: Proto["uiType"] | Proto["dbType"], transaction?: Transaction) => Promise<Proto["dbType"]>;
-    private postWriteProcessing;
-    prepareForUpdate(updateData: UpdateObject<Proto['dbType']>, transaction?: Transaction): Promise<UpdateObject<Proto["dbType"]>>;
-    /**
-     * Recursively replaces any undefined or null fields in DB item with firestore.FieldValue.delete()
-     * @private
-     * @param updateData
-     */
-    private updateDeletedFields;
-    update: (updateData: UpdateObject<Proto["dbType"]>) => Promise<Proto["dbType"] | undefined>;
-    delete: (transaction?: Transaction) => Promise<Proto["dbType"] | undefined>;
-}

package/firestore-v3/FirestoreCollectionV3.d.ts

@@ -1,155 +0,0 @@
-import { Database, DB_Prototype } from '@nu-art/db-api-shared';
-import { CustomException, InvalidResult, Logger, TS_Object, UniqueId } from '@nu-art/ts-common';
-import { FirestoreType_Collection, FirestoreType_DocumentReference } from '../firestore/types.js';
-import { Clause_Where, FirestoreQuery, MultiWriteOperation } from '@nu-art/firebase-shared';
-import { FirestoreWrapperBEV3 } from './FirestoreWrapperBEV3.js';
-import { Transaction } from 'firebase-admin/firestore';
-import { firestore } from 'firebase-admin';
-import { DocWrapperV3, UpdateObject } from './DocWrapperV3.js';
-import UpdateData = firestore.UpdateData;
-export type PostWriteProcessingData<DBType extends TS_Object> = {
-    before?: DBType | DBType[];
-    updated?: DBType | DBType[];
-    deleted?: DBType | DBType[] | null;
-};
-export type CollectionActionType = 'create' | 'set' | 'update' | 'delete';
-export type FirestoreCollectionHooks<DBType extends TS_Object> = {
-    canDeleteItems: (dbItems: DBType[], transaction?: Transaction) => Promise<void>;
-    preWriteProcessing?: (dbInstance: DBType, originalDbInstance?: DBType, transaction?: Transaction) => Promise<void>;
-    manipulateQuery?: (query: FirestoreQuery<DBType>) => FirestoreQuery<DBType>;
-    postWriteProcessing?: (data: PostWriteProcessingData<DBType>, actionType: CollectionActionType, transaction?: Transaction) => Promise<void>;
-    upgradeInstances: (instances: DBType[]) => Promise<any>;
-};
-export type MultiWriteItem<Op extends MultiWriteOperation, DBType extends TS_Object> = Op extends 'delete' ? undefined : Op extends 'update' ? UpdateObject<DBType> : DBType;
-type MultiWriteType = 'bulk' | 'batch';
-/**
- * # <ins>FirestoreBulkException</ins>
- * @category Exceptions
- */
-export declare class FirestoreBulkException extends CustomException {
-    causes?: Error[];
-    constructor(causes?: Error[]);
-}
-/**
- * FirestoreCollection is a class for handling Firestore collections.
- */
-export declare class FirestoreCollectionV3<Proto extends DB_Prototype> extends Logger {
-    readonly wrapper: FirestoreWrapperBEV3;
-    readonly collection: FirestoreType_Collection;
-    readonly dbDef: Database<Proto>;
-    readonly uniqueKeys: Proto['uniqueKeys'][] | string[];
-    private readonly validator;
-    readonly hooks?: FirestoreCollectionHooks<Proto['dbType']>;
-    constructor(wrapper: FirestoreWrapperBEV3, _dbDef: Database<Proto>, hooks?: FirestoreCollectionHooks<Proto['dbType']>);
-    doc: Readonly<{
-        _: (ref: FirestoreType_DocumentReference<Proto["dbType"]>, data?: Proto["dbType"]) => DocWrapperV3<Proto>;
-        unique: (id: Proto["uniqueParam"]) => DocWrapperV3<Proto>;
-        item: (item: Proto["uiType"]) => DocWrapperV3<Proto>;
-        all: (_ids: (Proto["uniqueParam"])[]) => DocWrapperV3<Proto>[];
-        allItems: (preDBItems: Proto["uiType"][]) => DocWrapperV3<Proto>[];
-        query: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<DocWrapperV3<Proto>[]>;
-        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<DocWrapperV3<Proto>[]>;
-    }>;
-    private getAll;
-    private _customQuery;
-    query: Readonly<{
-        unique: (_id: Proto["uniqueParam"], transaction?: Transaction) => Promise<Proto["dbType"] | undefined>;
-        uniqueAssert: (_id: Proto["uniqueParam"], transaction?: Transaction) => Promise<Proto["dbType"]>;
-        uniqueWhere: (where: Clause_Where<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"]>;
-        uniqueCustom: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"]>;
-        all: (_ids: (Proto["uniqueParam"])[], transaction?: Transaction) => Promise<(Proto["dbType"] | undefined)[]>;
-        custom: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        where: (where: Clause_Where<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-    }>;
-    uniqueGetOrCreate: (where: Clause_Where<Proto["dbType"]>, toCreate: (transaction?: Transaction) => Promise<Proto["uiType"]>, transaction?: Transaction) => Promise<Proto["dbType"] | Proto["uiType"]>;
-    protected _createAll: (preDBItems: Proto["uiType"][], transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-    create: Readonly<{
-        item: (preDBItem: Proto["uiType"], transaction?: Transaction) => Promise<Proto["dbType"]>;
-        all: (preDBItems: Proto["uiType"][], transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-    }>;
-    private _setAll;
-    set: Readonly<{
-        item: (preDBItem: Proto["uiType"], transaction?: Transaction) => Promise<Proto["dbType"]>;
-        all: (items: (Proto["uiType"] | Proto["dbType"])[], transaction?: Transaction) => Promise<Awaited<Proto["dbType"]>[]>;
-        /**
-         * Multi is a non atomic operation
-         */
-        multi: (items: (Proto["uiType"] | Proto["dbType"])[], transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<Awaited<Proto["dbType"]>[]>;
-    }>;
-    private upgradeInstances;
-    protected _updateAll: (updateData: UpdateObject<Proto["dbType"]>[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-    validateUpdateData(updateData: UpdateData<Proto['dbType']>, transaction?: Transaction): Promise<void>;
-    protected _deleteQuery: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
-    protected _deleteUnManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
-    protected _deleteAll: (docsToBeDeleted: DocWrapperV3<Proto>[], transaction?: Transaction, multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-    private deleteCollection;
-    delete: Readonly<{
-        unique: (id: Proto["uniqueParam"], transaction?: Transaction) => Promise<Proto["dbType"] | undefined>;
-        item: (item: Proto["uiType"], transaction?: Transaction) => Promise<Proto["dbType"] | undefined>;
-        all: (ids: (Proto["uniqueParam"])[], transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        allDocs: (docs: DocWrapperV3<Proto>[], transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        allItems: (items: Proto["uiType"][], transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        query: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        unManipulatedQuery: (query: FirestoreQuery<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        where: (where: Clause_Where<Proto["dbType"]>, transaction?: Transaction) => Promise<Proto["dbType"][]>;
-        /**
-         * Multi is a non atomic operation - doesn't use transactions. Use 'all' variants for transaction.
-         */
-        multi: {
-            all: (ids: UniqueId[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-            items: (items: Proto["uiType"][], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-            allDocs: (docs: DocWrapperV3<Proto>[], multiWriteType?: MultiWriteType) => Promise<Proto["dbType"][]>;
-            query: (query: FirestoreQuery<Proto["dbType"]>, multiWriteType?: MultiWriteType) => Promise<NonNullable<Proto["dbType"]>[]>;
-        };
-        yes: {
-            iam: {
-                sure: {
-                    iwant: {
-                        todelete: {
-                            the: {
-                                collection: {
-                                    delete: () => Promise<void>;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    }>;
-    /**
-     * @param writer Type of BulkWriter - can be Bulk writer or Batch writer
-     * @param doc
-     * @param operation create/update/set/delete
-     * @param item - mandatory for everything but delete
-     */
-    private addToMultiWrite;
-    private multiWrite;
-    private bulkWrite;
-    /**
-     * @param docs docs to write to
-     * @param operation create/update/set/delete
-     * @param items mandatory for everything but delete
-     */
-    private batchWrite;
-    /**
-     * A firestore transaction is run globally on the firestore project and not specifically on any collection, locking specific documents in the project.
-     * @param processor
-     * @param transaction A transaction that was provided to be used
-     */
-    runTransaction: <ReturnType>(processor: (transaction: Transaction) => Promise<ReturnType>, transaction?: Transaction) => Promise<ReturnType>;
-    runTransactionInChunks: <T = any, R = any>(items: T[], processor: (chunk: typeof items, transaction: Transaction) => Promise<R[]>, chunkSize?: number) => Promise<R[]>;
-    getVersion: () => any;
-    needsUpgrade: (version?: string) => boolean;
-    validateItem(dbItem: Proto['dbType']): void;
-    protected onValidationError(instance: Proto['dbType'], results: InvalidResult<Proto['dbType']>): void;
-    private assertNoDuplicatedIds;
-    composeDbObjectUniqueId: (item: Proto["uiType"]) => string;
-}
-/**
- * If the collection has unique keys, assert they exist, and use them to generate the _id.
- * In the case an _id already exists, verify it is not different from the uniqueKeys-generated _id.
- */
-export declare const assertUniqueId: <Proto extends DB_Prototype>(item: Proto["dbType"], keys: Proto["uniqueKeys"]) => Proto["dbType"]["_id"];
-export {};