snap-on-openapi 1.0.1 → 1.0.3

package/dist/services/ConfigBuilder/types/DefaultConfig.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, test } from 'vitest';
+import z from 'zod';
+import { OpenApi } from '../../../OpenApi';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { Method } from '../../../enums/Methods';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { TestUtils } from '../../TestUtils/TestUtils';
+describe('DefaultConfig', () => {
+    describe('Error handler', () => {
+        test('Default Config checks', async () => {
+            const defaultApi = OpenApi.builder.create();
+            expect(defaultApi.getConfig().skipDescriptionsCheck, 'By default we check validator descriptions').toBe(false);
+        });
+        test('Returns not found error on unkown route', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const req = TestUtils.createRequest('/api/route');
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should throw error since no route is present').toEqual({
+                error: ErrorCode.NotFound,
+            });
+            expect(res.status, 'Should status 404 for not found error').toEqual(404);
+        });
+        test('Returns unknown error on random error', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const route = defaultApi.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/route',
+                description: 'Test route',
+                validators: {
+                    response: z.string().openapi({ description: 'Test response' }),
+                },
+                handler: async () => {
+                    throw new Error('dasdsaa');
+                },
+            });
+            defaultApi.addRoute(route);
+            const req = TestUtils.createRequest('/api/route');
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should return unknown error if error happens').toEqual({
+                error: ErrorCode.UnknownError,
+            });
+            expect(res.status, 'Should status 500 for unknown error').toEqual(500);
+        });
+        test('Returns validation error on invalid params', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const route = defaultApi.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.POST,
+                path: '/route',
+                description: 'Test route',
+                validators: {
+                    body: z.object({
+                        name: z.string().openapi({ description: 'Name' }),
+                    }),
+                    response: z.string().openapi({ description: 'Test response' }),
+                },
+                handler: async () => Promise.resolve('success'),
+            });
+            defaultApi.addRoute(route);
+            const happyReq = TestUtils.createRequest('/api/route', Method.POST, { name: 'king' });
+            const happyRes = await defaultApi.processRootRoute(happyReq);
+            expect(happyRes.body, 'Should return normal response if body is valid').toBe('success');
+            expect(happyRes.status, 'Should return status 200 on normal response').toBe(200);
+            const req = TestUtils.createRequest('/api/route', Method.POST);
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should return unknown error if error happens').toEqual({
+                error: {
+                    code: ErrorCode.ValidationFailed,
+                    fieldErrors: [
+                        {
+                            field: 'name',
+                            message: 'Required',
+                        },
+                    ],
+                    location: 'Body',
+                },
+            });
+            expect(res.status, 'Should return status 400 on validation error').toEqual(400);
+        });
+    });
+});

package/dist/services/ConfigBuilder/types/DefaultErrorMap.d.ts

@@ -1,5 +1,5 @@
-import { ErrorCode } from '../../../enums/ErrorCode.js';
-import { ErrorConfigMap } from '../../../types/config/ErrorConfigMap.js';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { ErrorConfigMap } from '../../../types/config/ErrorConfigMap';
 export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
     [ErrorCode.UnknownError]: {
         readonly status: "500";
@@ -47,7 +47,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }>, "many">;
-                location: import("zod").ZodNativeEnum<typeof import("../../../index.js").OpenApiValidationLocation>;
+                location: import("zod").ZodNativeEnum<typeof import("../../..").OpenApiValidationLocation>;
             }, "strip", import("zod").ZodTypeAny, {
                 code: ErrorCode.ValidationFailed;
                 fieldErrors: {
@@ -58,7 +58,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             }, {
                 code: ErrorCode.ValidationFailed;
                 fieldErrors: {
@@ -69,7 +69,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             }>;
         }, "strip", import("zod").ZodTypeAny, {
             error: {
@@ -82,7 +82,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             };
         }, {
             error: {
@@ -95,7 +95,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             };
         }>;
     };

package/dist/services/ConfigBuilder/types/DefaultErrorMap.js

@@ -1,7 +1,7 @@
-import { ErrorCode } from '../../../enums/ErrorCode.js';
-import { unknownErrorResponseValidator } from '../../../types/errors/responses/UnknownErrorResponse.js';
-import { validationErrorResponseValidator } from '../../../types/errors/responses/ValidationErrorResponse.js';
-import { notFoundErrorResponseValidator } from '../../../types/errors/responses/NotFoundErrorResponse.js';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { unknownErrorResponseValidator } from '../../../types/errors/responses/UnknownErrorResponse';
+import { validationErrorResponseValidator } from '../../../types/errors/responses/ValidationErrorResponse';
+import { notFoundErrorResponseValidator } from '../../../types/errors/responses/NotFoundErrorResponse';
 export class DefaultErrorMap {
     [ErrorCode.UnknownError] = {
         status: '500',

package/dist/services/ConfigBuilder/types/DefaultRouteContextMap.d.ts

@@ -1,6 +1,6 @@
-import { SampleRouteType } from '../../../enums/SampleRouteType.js';
-import { RouteContextMap } from '../../../types/config/RouteContextMap.js';
-import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { RouteContextMap } from '../../../types/config/RouteContextMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export declare class DefaultRouteContextMap implements RouteContextMap<SampleRouteType, DefaultRouteParamsMap> {
     Public: () => Promise<{}>;
 }

package/dist/services/ConfigBuilder/types/DefaultRouteMap.d.ts

@@ -1,8 +1,8 @@
-import { SampleRouteType } from '../../../enums/SampleRouteType.js';
-import { RouteConfigMap } from '../../../types/config/RouteConfigMap.js';
-import { ErrorCode } from '../../../enums/ErrorCode.js';
-import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
-import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { RouteConfigMap } from '../../../types/config/RouteConfigMap';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export declare class DefaultRouteMap implements RouteConfigMap<SampleRouteType, ErrorCode, DefaultRouteParamsMap, DefaultRouteContextMap> {
     Public: {
         readonly authorization: false;

package/dist/services/ConfigBuilder/types/DefaultRouteMap.js

@@ -1,5 +1,5 @@
-import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
-import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export class DefaultRouteMap {
     Public = {
         authorization: false,

package/dist/services/ConfigBuilder/types/DefaultRouteParamsMap.d.ts

@@ -1,5 +1,5 @@
-import { SampleRouteType } from '../../../enums/SampleRouteType.js';
-import { RouteExtraPropsMap } from '../../../types/config/RouteExtraPropsMap.js';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { RouteExtraPropsMap } from '../../../types/config/RouteExtraPropsMap';
 export declare class DefaultRouteParamsMap implements RouteExtraPropsMap<SampleRouteType> {
     Public: undefined;
 }

package/dist/services/ConfigBuilder/types/OpenApiConstructor.d.ts

@@ -1,2 +1,2 @@
-import { OpenApi } from '../../../OpenApi.js';
+import { OpenApi } from '../../../OpenApi';
 export type OpenApiConstructor = (conf: any) => OpenApi<any, any, any>;

package/dist/services/DescriptionChecker/DescriptionChecker.d.ts

@@ -1,6 +1,6 @@
 import { ZodTypeAny, ZodRawShape } from 'zod';
-import { AnyRoute } from '../../types/AnyRoute.js';
-import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+import { AnyRoute } from '../../types/AnyRoute';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils';
 interface DescriptionCheckerConfig {
     checkValidators: boolean;
 }

package/dist/services/DescriptionChecker/DescriptionChecker.js

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils';
 export class DescriptionChecker {
     utils = new ValidationUtils();
     config;

package/dist/services/DescriptionChecker/DescriptionChecker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/DescriptionChecker/DescriptionChecker.test.js

@@ -0,0 +1,120 @@
+import { describe } from 'node:test';
+import { expect, test } from 'vitest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { Method } from '../../enums/Methods';
+import z from 'zod';
+describe('DescriptionChecker', () => {
+    test('Checks route descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/something',
+            description: '',
+            validators: {
+                response: z.string().openapi({ description: 'Testing' }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error('Description for /something is missing or too small'));
+        route.description = 'Testing route description';
+        expect(() => {
+            api.addRoute(route);
+        }).not.toThrowError();
+    });
+    test('Checks response validator descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string(),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'GET:/something': responseValidator missing openapi description on field 'responseValidator'"));
+        route.validators.response = route.validators.response.openapi({ description: 'Something useful' });
+        expect(() => {
+            api.addRoute(route);
+        }).not.toThrowError();
+    });
+    test('Checks body validator descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string().openapi({ description: 'Test description' }),
+                body: z.object({
+                    name: z.string(),
+                }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'POST:/something': bodyValidator missing openapi description on field 'name'"));
+        const route2 = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string().openapi({ description: 'Test description' }),
+                body: z.object({
+                    name: z.string().openapi({ description: 'Name' }),
+                }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route2);
+        }).not.toThrowError();
+    });
+    test('Checks validator descriptions in array items', async () => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.object({
+                    items: z.array(z.object({
+                        name: z.string(),
+                    })).openapi({ description: 'Items of array' }),
+                }).openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve({ items: [{ name: 'Something' }] }),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'POST:/something': responseValidator missing openapi description on field 'name'"));
+        const route2 = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.object({
+                    items: z.array(z.object({
+                        name: z.string().openapi({ description: 'Name of item' }),
+                    })).openapi({ description: 'Items of array' }),
+                }).openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve({ items: [{ name: 'Something' }] }),
+        });
+        expect(() => {
+            api.addRoute(route2);
+        }).not.toThrowError();
+    });
+});

package/dist/services/DevelopmentUtils/DevelopmentUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/DevelopmentUtils/DevelopmentUtils.test.js

@@ -0,0 +1,10 @@
+import { expect, test } from 'vitest';
+import { DevelopmentUtils } from './DevelopmentUtils';
+import { describe } from 'node:test';
+describe('Development Utils', () => {
+    test('Swagger HTML returned correctly', () => {
+        const utils = new DevelopmentUtils();
+        const html = utils.getSwaggerHTML('/test');
+        expect(html).toContain('SwaggerUIBundle');
+    });
+});

package/dist/services/ExpressWrapper/ExpressWrapper.d.ts

@@ -1,8 +1,8 @@
-import { ExpressApp } from './types/ExpressApp.js';
-import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
-import { OpenApi } from '../../OpenApi.js';
-import { AnyConfig } from '../../types/config/AnyConfig.js';
-import { RoutePath } from '../../types/RoutePath.js';
+import { ExpressApp } from './types/ExpressApp';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils';
+import { OpenApi } from '../../OpenApi';
+import { AnyConfig } from '../../types/config/AnyConfig';
+import { RoutePath } from '../../types/RoutePath';
 export declare class ExpressWrapper<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     protected service: OpenApi<TRouteTypes, TErrorCodes, TConfig>;
     protected developmentUtils: DevelopmentUtils;

package/dist/services/ExpressWrapper/ExpressWrapper.js

@@ -1,5 +1,5 @@
 import { format } from 'url';
-import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils';
 export class ExpressWrapper {
     service;
     developmentUtils;

package/dist/services/ExpressWrapper/ExpressWrapper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/ExpressWrapper/ExpressWrapper.test.js

@@ -0,0 +1,136 @@
+import { describe, expect, test } from 'vitest';
+import express from 'express';
+import supertest from 'supertest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { ErrorCode } from '../../enums/ErrorCode';
+import z from 'zod';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { OpenApi } from '../../OpenApi';
+describe('ExpressWrapper', () => {
+    test('Can mount the api correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createOpenApiRootRoute(app);
+        const errResponse = await supertest(app).get('/api');
+        expect(errResponse.status, 'Should be 404 on unknown route').toBe(404);
+        expect(errResponse.body, 'Should be error on unknown route').toEqual({ error: ErrorCode.NotFound });
+        const goodResponse = await supertest(app).get('/api/sample');
+        expect(goodResponse.status, 'Should be 200 on sample route').toBe(200);
+        expect(goodResponse.body, "Should be body 'success'").toEqual('success');
+    });
+    test('Can mount swagger routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createSwaggerRoute('/swagger', app);
+        const goodResponse = await supertest(app).get('/swagger');
+        expect(goodResponse.status, 'Should be 200 on swagger route').toBe(200);
+        expect(goodResponse.text, 'Swagger UI pieces should be in HTML').toContain('swagger-ui');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Can mount stoplight routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createStoplightRoute('/light', app);
+        const goodResponse = await supertest(app).get('/light');
+        expect(goodResponse.status, 'Should be 200 on stoplight route').toBe(200);
+        expect(goodResponse.text, 'Stoplight UI pieces should be in HTML').toContain('@stoplight');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Can mount schema routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createSchemaRoute('/schema', app);
+        const goodResponse = await supertest(app).get('/schema');
+        expect(goodResponse.status, 'Should be 200 on schema route').toBe(200);
+        expect(goodResponse.text, 'Response should contain pieces of openapi schema').toContain('Sample route');
+    });
+    test('Can mount stoplight routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createStoplightRoute('/light', app);
+        const goodResponse = await supertest(app).get('/light');
+        expect(goodResponse.status, 'Should be 200 on stoplight route').toBe(200);
+        expect(goodResponse.text, 'Stoplight UI pieces should be in HTML').toContain('@stoplight');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Works correctly with array header values', async () => {
+        class ExpressAppMock {
+            handler;
+            post(route, handler) {
+                this.handler = handler;
+            }
+            ;
+            get = () => { };
+            delete = () => { };
+            put = () => { };
+            patch = () => { };
+            async test(req) {
+                let body;
+                let status = 0;
+                const res = {
+                    header: function () {
+                        return this;
+                    },
+                    status: function (code) {
+                        status = code;
+                        return this;
+                    },
+                    json: function (data) {
+                        body = data;
+                        return this;
+                    },
+                    send: function () {
+                        return this;
+                    },
+                };
+                if (!this.handler) {
+                    throw new Error("Handler wasn't set");
+                }
+                await this.handler(req, res);
+                return { status, body };
+            }
+        }
+        ;
+        const appMock = new ExpressAppMock();
+        const api = OpenApi.builder
+            .customizeRoutes(SampleRouteType)
+            .defineRouteContexts({
+            [SampleRouteType.Public]: (ctx) => Promise.resolve({
+                authorization: ctx.request.headers.get('Authorization'),
+            }),
+        })
+            .defineRoutes({
+            [SampleRouteType.Public]: {
+                authorization: true,
+            },
+        })
+            .create();
+        api.wrappers.express.createOpenApiRootRoute(appMock);
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/test-multi-headers',
+            description: 'Multiheader test route',
+            validators: {
+                response: z.unknown().nullable().openapi({ description: 'Authorization header' }),
+            },
+            handler: (ctx) => Promise.resolve(ctx.authorization),
+        });
+        api.addRoute(route);
+        const req = {
+            headers: {
+                Authorization: ['Bearer1', 'Bearer2'],
+                ContentType: undefined,
+            },
+            body: '',
+            method: 'POST',
+            protocol: '',
+            originalUrl: '/api/test-multi-headers',
+            host: 'http://localhost',
+        };
+        const goodResponse = await appMock.test(req);
+        expect(goodResponse.status, 'Should be 200 on sample route').toBe(200);
+        expect(goodResponse.body, 'Route should return both headers').toBe('Bearer1,Bearer2');
+    });
+});

package/dist/services/ExpressWrapper/types/ExpressApp.d.ts

@@ -1,4 +1,4 @@
-import { ExpressHandler } from './ExpressHandler.js';
+import { ExpressHandler } from './ExpressHandler';
 export interface ExpressApp {
     get: (route: string | RegExp, handler: ExpressHandler) => void;
     post: (route: string | RegExp, handler: ExpressHandler) => void;

package/dist/services/ExpressWrapper/types/ExpressHandler.d.ts

@@ -1,3 +1,3 @@
-import { ExpressRequest } from './ExpressRequest.js';
-import { ExpressResponse } from './ExpressResponse.js';
+import { ExpressRequest } from './ExpressRequest';
+import { ExpressResponse } from './ExpressResponse';
 export type ExpressHandler = (req: ExpressRequest, res: ExpressResponse) => void | Promise<void>;

package/dist/services/Logger/Logger.d.ts

@@ -1,9 +1,10 @@
-import { LogLevel } from './types/LogLevel.js';
+import { LogLevel } from './types/LogLevel';
 export declare class Logger {
     protected invoker: string;
     static logLevel: LogLevel;
     static showTime: boolean;
     constructor(invoker: string, originalInvoker?: string);
+    derrive(invoker: string): Logger;
     info(message: string, data?: Record<string, unknown>): void;
     debug(message: string, data?: object): void;
     error(message: string | null, error: unknown, data?: object): void;

package/dist/services/Logger/Logger.js

@@ -1,4 +1,4 @@
-import { LogLevel } from './types/LogLevel.js';
+import { LogLevel } from './types/LogLevel';
 export class Logger {
     invoker;
     static logLevel = LogLevel.all;
@@ -6,6 +6,9 @@ export class Logger {
     constructor(invoker, originalInvoker) {
         this.invoker = (originalInvoker ? `${originalInvoker}:` : '') + invoker;
     }
+    derrive(invoker) {
+        return new Logger(invoker, this.invoker);
+    }
     info(message, data) {
         if (Logger.logLevel === LogLevel.error) {
             return;

package/dist/services/Logger/Logger.test.d.ts

@@ -0,0 +1 @@
+export {};