@forklaunch/core 0.2.3 → 0.2.6

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/lib/src/services/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"baseService.d.ts","sourceRoot":"","sources":["../../../../src/services/interfaces/baseService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,OAAO,WAAW,WAAW;IAClC;;;;OAIG;IACH,EAAE,EAAE,aAAa,CAAC;CACnB"}

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

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

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

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

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

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

package/lib/tests/dtoMapper.test.js

@@ -0,0 +1,168 @@
+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 TestRequestDM;
+    beforeAll(() => {
+        TestRequestDM = new TestRequestDtoMapper(SchemaValidator());
+    });
+    test('schema static and constructed equality', async () => {
+        expect(TestRequestDM.schema).toEqual(TestRequestDtoMapper.schema());
+    });
+    test('from JSON', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const responseDM = TestRequestDM.fromJson(json);
+        const staticDM = TestRequestDtoMapper.fromJson(SchemaValidator(), json);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticDM.dto).toEqual(expectedDto);
+        expect(responseDM.dto).toEqual(expectedDto);
+        expect(responseDM.dto).toEqual(staticDM.dto);
+    });
+    test('deserialize', async () => {
+        const json = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        const entity = extractNonTimeBasedEntityFields(TestRequestDM.deserializeJsonToEntity(json));
+        const objectEntity = extractNonTimeBasedEntityFields(TestRequestDM.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(() => TestRequestDM.fromJson(json)).toThrow();
+        expect(() => 
+        // @ts-expect-error
+        TestRequestDtoMapper.fromJson(new TypeboxSchemaValidator(), json)).toThrow();
+    });
+});
+describe('response dtoMapper tests', () => {
+    let TestResponseDM;
+    beforeAll(() => {
+        TestResponseDM = new TestResponseDtoMapper(SchemaValidator());
+    });
+    test('schema static and constructed equality', async () => {
+        expect(TestResponseDM.schema).toEqual(TestResponseDtoMapper.schema());
+    });
+    test('from entity', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const responseDM = TestResponseDM.fromEntity(entity);
+        const staticDM = TestResponseDtoMapper.fromEntity(SchemaValidator(), entity);
+        const expectedDto = {
+            id: '123',
+            name: 'test',
+            age: 1
+        };
+        expect(staticDM.dto).toEqual(expectedDto);
+        expect(responseDM.dto).toEqual(expectedDto);
+        expect(responseDM.dto).toEqual(staticDM.dto);
+    });
+    test('serialize', async () => {
+        const entity = new TestEntity();
+        entity.id = '123';
+        entity.name = 'test';
+        entity.age = 1;
+        const json = TestResponseDM.serializeEntityToJson(entity);
+        const objectJson = TestResponseDM.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(() => TestResponseDM.fromEntity(entity).toJson()).toThrow();
+        expect(() => TestResponseDtoMapper.fromEntity(SchemaValidator(), entity).toJson()).toThrow();
+    });
+});

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

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

package/lib/tests/entityMapper.test.js

@@ -0,0 +1,168 @@
+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/tests/expressLikeRouter.test.d.ts

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

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

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

package/lib/tests/expressLikeRouter.test.js

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

package/lib/tests/expressLikeRouterInstantiation.test.d.ts

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

package/lib/tests/expressLikeRouterInstantiation.test.d.ts.map

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

package/lib/tests/expressLikeRouterInstantiation.test.js

@@ -0,0 +1,60 @@
+import { date, number, SchemaValidator, string } from '@forklaunch/validator/typebox';
+import { ForklaunchExpressLikeRouter, typedHandler } from '../src/http';
+const xasd = typedHandler(SchemaValidator(), '/test/:name/:id', 'trace', {
+    name: 'string',
+    summary: 'string',
+    params: {
+        name: string,
+        id: number
+    },
+    requestHeaders: {
+        'x-test': number
+    },
+    responses: {
+        200: date,
+        400: string
+    }
+}, async (req, res) => {
+    // const r = req.params.a;
+    const i = req.headers['x-test'] * 7;
+    const l = res.getHeaders()['x-correlation-id'];
+}, async (req, res) => {
+    // const r = req.params.a;
+    const i = req.headers['x-test'] * 7;
+    const l = res.getHeaders()['x-correlation-id'];
+    res.status(200).send(new Date());
+});
+const xa = new ForklaunchExpressLikeRouter('/l', SchemaValidator(), {});
+const contractDetails = {
+    name: 'string',
+    summary: 'string',
+    params: {
+        name: string,
+        id: number
+        // a: string
+    },
+    requestHeaders: {
+        'x-test': number
+    },
+    responses: {
+        200: date,
+        400: string
+    }
+};
+const a = xa.trace('/test/:name/:id', contractDetails, async (req, res) => {
+    // const r = req.params.a;
+    const i = req.headers['x-test'] * 7;
+    const l = res.getHeaders()['x-correlation-id'];
+}, async (req, res) => {
+    // const r = req.params.a;
+    const i = req.headers['x-test'] * 7;
+    const l = res.getHeaders()['x-correlation-id'];
+    res.status(200).send(new Date());
+});
+const b = xa.trace('/test/:name/:id', async (req, res) => {
+    const i = req.headers['x-test'] * 7;
+    const l = res.getHeaders()['x-correlation-id'];
+    res.status(200).send(new Date());
+}, xasd);
+const c = xa.trace('/test/:name/:id', xasd);
+xa.all(contractDetails, async (req, res) => { });

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

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

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

@@ -0,0 +1,102 @@
+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'))])
+    };
+    beforeEach(() => {
+        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: {
+                params: testSchema,
+                query: testSchema,
+                headers: testSchema,
+                body: testSchema
+            }
+        };
+        res = {
+            bodyData: testSchema,
+            statusCode: 200,
+            getHeaders: () => ({ 'x-correlation-id': '123' }),
+            setHeader: () => { },
+            status: () => ({
+                json: () => true,
+                jsonp: () => true,
+                send: () => { }
+            }),
+            end: () => { },
+            headersSent: false,
+            locals: {},
+            cors: true,
+            responseSchemas: {
+                headers: {
+                    'x-correlation-id': '123'
+                },
+                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: { 'x-correlation-id': '123' },
+            responses: {
+                200: testSchema
+            }
+        })(req, res, nextFunction);
+        expect(req.contractDetails).toEqual(contractDetails);
+    });
+    test('parse request', async () => {
+        createContext(mockSchemaValidator)(req, res, nextFunction);
+        parseRequest(req, res, nextFunction);
+    });
+    test('parse response', async () => {
+        createContext(mockSchemaValidator)(req, res, nextFunction);
+        parseResponse(req, res, nextFunction);
+    });
+    // TODO: enrich transmission response test
+    // Not supported yet
+    // test('Validate Auth', async () => {
+    // });
+});

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

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

package/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/tests/redisTtlCache.test.d.ts

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