@forklaunch/core 0.1.2 → 0.1.5

package/http/types/primitive.types.ts

@@ -1,76 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { UnboxedObjectSchema } from '@forklaunch/validator/types';
-
-export type ParamsDictionary = { [key: string]: string };
-
-export type StringOnlyObject<SV extends AnySchemaValidator> = Omit<
-  UnboxedObjectSchema<SV>,
-  number | symbol
->;
-export type NumberOnlyObject<SV extends AnySchemaValidator> = Omit<
-  UnboxedObjectSchema<SV>,
-  string | symbol
->;
-
-export type BodyObject<SV extends AnySchemaValidator> = StringOnlyObject<SV> &
-  unknown;
-export type ParamsObject<SV extends AnySchemaValidator> = StringOnlyObject<SV> &
-  unknown;
-export type QueryObject<SV extends AnySchemaValidator> = StringOnlyObject<SV> &
-  unknown;
-export type HeadersObject<SV extends AnySchemaValidator> =
-  StringOnlyObject<SV> & unknown;
-export type ResponsesObject<SV extends AnySchemaValidator> = {
-  [key: number]:
-    | SV['_ValidSchemaObject']
-    | UnboxedObjectSchema<SV>
-    | string
-    | SV['string'];
-} & unknown;
-
-export type Body<SV extends AnySchemaValidator> =
-  | BodyObject<SV>
-  | SV['_ValidSchemaObject']
-  | SV['_SchemaCatchall'];
-
-export type AuthMethod = 'jwt' | 'session';
-export interface PathParamHttpContractDetails<
-  SV extends AnySchemaValidator,
-  ParamSchemas extends ParamsObject<SV> = ParamsObject<SV>,
-  ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>,
-  QuerySchemas extends QueryObject<SV> = QueryObject<SV>
-> {
-  name: string;
-  summary: string;
-  responses: ResponseSchemas;
-  requestHeaders?: HeadersObject<SV>;
-  responseHeaders?: HeadersObject<SV>;
-  params?: ParamSchemas;
-  query?: QuerySchemas;
-  auth?: {
-    method: AuthMethod;
-    allowedSlugs?: Set<string>;
-    forbiddenSlugs?: Set<string>;
-    allowedRoles?: Set<string>;
-    forbiddenRoles?: Set<string>;
-  };
-}
-
-export interface HttpContractDetails<
-  SV extends AnySchemaValidator,
-  ParamSchemas extends ParamsObject<SV> = ParamsObject<SV>,
-  ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>,
-  BodySchema extends Body<SV> = Body<SV>,
-  QuerySchemas extends QueryObject<SV> = QueryObject<SV>
-> extends PathParamHttpContractDetails<
-    SV,
-    ParamSchemas,
-    ResponseSchemas,
-    QuerySchemas
-  > {
-  body?: BodySchema;
-  contentType?:
-    | 'application/json'
-    | 'multipart/form-data'
-    | 'application/x-www-form-urlencoded';
-}

package/index.ts

@@ -1,6 +0,0 @@
-export * from './cache';
-export * from './controllers';
-export * from './database';
-export * from './entityMapper';
-export * from './http';
-export * from './services';

package/jest.config.ts

@@ -1,10 +0,0 @@
-import type { Config } from 'jest';
-
-const config: Config = {
-  verbose: true,
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testPathIgnorePatterns: ['dist/', 'node_modules/']
-};
-
-export default config;

package/tests/entityMapper.test.ts

@@ -1,219 +0,0 @@
-import {
-  TypeboxSchemaValidator,
-  number,
-  string
-} from '@forklaunch/validator/typebox';
-import { BaseEntity } from '../database/mikro/models/entities/base.entity';
-import { RequestEntityMapper } from '../entityMapper/models/requestEntityMapper.model';
-import { ResponseEntityMapper } from '../entityMapper/models/responseEntityMapper.model';
-
-class TestEntity extends BaseEntity {
-  name: string;
-  age: number;
-}
-
-class TestRequestEntityMapper extends RequestEntityMapper<
-  TestEntity,
-  TypeboxSchemaValidator
-> {
-  schema = {
-    id: string,
-    name: string,
-    age: number
-  };
-
-  toEntity(...additionalArgs: unknown[]): TestEntity {
-    const entity = new TestEntity();
-    entity.id = this.dto.id;
-    entity.name = this.dto.name;
-    entity.age = this.dto.age;
-
-    return entity;
-  }
-}
-
-class TestResponseEntityMapper extends ResponseEntityMapper<
-  TestEntity,
-  TypeboxSchemaValidator
-> {
-  schema = {
-    id: string,
-    name: string,
-    age: number
-  };
-
-  fromEntity(entity: TestEntity): this {
-    this.dto = {
-      id: entity.id,
-      name: entity.name,
-      age: entity.age
-    };
-
-    return this;
-  }
-}
-
-function extractNonTimeBasedEntityFields<T extends BaseEntity>(entity: T): T {
-  entity.createdAt = new Date(0);
-  entity.updatedAt = new Date(0);
-  return entity;
-}
-
-describe('Request Entity Mapper Test', () => {
-  let TestRequestEM: TestRequestEntityMapper;
-
-  beforeAll(() => {
-    TestRequestEM = new TestRequestEntityMapper(new TypeboxSchemaValidator());
-  });
-
-  test('Schema Equality', async () => {
-    expect(TestRequestEM.schema).toEqual(TestRequestEntityMapper.schema());
-  });
-
-  test('From JSON', async () => {
-    const json = {
-      id: '123',
-      name: 'test',
-      age: 1
-    };
-
-    const responseEM = TestRequestEM.fromJson(json);
-    const staticEM = TestRequestEntityMapper.fromJson(
-      new TypeboxSchemaValidator(),
-      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(
-      TestRequestEntityMapper.deserializeJsonToEntity(
-        new TypeboxSchemaValidator(),
-        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
-      TestRequestEntityMapper.fromJson(new TypeboxSchemaValidator(), json)
-    ).toThrow();
-  });
-});
-
-describe('Response Entity Mapper Test', () => {
-  let TestResponseEM: TestResponseEntityMapper;
-
-  beforeAll(() => {
-    TestResponseEM = new TestResponseEntityMapper(new TypeboxSchemaValidator());
-  });
-
-  test('Schema Equality', async () => {
-    expect(TestResponseEM.schema).toEqual(TestResponseEntityMapper.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 = TestResponseEntityMapper.fromEntity(
-      new TypeboxSchemaValidator(),
-      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 = TestResponseEntityMapper.serializeEntityToJson(
-      new TypeboxSchemaValidator(),
-      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(() =>
-      TestResponseEntityMapper.fromEntity(
-        new TypeboxSchemaValidator(),
-        entity
-      ).toJson()
-    ).toThrow();
-  });
-});

package/tests/http.middleware.test.ts

@@ -1,99 +0,0 @@
-import { SchemaValidator } from '@forklaunch/validator';
-import {
-    MockSchemaValidator,
-    literal,
-    mockSchemaValidator,
-    optional,
-    union
-} from '@forklaunch/validator/tests/mockSchemaValidator';
-import { ForklaunchRequest, ForklaunchResponse, HttpContractDetails, RequestContext, createRequestContext, enrichRequestDetails, parseRequestBody, parseRequestHeaders, parseRequestParams, parseRequestQuery, parseResponse } from '../http';
-
-describe('Http Middleware Tests', () => {
-    let contractDetails: HttpContractDetails<MockSchemaValidator>;
-    let req: ForklaunchRequest<MockSchemaValidator>;
-    let resp: ForklaunchResponse;
-
-    const nextFunction = (err?: unknown) => {
-        expect(err).toBeFalsy()
-    };
-
-    const testSchema = {
-        test: union(['a', optional(literal('test'))] as const)
-    };
-
-    beforeAll(() => {
-        contractDetails = {
-            name: 'Test Contract',
-            summary: 'Test Contract Summary',
-            body: testSchema,
-            params: testSchema,
-            requestHeaders: testSchema,
-            query: testSchema,
-            responses: {
-                200: testSchema
-            }
-        };
-
-        req = {
-            context: {} as RequestContext,
-            contractDetails: {} as HttpContractDetails<MockSchemaValidator>,
-            schemaValidator: {} as SchemaValidator,
-            params: testSchema,
-            headers: testSchema,
-            body: testSchema,
-            query: testSchema
-        };
-
-        resp = {
-            bodyData: {},
-            statusCode: 200,
-            corked: false,
-            getHeaders: jest.fn(),
-            setHeader: jest.fn(),
-            status: jest.fn(),
-            send: jest.fn(),
-            json: jest.fn(),
-            jsonp: jest.fn(),
-        };
-    });
-
-
-
-    test('Create Request Context', async () => {
-        req.context = {} as RequestContext;
-        req.schemaValidator = {} as SchemaValidator;
-        createRequestContext(mockSchemaValidator)(req, resp, nextFunction);
-        expect(req.context.correlationId).not.toBe('123');
-        expect(req.schemaValidator).toBe(mockSchemaValidator);
-    });
-
-    test('Enrich Request Details', async () => {
-        req.contractDetails = {} as HttpContractDetails<MockSchemaValidator>;
-        enrichRequestDetails(contractDetails)(req, resp, nextFunction);
-        expect(req.contractDetails).toEqual(contractDetails);
-    });
-
-    test('Validate Request Params', async () => {
-        parseRequestParams(req, resp, nextFunction);
-    });
-
-    test('Validate Request Headers', async () => {
-        parseRequestHeaders(req, resp, nextFunction);
-    });
-
-    test('Validate Request Body', async () => {
-        parseRequestBody(req, resp, nextFunction);
-    });
-
-    test('Validate Request Query Params', async () => {
-        parseRequestQuery(req, resp, nextFunction);
-    });
-
-    test('Validate Response', async () => {
-        parseResponse(req, resp, nextFunction);
-    });
-
-    // Not supported yet
-    // test('Validate Auth', async () => {
-    // });
-});

package/tests/redisTtlCache.test.ts

@@ -1,62 +0,0 @@
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
-import { RedisTtlCache } from '../cache/redisTtlCache';
-
-describe('RedisTtlCache', () => {
-  let container: StartedTestContainer;
-  let cache: RedisTtlCache;
-  let key: string;
-  let value: unknown;
-  let ttlMilliseconds: number;
-
-  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('PutRecord', async () => {
-    await cache.putRecord({ key, value, ttlMilliseconds });
-  });
-
-  test('Read Record', async () => {
-    const storedValue = await cache.readRecord(key);
-
-    expect(storedValue).toEqual({
-      key,
-      ttlMilliseconds,
-      value
-    });
-  });
-
-  test('Peek Record', async () => {
-    const exists = await cache.peekRecord(key);
-
-    expect(exists).toBeTruthy();
-  });
-
-  test('Delete Record', async () => {
-    await cache.deleteRecord(key);
-    const existsAfterDelete = await cache.peekRecord(key);
-
-    expect(existsAfterDelete).toBeFalsy();
-  });
-
-  test('Check No Record', async () => {
-    await Promise.resolve(setTimeout(async () => {}, ttlMilliseconds));
-    const existsAfterTtl = await cache.peekRecord(key);
-    expect(existsAfterTtl).toBeFalsy();
-  });
-});