@my-devkit/firebase 1.0.193 → 1.0.195

package/src/firestore-client.ts

@@ -4,7 +4,6 @@ import { getFirestore } from 'firebase-admin/firestore';
 import { Injectable, TransactionalClient } from './decorators';
 import { ITransactionalClient } from './interfaces';
 
-
 @TransactionalClient()
 @Injectable()
 export class FirestoreClient implements ITransactionalClient {
@@ -45,7 +44,11 @@ export class FirestoreClient implements ITransactionalClient {
         return this.queryDocument<T>(path);
     }
 
-    public async _findWhere<T extends Document>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], options?: FirestoreClient.QueryOptions): Promise<T> {
+    public async _findWhere<T extends Document>(
+        collection: string,
+        whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
+        options?: FirestoreClient.QueryOptions
+    ): Promise<T> {
         const documents = await this._getWhere<T>(collection, whereClauses, options);
 
         if (documents.length > 1) {
@@ -69,7 +72,11 @@ export class FirestoreClient implements ITransactionalClient {
         return this._getWhere(collection, [], options);
     }
 
-    public async _getWhere<T extends Document>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], options?: FirestoreClient.QueryOptions): Promise<T[]> {
+    public async _getWhere<T extends Document>(
+        collection: string,
+        whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
+        options?: FirestoreClient.QueryOptions
+    ): Promise<T[]> {
         Logger.info(`Repository: getWhere ${collection} whereClauses: ${JSON.stringify(whereClauses)}`);
         const documentMap = await this.queryCollection<T>(collection, whereClauses, options);
 
@@ -118,7 +125,6 @@ export class FirestoreClient implements ITransactionalClient {
         return documents;
     }
 
-
     public createDocument<T extends Document>(document: T): void {
         const existingOperation = this.operations.get(document._path);
 
@@ -136,7 +142,11 @@ export class FirestoreClient implements ITransactionalClient {
                     throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
-            this.operations.set(document._path, { document, action: FirestoreClient.Action.Create, committed: false });
+            this.operations.set(document._path, {
+                document,
+                action: FirestoreClient.Action.Create,
+                committed: false
+            });
         }
     }
 
@@ -155,7 +165,11 @@ export class FirestoreClient implements ITransactionalClient {
                     throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
-            this.operations.set(document._path, { document, action: FirestoreClient.Action.Update, committed: false });
+            this.operations.set(document._path, {
+                document,
+                action: FirestoreClient.Action.Update,
+                committed: false
+            });
         }
     }
 
@@ -177,7 +191,11 @@ export class FirestoreClient implements ITransactionalClient {
                     throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
             }
         } else {
-            this.operations.set(document._path, { document, action: FirestoreClient.Action.Delete, committed: false });
+            this.operations.set(document._path, {
+                document,
+                action: FirestoreClient.Action.Delete,
+                committed: false
+            });
         }
     }
 
@@ -226,39 +244,50 @@ export class FirestoreClient implements ITransactionalClient {
         return result ? deserialize<T>(result) : null;
     }
 
-    private doesDocumentMatchQuery<T extends Document>(document: T, collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][]): boolean {
+    private doesDocumentMatchQuery<T extends Document>(
+        document: T,
+        collection: string,
+        whereClauses: [string, FirestoreClient.Operator, any | any[]][]
+    ): boolean {
         const serializedDocument = serialize(document);
 
-        return document._path.startsWith(`${collection}/`) && whereClauses.every(wc => {
-            const documentValue = serializedDocument[wc[0]];
-            const operator = wc[1];
-            const expectedValue = wc[2];
-
-            switch (operator) {
-                case '==':
-                    return documentValue === expectedValue;
-                case '!=':
-                    return documentValue !== undefined && documentValue !== expectedValue;
-                case '>':
-                    return documentValue > expectedValue;
-                case '>=':
-                    return documentValue >= expectedValue;
-                case '<':
-                    return documentValue < expectedValue;
-                case '<=':
-                    return documentValue <= expectedValue;
-                case 'array-contains':
-                    return Array.isArray(documentValue) && documentValue.includes(expectedValue);
-                case 'array-contains-any':
-                    return Array.isArray(documentValue) && Array.isArray(expectedValue) && documentValue.some(v => expectedValue.includes(v));
-                case 'in':
-                    return Array.isArray(expectedValue) && expectedValue.includes(documentValue);
-                case 'not-in':
-                    return Array.isArray(expectedValue) && !expectedValue.includes(documentValue);
-                default:
-                    throw new Error(`Operator ${operator} not handled!`);
-            }
-        });
+        return (
+            document._path.startsWith(`${collection}/`) &&
+            whereClauses.every(wc => {
+                const documentValue = serializedDocument[wc[0]];
+                const operator = wc[1];
+                const expectedValue = wc[2];
+
+                switch (operator) {
+                    case '==':
+                        return documentValue === expectedValue;
+                    case '!=':
+                        return documentValue !== undefined && documentValue !== expectedValue;
+                    case '>':
+                        return documentValue > expectedValue;
+                    case '>=':
+                        return documentValue >= expectedValue;
+                    case '<':
+                        return documentValue < expectedValue;
+                    case '<=':
+                        return documentValue <= expectedValue;
+                    case 'array-contains':
+                        return Array.isArray(documentValue) && documentValue.includes(expectedValue);
+                    case 'array-contains-any':
+                        return (
+                            Array.isArray(documentValue) &&
+                            Array.isArray(expectedValue) &&
+                            documentValue.some(v => expectedValue.includes(v))
+                        );
+                    case 'in':
+                        return Array.isArray(expectedValue) && expectedValue.includes(documentValue);
+                    case 'not-in':
+                        return Array.isArray(expectedValue) && !expectedValue.includes(documentValue);
+                    default:
+                        throw new Error(`Operator ${operator} not handled!`);
+                }
+            })
+        );
     }
 
     private isCreateOperation(operation: FirestoreClient.Operation): boolean {
@@ -275,7 +304,6 @@ export class FirestoreClient implements ITransactionalClient {
 }
 
 export namespace FirestoreClient {
-
     export interface Operation {
         document: Document;
         action: Action;

package/src/interfaces/app-config.ts

@@ -1 +0,0 @@
-

package/src/interfaces/newable.ts

@@ -1 +1 @@
-export type Newable<T> = new () => T;
+export type Newable<T> = new () => T;

package/src/interfaces/type.ts

@@ -1,3 +1,3 @@
-export interface Type<T = any> extends Function {
-    new(...args: any[]): T;
+export interface Type<T = any> {
+    new (...args: any[]): T;
 }

package/src/reflect.ts

@@ -7,16 +7,16 @@ import { Type } from './interfaces';
 import { RequestMethod } from './request-method.enum';
 import { Server } from './server';
 
-/* eslint-disable @typescript-eslint/ban-types */
 class ReflectHelper<T extends ReflectTarget<any>> {
     private readonly HANDLER_META_DATA = '__handler__';
     private readonly CONTROLLER_META_DATA = '__controller__';
     private readonly INJECTABLE_META_DATA = '__injectable__';
     private readonly TRANSACTIONAL_CLIENT_META_DATA = '__transactional_client__';
 
-    constructor(private target: T, private methodName: string | symbol) {
-
-    }
+    constructor(
+        private target: T,
+        private methodName: string | symbol
+    ) {}
 
     public getParameters(): Type[] {
         return Reflect.getMetadata('design:paramtypes', this.target, this.methodName) || [];
@@ -27,7 +27,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
     }
 
     public getInjectableId(): string {
-        return this.getMetaData<string>(this.INJECTABLE_META_DATA)
+        return this.getMetaData<string>(this.INJECTABLE_META_DATA);
     }
 
     public registerTransactionalClient(): void {
@@ -35,7 +35,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
     }
 
     public isTransactionalClient(): boolean {
-        return this.hasMetaData(this.TRANSACTIONAL_CLIENT_META_DATA)
+        return this.hasMetaData(this.TRANSACTIONAL_CLIENT_META_DATA);
     }
 
     public getControllerConfiguration(): ControllerConfiguration {
@@ -53,7 +53,7 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         this.getControllerConfiguration().basePath = basePath;
     }
 
-    public registerControllerRoute(route: { path: string, requestMethod: RequestMethod }): void {
+    public registerControllerRoute(route: { path: string; requestMethod: RequestMethod }): void {
         this.getControllerRoute().path = route.path;
         this.getControllerRoute().requestMethod = route.requestMethod;
     }

package/src/sanity-check/controller.ts

@@ -3,7 +3,6 @@ import { Controller, Get, Post } from '../decorators';
 
 @Controller('sanity-check')
 export class SanityCheckController {
-
     @Post('warm-up')
     public async postWarmUp(): Promise<string> {
         return 'Warm Up succeeded! :-)';

package/src/sanity-check/module.ts

@@ -3,10 +3,6 @@ import { Module } from '../decorators';
 import { SanityCheckController } from './controller';
 
 @Module({
-    controllers: [
-        SanityCheckController,
-    ],
+    controllers: [SanityCheckController]
 })
-export class SanityCheckModule {
-
-}
+export class SanityCheckModule {}

package/src/server/middlewares/authentication-middleware.ts

@@ -4,7 +4,6 @@ import { Auth } from 'firebase-admin/auth';
 import { Context } from '../../context';
 import { Server } from '../server';
 
-
 export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Server.RequestHandler {
     return async (request: Server.Request, _response: Server.Response, next: Server.NextFunction): Promise<void> => {
         const authorizationHeader = request.headers.authorization ? request.headers.authorization.toString() : null;

package/src/server/server.ts

@@ -56,7 +56,6 @@ export class Server {
 }
 
 export namespace Server {
-
     export interface Options {
         bus: Bus;
         firebaseAuth: auth.Auth;

package/src/zip-helper.ts

@@ -1,4 +1,4 @@
-import * as zlib from 'zlib';
+import * as zlib from 'node:zlib';
 
 export class ZipHelper {
     public static zip(content: string): string {

package/tsconfig.json

@@ -11,8 +11,5 @@
         "emitDecoratorMetadata": true,
         "experimentalDecorators": true
     },
-    "types": [
-        "reflect-metadata",
-        "mocha"
-    ],
+    "types": ["reflect-metadata", "mocha"]
 }