@forklaunch/core 0.2.3 → 0.2.6

package/lib/dist/lib/src/http/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./enrichExpressLikeSend";
+export * from "./httpStatusCodes";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/lib/src/http/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../dist/lib/src/http/utils/index.js"],"names":[],"mappings":""}

package/lib/dist/lib/src/http/utils/index.js

@@ -0,0 +1,2 @@
+export * from './enrichExpressLikeSend';
+export * from './httpStatusCodes';

package/lib/dist/lib/src/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./interfaces/baseService";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/lib/src/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../dist/lib/src/services/index.js"],"names":[],"mappings":""}

package/lib/dist/lib/src/services/interfaces/baseService.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=baseService.d.ts.map

package/lib/dist/lib/src/services/interfaces/baseService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseService.d.ts","sourceRoot":"","sources":["../../../../../../dist/lib/src/services/interfaces/baseService.js"],"names":[],"mappings":""}

package/lib/dist/lib/src/services/interfaces/baseService.js

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

package/lib/dist/lib/tests/dtoMapper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dtoMapper.test.d.ts.map

package/lib/dist/lib/tests/dtoMapper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dtoMapper.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/dtoMapper.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/dtoMapper.test.js

@@ -0,0 +1,172 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { SchemaValidator, number, string } from '@forklaunch/validator/typebox';
+import { Property } from '@mikro-orm/core';
+import { BaseEntity } from '../src/database/mikro/models/entities/base.entity';
+import { RequestDtoMapper } from '../src/dtoMapper/models/requestDtoMapper.model';
+import { ResponseDtoMapper } from '../src/dtoMapper/models/responseDtoMapper.model';
+const SV = SchemaValidator();
+class TestEntity extends BaseEntity {
+    name;
+    age;
+}
+__decorate([
+    Property()
+], TestEntity.prototype, "name", void 0);
+__decorate([
+    Property()
+], TestEntity.prototype, "age", void 0);
+class TestRequestDtoMapper extends RequestDtoMapper {
+    schema = {
+        id: string,
+        name: string,
+        age: number
+    };
+    toEntity(...additionalArgs) {
+        const entity = new TestEntity();
+        entity.id = this.dto.id;
+        entity.name = this.dto.name;
+        entity.age = this.dto.age;
+        return entity;
+    }
+}
+class TestResponseDtoMapper extends ResponseDtoMapper {
+    schema = {
+        id: string,
+        name: string,
+        age: number
+    };
+    fromEntity(entity) {
+        this.dto = {
+            id: entity.id,
+            name: entity.name,
+            age: entity.age
+        };
+        return this;
+    }
+}
+function extractNonTimeBasedEntityFields(entity) {
+    entity.createdAt = new Date(0);
+    entity.updatedAt = new Date(0);
+    return entity;
+}
+describe('request dtoMapper tests', () => {
+    let TestRequestEM;
+    beforeAll(() => {
+        TestRequestEM = new TestRequestDtoMapper(SchemaValidator());
+    });
+    test('schema static and constructed equality', async () => {
+        expect(TestRequestEM.schema).toEqual(TestRequestDtoMapper.schema());
+    });
+    test('from JSON', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const responseEM = TestRequestEM.fromJson(json);
+        const staticEM = TestRequestDtoMapper.fromJson(SchemaValidator(), json);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(staticEM.dto);
+    });
+    test('deserialize', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const entity = extractNonTimeBasedEntityFields(TestRequestEM.deserializeJsonToEntity(json));
+        const objectEntity = extractNonTimeBasedEntityFields(TestRequestEM.fromJson(json).toEntity());
+        const staticEntity = extractNonTimeBasedEntityFields(TestRequestDtoMapper.deserializeJsonToEntity(SchemaValidator(), json));
+        let expectedEntity = new TestEntity();
+        expectedEntity.id = '123';
+        expectedEntity.name = 'test';
+        expectedEntity.age = 1;
+        expectedEntity = extractNonTimeBasedEntityFields(expectedEntity);
+        expect(entity).toEqual(expectedEntity);
+        expect(objectEntity).toEqual(expectedEntity);
+        expect(staticEntity).toEqual(expectedEntity);
+        expect(entity).toEqual(objectEntity);
+        expect(entity).toEqual(staticEntity);
+        expect(staticEntity).toEqual(expectedEntity);
+        expect(staticEntity).toEqual(objectEntity);
+    });
+    test('serialize failure', async () => {
+        const json = {
+            id: '123',
+            name: 'test'
+        };
+        // @ts-expect-error
+        expect(() => TestRequestEM.fromJson(json)).toThrow();
+        expect(() => 
+        // @ts-expect-error
+        TestRequestDtoMapper.fromJson(new TypeboxSchemaValidator(), json)).toThrow();
+    });
+});
+describe('response dtoMapper tests', () => {
+    let TestResponseEM;
+    beforeAll(() => {
+        TestResponseEM = new TestResponseDtoMapper(SchemaValidator());
+    });
+    test('schema static and constructed equality', async () => {
+        expect(TestResponseEM.schema).toEqual(TestResponseDtoMapper.schema());
+    });
+    test('from entity', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const responseEM = TestResponseEM.fromEntity(entity);
+        const staticEM = TestResponseDtoMapper.fromEntity(SchemaValidator(), entity);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(staticEM.dto);
+    });
+    test('serialize', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const json = TestResponseEM.serializeEntityToJson(entity);
+        const objectJson = TestResponseEM.fromEntity(entity).toJson();
+        const staticJson = TestResponseDtoMapper.serializeEntityToJson(SchemaValidator(), entity);
+        const expectedJson = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(json).toEqual(expectedJson);
+        expect(objectJson).toEqual(expectedJson);
+        expect(staticJson).toEqual(expectedJson);
+        expect(json).toEqual(objectJson);
+        expect(json).toEqual(staticJson);
+        expect(staticJson).toEqual(expectedJson);
+        expect(staticJson).toEqual(objectJson);
+    });
+    test('deserialize failure', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        expect(() => TestResponseEM.fromEntity(entity).toJson()).toThrow();
+        expect(() => TestResponseDtoMapper.fromEntity(SchemaValidator(), entity).toJson()).toThrow();
+    });
+});

package/lib/dist/lib/tests/entityMapper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityMapper.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/entityMapper.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/entityMapper.test.js

@@ -0,0 +1,172 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { SchemaValidator, number, string } from '@forklaunch/validator/typebox';
+import { Property } from '@mikro-orm/core';
+import { BaseEntity } from '../src/database/mikro/models/entities/base.entity';
+import { RequestDtoMapper } from '../src/dtoMapper/models/requestDtoMapper.model';
+import { ResponseDtoMapper } from '../src/dtoMapper/models/responseDtoMapper.model';
+const SV = SchemaValidator();
+class TestEntity extends BaseEntity {
+    name;
+    age;
+}
+__decorate([
+    Property()
+], TestEntity.prototype, "name", void 0);
+__decorate([
+    Property()
+], TestEntity.prototype, "age", void 0);
+class TestRequestDtoMapper extends RequestDtoMapper {
+    schema = {
+        id: string,
+        name: string,
+        age: number
+    };
+    toEntity(...additionalArgs) {
+        const entity = new TestEntity();
+        entity.id = this.dto.id;
+        entity.name = this.dto.name;
+        entity.age = this.dto.age;
+        return entity;
+    }
+}
+class TestResponseDtoMapper extends ResponseDtoMapper {
+    schema = {
+        id: string,
+        name: string,
+        age: number
+    };
+    fromEntity(entity) {
+        this.dto = {
+            id: entity.id,
+            name: entity.name,
+            age: entity.age
+        };
+        return this;
+    }
+}
+function extractNonTimeBasedEntityFields(entity) {
+    entity.createdAt = new Date(0);
+    entity.updatedAt = new Date(0);
+    return entity;
+}
+describe('Request Entity Mapper Test', () => {
+    let TestRequestEM;
+    beforeAll(() => {
+        TestRequestEM = new TestRequestDtoMapper(SchemaValidator());
+    });
+    test('Schema Equality', async () => {
+        expect(TestRequestEM.schema).toEqual(TestRequestDtoMapper.schema());
+    });
+    test('From JSON', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const responseEM = TestRequestEM.fromJson(json);
+        const staticEM = TestRequestDtoMapper.fromJson(SchemaValidator(), json);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(staticEM.dto);
+    });
+    test('Deserialization Equality', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const entity = extractNonTimeBasedEntityFields(TestRequestEM.deserializeJsonToEntity(json));
+        const objectEntity = extractNonTimeBasedEntityFields(TestRequestEM.fromJson(json).toEntity());
+        const staticEntity = extractNonTimeBasedEntityFields(TestRequestDtoMapper.deserializeJsonToEntity(SchemaValidator(), json));
+        let expectedEntity = new TestEntity();
+        expectedEntity.id = '123';
+        expectedEntity.name = 'test';
+        expectedEntity.age = 1;
+        expectedEntity = extractNonTimeBasedEntityFields(expectedEntity);
+        expect(entity).toEqual(expectedEntity);
+        expect(objectEntity).toEqual(expectedEntity);
+        expect(staticEntity).toEqual(expectedEntity);
+        expect(entity).toEqual(objectEntity);
+        expect(entity).toEqual(staticEntity);
+        expect(staticEntity).toEqual(expectedEntity);
+        expect(staticEntity).toEqual(objectEntity);
+    });
+    test('Serialization Failure', async () => {
+        const json = {
+            id: '123',
+            name: 'test'
+        };
+        // @ts-expect-error
+        expect(() => TestRequestEM.fromJson(json)).toThrow();
+        expect(() => 
+        // @ts-expect-error
+        TestRequestDtoMapper.fromJson(new TypeboxSchemaValidator(), json)).toThrow();
+    });
+});
+describe('Response Entity Mapper Test', () => {
+    let TestResponseEM;
+    beforeAll(() => {
+        TestResponseEM = new TestResponseDtoMapper(SchemaValidator());
+    });
+    test('Schema Equality', async () => {
+        expect(TestResponseEM.schema).toEqual(TestResponseDtoMapper.schema());
+    });
+    test('From Entity', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const responseEM = TestResponseEM.fromEntity(entity);
+        const staticEM = TestResponseDtoMapper.fromEntity(SchemaValidator(), entity);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(expectedDto);
+        expect(responseEM.dto).toEqual(staticEM.dto);
+    });
+    test('Serialization Equality', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const json = TestResponseEM.serializeEntityToJson(entity);
+        const objectJson = TestResponseEM.fromEntity(entity).toJson();
+        const staticJson = TestResponseDtoMapper.serializeEntityToJson(SchemaValidator(), entity);
+        const expectedJson = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(json).toEqual(expectedJson);
+        expect(objectJson).toEqual(expectedJson);
+        expect(staticJson).toEqual(expectedJson);
+        expect(json).toEqual(objectJson);
+        expect(json).toEqual(staticJson);
+        expect(staticJson).toEqual(expectedJson);
+        expect(staticJson).toEqual(objectJson);
+    });
+    test('Serialization Failure', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        expect(() => TestResponseEM.fromEntity(entity).toJson()).toThrow();
+        expect(() => TestResponseDtoMapper.fromEntity(SchemaValidator(), entity).toJson()).toThrow();
+    });
+});

package/lib/dist/lib/tests/expressLikeRouter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=expressLikeRouter.test.d.ts.map

package/lib/dist/lib/tests/expressLikeRouter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressLikeRouter.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/expressLikeRouter.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/expressLikeRouter.test.js

@@ -0,0 +1,3 @@
+// TODO: implement tests
+describe('express-like router tests', () => { });
+export {};

package/lib/dist/lib/tests/http.middleware.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.middleware.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/http.middleware.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/http.middleware.test.js

@@ -0,0 +1,95 @@
+import { literal, mockSchemaValidator, optional, union } from '@forklaunch/validator/tests/mockSchemaValidator';
+import { cors } from '../src/http/middleware/request/cors.middleware';
+import { createContext } from '../src/http/middleware/request/createContext.middleware';
+import { enrichDetails } from '../src/http/middleware/request/enrichDetails.middleware';
+import { parse as parseRequest } from '../src/http/middleware/request/parse.middleware';
+import { parse as parseResponse } from '../src/http/middleware/response/parse.middleware';
+describe('http middleware tests', () => {
+    let contractDetails;
+    let req;
+    let res;
+    const nextFunction = (err) => {
+        expect(err).toBeFalsy();
+    };
+    const testSchema = {
+        test: union(['a', optional(literal('test'))])
+    };
+    beforeAll(() => {
+        contractDetails = {
+            name: 'Test Contract',
+            summary: 'Test Contract Summary',
+            body: testSchema,
+            params: testSchema,
+            requestHeaders: testSchema,
+            query: testSchema,
+            responses: {
+                200: testSchema
+            }
+        };
+        req = {
+            method: 'POST',
+            context: {},
+            contractDetails: {},
+            schemaValidator: {},
+            params: testSchema,
+            headers: testSchema,
+            body: testSchema,
+            query: testSchema,
+            requestSchema: testSchema
+        };
+        res = {
+            bodyData: {},
+            statusCode: 200,
+            getHeaders: () => ({ 'x-correlation-id': '123' }),
+            setHeader: () => { },
+            status: () => ({
+                json: () => true,
+                jsonp: () => true,
+                send: () => { }
+            }),
+            end: () => { },
+            headersSent: false,
+            locals: {},
+            cors: true,
+            responseSchemas: {
+                headers: {
+                    testSchema
+                },
+                responses: {
+                    200: testSchema
+                }
+            }
+        };
+    });
+    test('cors middleware', async () => {
+        cors(req, res, nextFunction);
+        expect(res.cors).toBe(true);
+    });
+    test('create request context', async () => {
+        req.context = {};
+        req.schemaValidator = {};
+        createContext(mockSchemaValidator)(req, res, nextFunction);
+        expect(req.context.correlationId).not.toBe('123');
+        expect(req.schemaValidator).toBe(mockSchemaValidator);
+    });
+    test('request enrich details', async () => {
+        req.contractDetails = {};
+        enrichDetails(contractDetails, testSchema, {
+            headers: testSchema,
+            responses: {
+                200: testSchema
+            }
+        })(req, res, nextFunction);
+        expect(req.contractDetails).toEqual(contractDetails);
+    });
+    test('parse request', async () => {
+        parseRequest(req, res, nextFunction);
+    });
+    test('parse response', async () => {
+        parseResponse(req, res, nextFunction);
+    });
+    // TODO: enrich transmission response test
+    // Not supported yet
+    // test('Validate Auth', async () => {
+    // });
+});

package/lib/dist/lib/tests/openApiV3Generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openApiV3Generator.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/openApiV3Generator.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/openApiV3Generator.test.js

@@ -0,0 +1,66 @@
+import { literal, mockSchemaValidator, optional, union } from '@forklaunch/validator/tests/mockSchemaValidator';
+import { generateSwaggerDocument } from '../src/http/openApiV3Generator/openApiV3Generator';
+describe('openApiV3Generator tests', () => {
+    const testSchema = {
+        test: union(['a', optional(literal('test'))])
+    };
+    test('generate openApiV3', async () => {
+        const generatedOpenApiSpec = generateSwaggerDocument(mockSchemaValidator, 8000, [
+            {
+                basePath: '/api',
+                routes: [
+                    {
+                        basePath: '/test',
+                        path: '/',
+                        method: 'get',
+                        contractDetails: {
+                            name: 'Test Contract',
+                            summary: 'Test Contract Summary',
+                            body: testSchema,
+                            params: testSchema,
+                            requestHeaders: testSchema,
+                            query: testSchema,
+                            responses: {
+                                200: testSchema
+                            }
+                        }
+                    }
+                ]
+            }
+        ]);
+        expect(generatedOpenApiSpec).toEqual({
+            openapi: '3.1.0',
+            info: { title: '', version: '1.0.0' },
+            components: {
+                securitySchemes: {
+                    bearer: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' }
+                }
+            },
+            tags: [{ name: 'Api', description: 'Api Operations' }],
+            servers: [{ url: 'http://localhost:8000' }],
+            paths: {
+                '/api': {
+                    get: {
+                        tags: ['Api'],
+                        summary: 'Test Contract: Test Contract Summary',
+                        parameters: [
+                            { name: 'test', in: 'path' },
+                            { name: 'test', in: 'header' },
+                            { name: 'test', in: 'query' }
+                        ],
+                        responses: {
+                            '200': {
+                                description: 'OK',
+                                content: { 'application/json': { schema: {} } }
+                            }
+                        },
+                        requestBody: {
+                            required: true,
+                            content: { 'application/json': { schema: {} } }
+                        }
+                    }
+                }
+            }
+        });
+    });
+});

package/lib/dist/lib/tests/redisTtlCache.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisTtlCache.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/redisTtlCache.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/redisTtlCache.test.js

@@ -0,0 +1,49 @@
+import { GenericContainer } from 'testcontainers';
+import { RedisTtlCache } from '../src/cache/redisTtlCache';
+describe('redisTtlCache', () => {
+    let container;
+    let cache;
+    let key;
+    let value;
+    let ttlMilliseconds;
+    beforeAll(async () => {
+        container = await new GenericContainer('redis')
+            .withExposedPorts(6379)
+            .start();
+        cache = new RedisTtlCache(5000, {
+            url: `redis://${container.getHost()}:${container.getMappedPort(6379)}`
+        });
+        key = 'testKey';
+        value = { data: 'testValue' };
+        ttlMilliseconds = 1000;
+    }, 30000);
+    afterAll(async () => {
+        await cache.disconnect();
+        await container.stop();
+    });
+    it('put', async () => {
+        await cache.putRecord({ key, value, ttlMilliseconds });
+    });
+    test('read', async () => {
+        const storedValue = await cache.readRecord(key);
+        expect(storedValue).toEqual({
+            key,
+            ttlMilliseconds,
+            value
+        });
+    });
+    test('peek', async () => {
+        const exists = await cache.peekRecord(key);
+        expect(exists).toBeTruthy();
+    });
+    test('delete', async () => {
+        await cache.deleteRecord(key);
+        const existsAfterDelete = await cache.peekRecord(key);
+        expect(existsAfterDelete).toBeFalsy();
+    });
+    test('check no record after ttl', async () => {
+        await Promise.resolve(setTimeout(async () => { }, ttlMilliseconds));
+        const existsAfterTtl = await cache.peekRecord(key);
+        expect(existsAfterTtl).toBeFalsy();
+    });
+});

package/lib/dist/lib/tests/typedHandler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typedHandler.test.d.ts.map

package/lib/dist/lib/tests/typedHandler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedHandler.test.d.ts","sourceRoot":"","sources":["../../../../dist/lib/tests/typedHandler.test.js"],"names":[],"mappings":""}

package/lib/dist/lib/tests/typedHandler.test.js

@@ -0,0 +1,3 @@
+// TODO: implement tests
+describe('typed-handler tests', () => { });
+export {};

package/lib/dist/lib/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/lib/dist/lib/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../../../dist/lib/vitest.config.js"],"names":[],"mappings":""}

package/lib/dist/lib/vitest.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        globals: true,
+        exclude: ['**/lib/**', '**/node_modules/**']
+    }
+});

package/lib/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./interfaces/baseService";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../dist/services/index.js"],"names":[],"mappings":""}

package/lib/dist/services/index.js

@@ -0,0 +1 @@
+export * from './interfaces/baseService';

package/lib/dist/services/interfaces/baseService.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=baseService.d.ts.map