@forklaunch/core 0.1.1 → 0.1.2

package/http/types/api.types.ts

@@ -1,10 +1,16 @@
-import { Prettify } from "@forklaunch/common";
-import { Schema, SchemaCatchall, ValidSchemaObject } from "@forklaunch/validator";
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-import { IdiomaticSchema } from "@forklaunch/validator/types";
-import { IncomingHttpHeaders, OutgoingHttpHeader } from "http";
-import { ParsedQs } from "qs";
-import { HttpContractDetails, ParamsDictionary, PathParamHttpContractDetails } from "./primitive.types";
+import { Prettify } from '@forklaunch/common';
+import {
+    AnySchemaValidator,
+    Schema
+} from '@forklaunch/validator';
+import { IdiomaticSchema, SchemaValidator } from '@forklaunch/validator/types';
+import { IncomingHttpHeaders, OutgoingHttpHeader } from 'http';
+import { ParsedQs } from 'qs';
+import {
+    HttpContractDetails,
+    ParamsDictionary,
+    PathParamHttpContractDetails
+} from './primitive.types';
 
 export interface RequestContext {
     correlationId: string;
@@ -12,15 +18,15 @@ export interface RequestContext {
 }
 
 export interface ForklaunchRequest<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     P = ParamsDictionary,
-    ReqBody = any,
+    ReqBody = unknown,
     ReqQuery = ParsedQs,
-    Headers = IncomingHttpHeaders,
+    Headers = IncomingHttpHeaders
 > {
     context: Prettify<RequestContext>;
     contractDetails: HttpContractDetails<SV> | PathParamHttpContractDetails<SV>;
-    schemaValidator: SV;
+    schemaValidator: SchemaValidator;
 
     params: P;
     headers: Headers;
@@ -29,37 +35,49 @@ export interface ForklaunchRequest<
 }
 
 export interface ForklaunchResponse<
-    ResBody = any,
-    StatusCode = number,
+    ResBody = {
+        400: unknown;
+        401: unknown;
+        403: unknown;
+        500: unknown;
+    },
+    StatusCode = number
 > {
     bodyData: unknown;
     statusCode: StatusCode;
     corked: boolean;
-    
+
     getHeaders: () => OutgoingHttpHeader;
     setHeader: (key: string, value: string) => void;
     status: {
         <U extends keyof ResBody>(code: U): ForklaunchResponse<ResBody[U], U>;
-        <U extends keyof ResBody>(code: U, message?: string): ForklaunchResponse<ResBody[U], U>;
+        <U extends keyof ResBody>(
+            code: U,
+            message?: string
+        ): ForklaunchResponse<ResBody[U], U>;
         <U extends 500>(code: U): ForklaunchResponse<string, U>;
         <U extends 500>(code: U, message?: string): ForklaunchResponse<string, U>;
-    }
+    };
     send: {
         <T>(body?: ResBody, close_connection?: boolean): T;
         <T>(body?: ResBody): T;
-    }
+    };
     json: {
         (body?: ResBody): boolean;
         <T>(body?: ResBody): T;
-    }
+    };
     jsonp: {
         (body?: ResBody): boolean;
         <T>(body?: ResBody): T;
-    }
+    };
 }
-export type MapSchema<SV extends SchemaValidator, T extends IdiomaticSchema<SchemaCatchall<SV>> | ValidSchemaObject<SV>> = Schema<T, SV> extends infer U ? 
-{ [key: string]: unknown } extends U ? 
-  never : 
-  U : 
-never;
-export type ForklaunchNextFunction = (err?: any) => void;
+export type MapSchema<
+    SV extends AnySchemaValidator,
+    T extends IdiomaticSchema<SV> | SV['_ValidSchemaObject']
+> =
+    Schema<T, SV> extends infer U
+    ? { [key: string]: unknown } extends U
+    ? never
+    : U
+    : never;
+export type ForklaunchNextFunction = (err?: unknown) => void;

package/http/types/index.ts

@@ -0,0 +1,2 @@
+export * from './api.types';
+export * from './primitive.types';

package/http/types/primitive.types.ts

@@ -1,55 +1,76 @@
-import { SchemaCatchall, ValidSchemaObject } from "@forklaunch/validator";
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-import { UnboxedObjectSchema } from "@forklaunch/validator/types";
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { UnboxedObjectSchema } from '@forklaunch/validator/types';
 
-export type ParamsDictionary = { [key: string]: string; };
+export type ParamsDictionary = { [key: string]: string };
 
-export type StringOnlyObject<SV extends SchemaValidator> = Omit<UnboxedObjectSchema<SchemaCatchall<SV>>, number | symbol>;
-export type NumberOnlyObject<SV extends SchemaValidator> = Omit<UnboxedObjectSchema<SchemaCatchall<SV>>, string | symbol>;
+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 SchemaValidator> = StringOnlyObject<SV> & unknown;
-export type ParamsObject<SV extends SchemaValidator> = StringOnlyObject<SV> & unknown;
-export type QueryObject<SV extends SchemaValidator> = StringOnlyObject<SV> & unknown;
-export type HeadersObject<SV extends SchemaValidator> = StringOnlyObject<SV> & unknown;
-export type ResponsesObject<SV extends SchemaValidator> = NumberOnlyObject<SV> & unknown;
+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 SchemaValidator> = BodyObject<SV>
-          | ValidSchemaObject<SV>
-          | SchemaCatchall<SV>;
+export type Body<SV extends AnySchemaValidator> =
+  | BodyObject<SV>
+  | SV['_ValidSchemaObject']
+  | SV['_SchemaCatchall'];
 
 export type AuthMethod = 'jwt' | 'session';
 export interface PathParamHttpContractDetails<
-    SV extends SchemaValidator,
-    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>
-    }
+  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 SchemaValidator,
-    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';
+  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,5 +1,6 @@
-// export * from './cache';
-// export * from './controllers';
-// export * from './database';
-// export * from './entityMapper';
-// export * from './services';
+export * from './cache';
+export * from './controllers';
+export * from './database';
+export * from './entityMapper';
+export * from './http';
+export * from './services';

package/jest.config.ts

@@ -1,4 +1,4 @@
-import type {Config} from 'jest';
+import type { Config } from 'jest';
 
 const config: Config = {
   verbose: true,
@@ -7,4 +7,4 @@ const config: Config = {
   testPathIgnorePatterns: ['dist/', 'node_modules/']
 };
 
-export default config;
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "forklaunch-js core package. Contains useful building blocks.",
   "main": "index.js",
   "scripts": {
@@ -8,7 +8,8 @@
     "build": "tsc",
     "docs": "typedoc --out docs *",
     "lint": "eslint . -c eslint.config.mjs",
-    "lint:fix": "eslint . -c eslint.config.mjs --fix"
+    "lint:fix": "eslint . -c eslint.config.mjs --fix",
+    "format": "prettier --ignore-path=.prettierignore --config .prettierrc '**/*.ts' --write"
   },
   "author": "Rohin Bhargava",
   "license": "MIT",
@@ -21,7 +22,7 @@
   },
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "dependencies": {
-    "@forklaunch/validator": "^0.1.15",
+    "@forklaunch/validator": "^0.2.9",
     "@mikro-orm/core": "^6.2.9",
     "jose": "^5.6.2",
     "redis": "^4.6.14",
@@ -35,6 +36,8 @@
     "@types/redis": "^4.0.11",
     "@types/uuid": "^10.0.0",
     "globals": "^15.8.0",
+    "prettier": "^3.3.2",
+    "testcontainers": "^10.10.1",
     "ts-jest": "^29.1.5",
     "ts-node": "^10.9.2",
     "typedoc": "^0.26.3",
@@ -43,5 +46,11 @@
   },
   "directories": {
     "test": "tests"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   }
-}
+}

package/tests/entityMapper.test.ts

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,99 @@
+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 () => {
+    // });
+});