@my-devkit/firebase 1.0.193 → 1.0.194

package/src/firestore-client.ts

@@ -1,10 +1,17 @@
-import { _orderBy, Cacheable, deserialize, Document, Logger, NotFoundError, serialize } from '@my-devkit/core';
+import {
+    _orderBy,
+    Cacheable,
+    deserialize,
+    Document,
+    Logger,
+    NotFoundError,
+    serialize
+} from '@my-devkit/core';
 import { getFirestore } from 'firebase-admin/firestore';
 
 import { Injectable, TransactionalClient } from './decorators';
 import { ITransactionalClient } from './interfaces';
 
-
 @TransactionalClient()
 @Injectable()
 export class FirestoreClient implements ITransactionalClient {
@@ -45,11 +52,17 @@ 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) {
-            throw new Error(`Transactional Repository: Too many documents found (${documents.length})`);
+            throw new Error(
+                `Transactional Repository: Too many documents found (${documents.length})`
+            );
         }
 
         return documents[0] || null;
@@ -65,12 +78,21 @@ export class FirestoreClient implements ITransactionalClient {
         return result;
     }
 
-    public async _getAll<T extends Document>(collection: string, options?: FirestoreClient.QueryOptions): Promise<T[]> {
+    public async _getAll<T extends Document>(
+        collection: string,
+        options?: FirestoreClient.QueryOptions
+    ): Promise<T[]> {
         return this._getWhere(collection, [], options);
     }
 
-    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)}`);
+    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);
 
         for (const operation of Array.from(this.operations.values())) {
@@ -80,26 +102,36 @@ export class FirestoreClient implements ITransactionalClient {
                 case FirestoreClient.Action.Create:
                     if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
                         documentMap.set(operation.document._path, <T>operation.document);
-                        Logger.info(`Repository: Document ${operation.document._path} added to result`);
+                        Logger.info(
+                            `Repository: Document ${operation.document._path} added to result`
+                        );
                     }
                     break;
                 case FirestoreClient.Action.Update:
                     if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
-                        Logger.info(`Repository: Document ${operation.document._path} ${exists ? 'updated from' : 'added to'} result`);
+                        Logger.info(
+                            `Repository: Document ${operation.document._path} ${exists ? 'updated from' : 'added to'} result`
+                        );
                         documentMap.set(operation.document._path, <T>operation.document);
                     } else if (exists) {
                         documentMap.delete(operation.document._path);
-                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
+                        Logger.info(
+                            `Repository: Document ${operation.document._path} removed from result`
+                        );
                     }
                     break;
                 case FirestoreClient.Action.Delete:
                     if (exists) {
                         documentMap.delete(operation.document._path);
-                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
+                        Logger.info(
+                            `Repository: Document ${operation.document._path} removed from result`
+                        );
                     }
                     break;
                 default:
-                    throw new Error(`FirestoreClient: Unhandled existing operation ${operation.action} on ${operation.document._path}`);
+                    throw new Error(
+                        `FirestoreClient: Unhandled existing operation ${operation.action} on ${operation.document._path}`
+                    );
             }
         }
 
@@ -118,25 +150,34 @@ export class FirestoreClient implements ITransactionalClient {
         return documents;
     }
 
-
     public createDocument<T extends Document>(document: T): void {
         const existingOperation = this.operations.get(document._path);
 
         if (existingOperation) {
             switch (existingOperation.action) {
                 case FirestoreClient.Action.Create:
-                    throw new Error(`FirestoreClient: can't create twice document ${document._path}`);
+                    throw new Error(
+                        `FirestoreClient: can't create twice document ${document._path}`
+                    );
                 case FirestoreClient.Action.Update:
-                    throw new Error(`FirestoreClient: can't create already existing document ${document._path}`);
+                    throw new Error(
+                        `FirestoreClient: can't create already existing document ${document._path}`
+                    );
                 case FirestoreClient.Action.Delete:
                     existingOperation.action = FirestoreClient.Action.Update;
                     existingOperation.document = document;
                     break;
                 default:
-                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+                    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
+            });
         }
     }
 
@@ -150,12 +191,20 @@ export class FirestoreClient implements ITransactionalClient {
                     existingOperation.document = document;
                     break;
                 case FirestoreClient.Action.Delete:
-                    throw new Error(`FirestoreClient: can't update deleted document ${document._path}`);
+                    throw new Error(
+                        `FirestoreClient: can't update deleted document ${document._path}`
+                    );
                 default:
-                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+                    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
+            });
         }
     }
 
@@ -172,16 +221,26 @@ export class FirestoreClient implements ITransactionalClient {
                     existingOperation.action = FirestoreClient.Action.Delete;
                     break;
                 case FirestoreClient.Action.Delete:
-                    throw new Error(`FirestoreClient: can't delete already deleted document ${document._path}`);
+                    throw new Error(
+                        `FirestoreClient: can't delete already deleted document ${document._path}`
+                    );
                 default:
-                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+                    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
+            });
         }
     }
 
-    private getCollectionReference(collection: string): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
+    private getCollectionReference(
+        collection: string
+    ): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
         if (collection.startsWith('**/')) {
             return this.db.collectionGroup(collection.replace('**/', ''));
         } else {
@@ -226,39 +285,56 @@ 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 +351,6 @@ export class FirestoreClient implements ITransactionalClient {
 }
 
 export namespace FirestoreClient {
-
     export interface Operation {
         document: Document;
         action: Action;

package/src/handler-helper.ts

@@ -6,7 +6,10 @@ import { ExecutionMode } from './execution-mode-enum';
 import { FirestoreClient } from './firestore-client';
 
 export class HandlerHelper {
-    public static async create<A extends Aggregate, R>(aggregate: A, callback: (a: A) => Promise<R>): Promise<R> {
+    public static async create<A extends Aggregate, R>(
+        aggregate: A,
+        callback: (a: A) => Promise<R>
+    ): Promise<R> {
         const result = await callback(aggregate);
 
         this.client.createDocument(aggregate);
@@ -15,10 +18,15 @@ export class HandlerHelper {
         return result;
     }
 
-    public static async update<A extends Aggregate, R>(aggregateOrId: A | string, callback: (a: A) => Promise<R>): Promise<R> {
+    public static async update<A extends Aggregate, R>(
+        aggregateOrId: A | string,
+        callback: (a: A) => Promise<R>
+    ): Promise<R> {
         const aggregate = await this.getAggregate(aggregateOrId);
         if (aggregate.events.length > 0) {
-            Logger.warn(`${aggregate._type} ${aggregate.id} has ${aggregate.events.length} events!!`);
+            Logger.warn(
+                `${aggregate._type} ${aggregate.id} has ${aggregate.events.length} events!!`
+            );
         }
         const hashBefore = aggregate.hash;
 
@@ -28,14 +36,19 @@ export class HandlerHelper {
             this.client.updateDocument(aggregate);
             await this.publishEvents(aggregate);
         } else {
-            Logger.debug(`${aggregate._type} ${aggregate.id} didn't change, ${aggregate.events.length} events skipped`);
+            Logger.debug(
+                `${aggregate._type} ${aggregate.id} didn't change, ${aggregate.events.length} events skipped`
+            );
             aggregate.clearEvents();
         }
 
         return result;
     }
 
-    public static async delete<A extends Aggregate, R>(aggregateOrId: A | string, callback: (a: A) => Promise<R>): Promise<R> {
+    public static async delete<A extends Aggregate, R>(
+        aggregateOrId: A | string,
+        callback: (a: A) => Promise<R>
+    ): Promise<R> {
         const aggregate = await this.getAggregate(aggregateOrId);
 
         const result = await callback(aggregate);

package/src/interfaces/app-config.ts

@@ -1 +0,0 @@
-

package/src/interfaces/from-array.ts

@@ -1 +1,2 @@
-export type FromArray<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer FromArray> ? FromArray : never;
+export type FromArray<T extends ReadonlyArray<unknown>> =
+    T extends ReadonlyArray<infer FromArray> ? FromArray : never;

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,12 +53,15 @@ 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;
     }
 
-    public registerControllerRouteArgumentInjector<T>(injector: RequestArgumentInjector<T>, index: number): void {
+    public registerControllerRouteArgumentInjector<T>(
+        injector: RequestArgumentInjector<T>,
+        index: number
+    ): void {
         this.getControllerRoute().argumentInjectors[index] = injector;
     }
 
@@ -80,7 +83,10 @@ class ReflectHelper<T extends ReflectTarget<any>> {
         });
     }
 
-    public registerEventHandler<E extends Event>(event: new () => E, executionMode: ExecutionMode): void {
+    public registerEventHandler<E extends Event>(
+        event: new () => E,
+        executionMode: ExecutionMode
+    ): void {
         this.getHandlerConfiguration().eventHandlers.set(this.methodName.toString(), {
             methodName: this.methodName.toString(),
             executionMode,
@@ -157,7 +163,10 @@ export interface HandlerConfiguration {
 
 export type RequestArgumentInjector<T = any> = (req: Server.Request) => T;
 
-export function reflect<T extends ReflectTarget<any>>(target: T, methodName?: string | symbol): ReflectHelper<T> {
+export function reflect<T extends ReflectTarget<any>>(
+    target: T,
+    methodName?: string | symbol
+): ReflectHelper<T> {
     return new ReflectHelper(target, methodName);
 }
 

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,10 +4,15 @@ 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;
+    return async (
+        request: Server.Request,
+        _response: Server.Response,
+        next: Server.NextFunction
+    ): Promise<void> => {
+        const authorizationHeader = request.headers.authorization
+            ? request.headers.authorization.toString()
+            : null;
         Logger.info(`${request.method} ${request.path}: Authentication check`);
 
         if (publicPaths.includes(request.path)) {
@@ -26,7 +31,9 @@ export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Ser
                 Context.user = await auth.getUser(userId);
                 next();
             } catch (error) {
-                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
+                throw new UnauthorizedError(
+                    `Error while verifying token ${error.message ? error.message : null}`
+                );
             }
         } else if (authorizationHeader.startsWith('Basic')) {
             const idToken = authorizationHeader.split('Basic ')[1];
@@ -38,7 +45,9 @@ export function AuthenticationMiddleware(auth: Auth, publicPaths: string[]): Ser
                 Context.user = await auth.getUser(userId);
                 next();
             } catch (error) {
-                throw new UnauthorizedError(`Error while verifying token ${error.message ? error.message : null}`);
+                throw new UnauthorizedError(
+                    `Error while verifying token ${error.message ? error.message : null}`
+                );
             }
         } else {
             throw new UnauthorizedError('Incorrect authorization header');

package/src/server/middlewares/create-context-middleware.ts

@@ -5,7 +5,11 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function CreateContextMiddleware(bus: Bus): Server.RequestHandler {
-    return async (request: Server.Request, _response: Server.Response, next: Server.NextFunction): Promise<void> => {
+    return async (
+        request: Server.Request,
+        _response: Server.Response,
+        next: Server.NextFunction
+    ): Promise<void> => {
         Context.create(bus);
         Context.correlationId = request.header('X-Correlation-ID') || guid();
 

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

@@ -4,7 +4,11 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function ErrorMiddleWare(): Server.ErrorHandler {
-    return async (error: any, _request: Server.Request, response: Server.Response): Promise<void> => {
+    return async (
+        error: any,
+        _request: Server.Request,
+        response: Server.Response
+    ): Promise<void> => {
         if (!(error instanceof Error)) {
             error = new Error(error);
         }

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

@@ -2,7 +2,11 @@ import { Context } from '../../context';
 import { Server } from '../server';
 
 export function HeadersMiddleWare(): Server.RequestHandler {
-    return async (_request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
+    return async (
+        _request: Server.Request,
+        response: Server.Response,
+        next: Server.NextFunction
+    ): Promise<void> => {
         response.removeHeader('X-Powered-By'); // Remove verbose express
         response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate'); // HTTP 1.1.
         response.setHeader('Pragma', 'no-cache'); // HTTP 1.0.

package/src/server/server.ts

@@ -8,7 +8,11 @@ import { RequestMethod } from '../request-method.enum';
 import * as middlewares from './middlewares';
 
 function encapsulate(handler: Server.RequestHandler): Server.RequestHandler {
-    return async (request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
+    return async (
+        request: Server.Request,
+        response: Server.Response,
+        next: Server.NextFunction
+    ): Promise<void> => {
         try {
             await handler(request, response, next);
         } catch (error) {
@@ -26,7 +30,9 @@ export class Server {
         this.registerRequestHandler(cors({ origin: true }));
         this.registerRequestHandler(middlewares.CreateContextMiddleware(options.bus));
         this.registerRequestHandler(middlewares.HeadersMiddleWare());
-        this.registerRequestHandler(middlewares.AuthenticationMiddleware(options.firebaseAuth, options.publicPaths));
+        this.registerRequestHandler(
+            middlewares.AuthenticationMiddleware(options.firebaseAuth, options.publicPaths)
+        );
     }
 
     public registerRequestHandler(handler: Server.RequestHandler): void {
@@ -34,13 +40,20 @@ export class Server {
     }
 
     public registerErrorHandler(handler: Server.ErrorHandler): void {
-        this._app.use(async (error: any, request: Server.Request, response: Server.Response, next: Server.NextFunction): Promise<void> => {
-            try {
-                await handler(error, request, response, next);
-            } catch (error) {
-                next(error);
+        this._app.use(
+            async (
+                error: any,
+                request: Server.Request,
+                response: Server.Response,
+                next: Server.NextFunction
+            ): Promise<void> => {
+                try {
+                    await handler(error, request, response, next);
+                } catch (error) {
+                    next(error);
+                }
             }
-        });
+        );
     }
 
     public registerRouter(path: string, router: express.Router): void {
@@ -56,7 +69,6 @@ export class Server {
 }
 
 export namespace Server {
-
     export interface Options {
         bus: Bus;
         firebaseAuth: auth.Auth;
@@ -91,6 +103,15 @@ export namespace Server {
     export type Request = express.Request;
     export type Response = express.Response;
     export type NextFunction = express.NextFunction;
-    export type RequestHandler = (request: Request, response: Response, next: NextFunction) => Promise<void> | void;
-    export type ErrorHandler = (error: any, request: Request, response: Response, next: NextFunction) => Promise<void> | void;
+    export type RequestHandler = (
+        request: Request,
+        response: Response,
+        next: NextFunction
+    ) => Promise<void> | void;
+    export type ErrorHandler = (
+        error: any,
+        request: Request,
+        response: Response,
+        next: NextFunction
+    ) => Promise<void> | void;
 }

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"]
 }