@forklaunch/core 0.1.2 → 0.1.3

package/dist/jest.config.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    verbose: true,
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['dist/', 'node_modules/']
+};
+exports.default = config;
+//# sourceMappingURL=jest.config.js.map

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "@forklaunch/core",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "forklaunch-js core package. Contains useful building blocks.",
-  "main": "index.js",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "jest",
     "build": "tsc",

package/.prettierignore

@@ -1,2 +0,0 @@
-node_modules/
-dist/

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "none",
-  "singleQuote": true,
-  "printWidth": 80
-}

package/entityMapper/index.ts

@@ -1,2 +0,0 @@
-export * from './models/requestEntityMapper.model';
-export * from './models/responseEntityMapper.model';

package/entityMapper/interfaces/entityMapper.interface.ts

@@ -1,17 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-
-/**
- * Interface representing a constructor for an entity mapper.
- *
- * @template T - The type of the entity mapper.
- * @interface EntityMapperConstructor
- */
-export interface EntityMapperConstructor<T, SV extends AnySchemaValidator> {
-  /**
-   * Creates a new instance of the entity mapper.
-   *
-   * @param {AnySchemaValidator} schemaValidator - The arguments to pass to the constructor.
-   * @returns {T} - A new instance of the entity mapper.
-   */
-  new (schemaValidator: SV): T;
-}

package/entityMapper/models/baseEntityMapper.model.ts

@@ -1,110 +0,0 @@
-import {
-  AnySchemaValidator,
-  Schema,
-  SchemaValidator
-} from '@forklaunch/validator';
-import { EntityMapperConstructor } from '../interfaces/entityMapper.interface';
-import { EntityMapperSchemaValidatorObject } from '../types/entityMapper.types';
-
-/**
- * Constructs an instance of a T.
- *
- * @template T - A type that extends BaseEntityMapper.
- * @param {EntityMapperConstructor<T>} self - The constructor of the T.
- * @param {...any[]} args - The arguments to pass to the constructor.
- * @returns {T} - An instance of the T.
- */
-export function construct<T, SV extends AnySchemaValidator>(
-  self: EntityMapperConstructor<T, SV>,
-  schemaValidator?: SV
-): T {
-  return new self(schemaValidator || ({} as SV));
-}
-
-/**
- * Abstract class representing a base entityMapper.
- *
- * @template SV - A type that extends SchemaValidator.
- */
-export abstract class BaseEntityMapper<SV extends AnySchemaValidator> {
-  /**
-   * The schema validator exact type.
-   * @type {SV}
-   * @protected
-   */
-  _SV!: SV;
-
-  /**
-   * The schema validator as a general type.
-   * @type {SchemaValidator}
-   * @protected
-   */
-  protected schemaValidator: SchemaValidator;
-
-  /**
-   * The schema definition.
-   * @type {EntityMapperSchemaValidatorObject<SV>}
-   * @abstract
-   */
-  abstract schema: EntityMapperSchemaValidatorObject<SV>;
-
-  /**
-   * The Data Transfer Object (DTO).
-   * @type {Schema<this['schema'], SV>}
-   *
-   */
-  _dto: Schema<this['schema'], SV> = {} as unknown as Schema<
-    this['schema'],
-    SV
-  >;
-
-  /**
-   * Creates an instance of BaseEntityMapper.
-   *
-   * @param {SV} schemaValidator - The schema provider.
-   */
-  constructor(schemaValidator: SV) {
-    this.schemaValidator = schemaValidator as unknown as SchemaValidator;
-  }
-
-  /**
-   * Validates and sets the Data Transfer Object (DTO).
-   *
-   * @param {this['_dto']} dto - The Data Transfer Object (DTO).
-   * @throws {Error} - Throws an error if the DTO is invalid.
-   */
-  set dto(_dto: this['_dto']) {
-    if (
-      !this.schemaValidator.validate(
-        this.schemaValidator.schemify(this.schema),
-        _dto
-      )
-    ) {
-      throw new Error('Invalid DTO');
-    }
-    this._dto = _dto as unknown as Schema<this['schema'], SV>;
-  }
-
-  /**
-   * Validates and gets the Data Transfer Object (DTO).
-   *
-   * @returns {this['_dto']} - The Data Transfer Object (DTO).
-   * @throws {Error} - Throws an error if the DTO is invalid.
-   */
-  get dto(): this['_dto'] {
-    return this._dto as unknown as this['_dto'];
-  }
-
-  /**
-   * Gets the schema of a T.
-   *
-   * @template T - A type that extends BaseEntityMapper.
-   * @param {EntityMapperConstructor<T>} this - The constructor of the T.
-   * @returns {T['schema']} - The schema of the T.
-   */
-  static schema<T extends BaseEntityMapper<SV>, SV extends AnySchemaValidator>(
-    this: EntityMapperConstructor<T, SV>
-  ): T['schema'] {
-    return construct(this).schema;
-  }
-}

package/entityMapper/models/requestEntityMapper.model.ts

@@ -1,111 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { BaseEntity } from '../../database/mikro/models/entities/base.entity';
-import { EntityMapperConstructor } from '../interfaces/entityMapper.interface';
-import { BaseEntityMapper, construct } from './baseEntityMapper.model';
-
-/**
- * Abstract class representing a request entityMapper.
- *
- * @template Entity - A type that extends BaseEntity.
- * @template SV - A type that extends SchemaValidator.
- * @extends {BaseEntityMapper<SV>}
- */
-export abstract class RequestEntityMapper<
-  Entity extends BaseEntity,
-  SV extends AnySchemaValidator
-> extends BaseEntityMapper<SV> {
-  /**
-   * The entity.
-   * @type {Entity}
-   * @protected
-   */
-  _Entity!: Entity;
-
-  /**
-   * Converts the underlying DTO to an entity.
-   *
-   * @abstract
-   * @param {...unknown[]} additionalArgs - Additional arguments.
-   * @returns {Entity} - The entity.
-   */
-  abstract toEntity(...additionalArgs: unknown[]): Entity;
-
-  /**
-   * Populates the DTO with data from a JSON object.
-   *
-   * @param {this['_dto']} json - The JSON object.
-   * @returns {this} - The instance of the RequestEntityMapper.
-   */
-  fromJson(json: this['_dto']): this {
-    if (
-      !this.schemaValidator.validate(
-        this.schemaValidator.schemify(this.schema),
-        json
-      )
-    ) {
-      throw new Error('Invalid DTO');
-    }
-    this.dto = json;
-    return this;
-  }
-
-  /**
-   * Deserializes a JSON object to an entity.
-   *
-   * @param {this['_dto']} json - The JSON object.
-   * @param {...unknown[]} additionalArgs - Additional arguments.
-   * @returns {Entity} - The entity.
-   */
-  deserializeJsonToEntity(
-    json: this['_dto'],
-    ...additionalArgs: unknown[]
-  ): Entity {
-    return this.fromJson(json).toEntity(...additionalArgs);
-  }
-
-  /**
-   * Creates an instance of a RequestEntityMapper from a JSON object.
-   *
-   * @template T - A type that extends RequestEntityMapper.
-   * @param {EntityMapperConstructor<T>} this - The constructor of the T.
-   * @param {T['_SV']} schemaValidator - The schema provider.
-   * @param {T['_dto']} json - The JSON object.
-   * @returns {T} - An instance of the T.
-   */
-  static fromJson<
-    T extends RequestEntityMapper<BaseEntity, SV>,
-    SV extends AnySchemaValidator,
-    JsonType extends T['_dto']
-  >(
-    this: EntityMapperConstructor<T, SV>,
-    schemaValidator: SV,
-    json: JsonType
-  ): T {
-    return construct(this, schemaValidator).fromJson(json);
-  }
-
-  /**
-   * Deserializes a JSON object to an entity.
-   *
-   * @template T - A type that extends RequestEntityMapper.
-   * @param {EntityMapperConstructor<T>} this - The constructor of the T.
-   * @param {T['_SV']} schemaValidator - The schema provider.
-   * @param {T['_dto']} json - The JSON object.
-   * @param {...unknown[]} additionalArgs - Additional arguments.
-   * @returns {T['_Entity']} - The entity.
-   */
-  static deserializeJsonToEntity<
-    T extends RequestEntityMapper<BaseEntity, SV>,
-    SV extends AnySchemaValidator,
-    JsonType extends T['_dto']
-  >(
-    this: EntityMapperConstructor<T, SV>,
-    schemaValidator: SV,
-    json: JsonType,
-    ...additionalArgs: unknown[]
-  ): T['_Entity'] {
-    return construct(this, schemaValidator)
-      .fromJson(json)
-      .toEntity(...additionalArgs);
-  }
-}

package/entityMapper/models/responseEntityMapper.model.ts

@@ -1,98 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { BaseEntity } from '../../database/mikro/models/entities/base.entity';
-import { EntityMapperConstructor } from '../interfaces/entityMapper.interface';
-import { BaseEntityMapper, construct } from './baseEntityMapper.model';
-
-/**
- * Abstract class representing a response entityMapper.
- *
- * @template Entity - A type that extends BaseEntity.
- * @template SV - A type that extends SchemaValidator.
- * @extends {BaseEntityMapper<SV>}
- */
-export abstract class ResponseEntityMapper<
-  Entity extends BaseEntity,
-  SV extends AnySchemaValidator
-> extends BaseEntityMapper<SV> {
-  /**
-   * The entity type.
-   * @type {Entity}
-   * @protected
-   */
-  _Entity!: Entity;
-
-  /**
-   * Populates entityMapper with DTO from an entity.
-   *
-   * @abstract
-   * @param {Entity} entity - The entity to convert.
-   * @returns {this} - The instance of the ResponseEntityMapper.
-   */
-  abstract fromEntity(entity: Entity, ...additionalArgs: unknown[]): this;
-
-  /**
-   * Converts the underlying DTO to a JSON object.
-   *
-   * @param {...unknown[]} additionalArgs - Additional arguments.
-   * @returns {this['_dto']} - The JSON object.
-   */
-  toJson(): this['_dto'] {
-    if (
-      !this.schemaValidator.validate(
-        this.schemaValidator.schemify(this.schema),
-        this.dto
-      )
-    ) {
-      throw new Error('Invalid DTO');
-    }
-    return this.dto;
-  }
-
-  /**
-   * Serializes an entity to a JSON object.
-   *
-   * @param {Entity} entity - The entity to serialize.
-   * @returns {this['_dto']} - The JSON object.
-   */
-  serializeEntityToJson(entity: Entity): this['_dto'] {
-    return this.fromEntity(entity).toJson();
-  }
-
-  /**
-   * Populates entityMapper with DTO from an entity.
-   *
-   * @template T - A type that extends ResponseEntityMapper.
-   * @param {EntityMapperConstructor<T>} this - The constructor of the T.
-   * @param {T['_Entity']} entity - The entity to convert.
-   * @returns {T} - An instance of the T.
-   */
-  static fromEntity<
-    T extends ResponseEntityMapper<BaseEntity, SV>,
-    SV extends AnySchemaValidator
-  >(
-    this: EntityMapperConstructor<T, SV>,
-    schemaValidator: SV,
-    entity: T['_Entity']
-  ): T {
-    return construct(this, schemaValidator).fromEntity(entity);
-  }
-
-  /**
-   * Serializes an entity to a JSON object.
-   *
-   * @template T - A type that extends ResponseEntityMapper.
-   * @param {EntityMapperConstructor<T>} this - The constructor of the T.
-   * @param {T['_Entity']} entity - The entity to serialize.
-   * @returns {T['_dto']} - The JSON object.
-   */
-  static serializeEntityToJson<
-    T extends ResponseEntityMapper<BaseEntity, SV>,
-    SV extends AnySchemaValidator
-  >(
-    this: EntityMapperConstructor<T, SV>,
-    schemaValidator: SV,
-    entity: T['_Entity']
-  ): T['_dto'] {
-    return construct(this, schemaValidator).serializeEntityToJson(entity);
-  }
-}

package/entityMapper/types/entityMapper.types.ts

@@ -1,12 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { UnboxedObjectSchema } from '@forklaunch/validator/types';
-
-/**
- * Type representing a schema validator object for an entity mapper.
- *
- * @template SV - A type that extends SchemaValidator.
- * @typedef {ValidSchemaObject<SV> | UnboxedObjectSchema<SchemaCatchall<SV>> & {}} EntityMapperSchemaValidatorObject
- */
-export type EntityMapperSchemaValidatorObject<SV extends AnySchemaValidator> =
-  | SV['_ValidSchemaObject']
-  | UnboxedObjectSchema<SV>;

package/eslint.config.mjs

@@ -1,12 +0,0 @@
-import pluginJs from "@eslint/js";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-
-
-export default [
-  {files: ["**/*.{ts}"]},
-  {ignores: ["tests/**/*", "dist/**/*", "node_modules/**/*"]},
-  {languageOptions: { globals: globals.browser }},
-  pluginJs.configs.recommended,
-  ...tseslint.configs.recommended,
-];

package/http/index.ts

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

package/http/middlewares/index.ts

@@ -1,2 +0,0 @@
-export * from './request.middleware';
-export * from './response.middleware';

package/http/middlewares/request.middleware.ts

@@ -1,257 +0,0 @@
-import { AnySchemaValidator, SchemaValidator } from '@forklaunch/validator';
-import * as jose from 'jose';
-import { v4 } from 'uuid';
-import {
-    ForklaunchNextFunction,
-    ForklaunchRequest,
-    ForklaunchResponse
-} from '../types/api.types';
-import {
-    AuthMethod,
-    HttpContractDetails,
-    PathParamHttpContractDetails,
-    StringOnlyObject
-} from '../types/primitive.types';
-
-export function createRequestContext<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(schemaValidator: SV) {
-    return (req: Request, res: Response, next?: NextFunction) => {
-        req.schemaValidator = schemaValidator as SchemaValidator;
-
-        let correlationId = v4();
-
-        if (req.headers['x-correlation-id']) {
-            correlationId = req.headers['x-correlation-id'] as string;
-        }
-
-        res.setHeader('x-correlation-id', correlationId);
-
-        req.context = {
-            correlationId: correlationId
-        };
-
-        if (next) {
-            next();
-        }
-    };
-}
-
-export function enrichRequestDetails<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(contractDetails: PathParamHttpContractDetails<SV> | HttpContractDetails<SV>) {
-    return (req: Request, _res: Response, next?: NextFunction) => {
-        req.contractDetails = contractDetails;
-
-        if (next) {
-            next();
-        }
-    };
-}
-
-export function preHandlerParse<SV extends AnySchemaValidator>(
-    schemaValidator: SchemaValidator,
-    object: unknown,
-    schemaInput?: StringOnlyObject<SV>
-) {
-    if (!schemaInput) {
-        return;
-    }
-
-    const schema = schemaValidator.schemify(schemaInput);
-    if (!schemaValidator.validate(schema, object)) {
-        return 400;
-    }
-}
-
-export function parseRequestParams<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-    const params = req.contractDetails.params;
-    if (preHandlerParse(req.schemaValidator, req.params, params) === 400) {
-        res.status(400).send('Invalid request parameters.');
-        if (next) {
-            next(new Error('Invalid request parameters.'));
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-
-export function parseRequestBody<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-    if (req.headers['content-type'] === 'application/json') {
-        const body = (req.schemaValidator,
-            req.contractDetails as HttpContractDetails<SV>).body;
-        if (
-            preHandlerParse(
-                req.schemaValidator,
-                req.body,
-                body as StringOnlyObject<SV>
-            ) === 400
-        ) {
-            res.status(400).send('Invalid request body.');
-            if (next) {
-                next(new Error('Invalid request body.'));
-            }
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-
-export function parseRequestHeaders<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-    const headers = req.contractDetails.requestHeaders;
-    if (preHandlerParse(req.schemaValidator, req.headers, headers) === 400) {
-        res.status(400).send('Invalid request headers.');
-        if (next) {
-            next(new Error('Invalid request headers.'));
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-
-export function parseRequestQuery<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-    const query = req.contractDetails.query;
-    if (preHandlerParse(req.schemaValidator, req.query, query) === 400) {
-        res.status(400).send('Invalid request query.');
-        if (next) {
-            next(new Error('Invalid request query.'));
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-
-async function checkAuthorizationToken(
-    authorizationMethod?: AuthMethod,
-    authorizationString?: string
-): Promise<[401 | 403, string] | string | undefined> {
-    if (!authorizationString) {
-        return [401, 'No Authorization token provided.'];
-    }
-    switch (authorizationMethod) {
-        case 'jwt': {
-            if (!authorizationString.startsWith('Bearer ')) {
-                return [401, 'Invalid Authorization token format.'];
-            }
-            try {
-                const decodedJwt = await jose.jwtVerify(
-                    authorizationString.split(' ')[1],
-                    new TextEncoder().encode(
-                        process.env.JWT_SECRET || 'your-256-bit-secret'
-                    )
-                );
-                return decodedJwt.payload.iss;
-            } catch (error) {
-                console.error(error);
-                return [403, 'Invalid Authorization token.'];
-            }
-        }
-        default:
-            return [401, 'Invalid Authorization method.'];
-    }
-}
-
-function mapRoles(
-    authorizationType?: AuthMethod,
-    authorizationToken?: string
-): string[] {
-    return [];
-}
-function mapPermissions(
-    authorizationType?: AuthMethod,
-    authorizationToken?: string
-): string[] {
-    return [];
-}
-
-export async function parseRequestAuth<
-    SV extends AnySchemaValidator,
-    Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse,
-    NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-    const auth = req.contractDetails.auth;
-    if (auth) {
-        const errorAndMessage = await checkAuthorizationToken(
-            auth.method,
-            req.headers.authorization
-        );
-        if (Array.isArray(errorAndMessage)) {
-            res.status(errorAndMessage[0]).send(errorAndMessage[1]);
-            if (next) {
-                next(new Error(errorAndMessage[1]));
-            }
-        }
-
-        // TODO: Implement role and permission checking
-        const permissionSlugs = mapPermissions(
-            auth.method,
-            req.headers.authorization
-        );
-        const roles = mapRoles(auth.method, req.headers.authorization);
-
-        const permissionErrorMessage =
-            'User does not have sufficient permissions to perform action.';
-        const roleErrorMessage =
-            'User does not have correct role to perform action.';
-
-        // this is wrong, we need to check if any of the user's permissions are in the allowed permissions, while checking that any of the permissions is not in the forbidden slugs
-        // currently this is checking if any of the user's permissions are NOT in the allowed permissions
-        permissionSlugs.forEach((permissionSlug) => {
-            if (
-                !req.contractDetails.auth?.allowedSlugs?.has(permissionSlug) ||
-                req.contractDetails.auth?.forbiddenSlugs?.has(permissionSlug)
-            ) {
-                res.status(403).send(permissionErrorMessage);
-                if (next) {
-                    next(new Error(permissionErrorMessage));
-                }
-            }
-        });
-        roles.forEach((role) => {
-            if (
-                !req.contractDetails.auth?.allowedRoles?.has(role) ||
-                req.contractDetails.auth?.forbiddenRoles?.has(role)
-            ) {
-                res.status(403).send(roleErrorMessage);
-                if (next) {
-                    next(new Error(roleErrorMessage));
-                }
-            }
-        });
-    }
-
-    // if (next) {
-    //     next();
-    // }
-}

package/http/middlewares/response.middleware.ts

@@ -1,63 +0,0 @@
-import { AnySchemaValidator } from '@forklaunch/validator';
-import {
-  ForklaunchNextFunction,
-  ForklaunchRequest,
-  ForklaunchResponse
-} from '../types/api.types';
-import { HttpContractDetails } from '../types/primitive.types';
-
-function checkAnyValidation<SV extends AnySchemaValidator>(
-  contractDetails: HttpContractDetails<SV>
-) {
-  return (
-    contractDetails.body ||
-    contractDetails.params ||
-    contractDetails.requestHeaders ||
-    contractDetails.query
-  );
-}
-
-export function parseResponse<
-  SV extends AnySchemaValidator,
-  Request extends ForklaunchRequest<SV>,
-  Response extends ForklaunchResponse,
-  NextFunction extends ForklaunchNextFunction
->(req: Request, res: Response, next?: NextFunction) {
-  if (req.contractDetails.responseHeaders) {
-    const schema = req.schemaValidator.schemify(
-      req.contractDetails.responseHeaders
-    );
-    req.schemaValidator.validate(schema, res.getHeaders());
-  }
-
-  if (
-    res.statusCode === 500 ||
-    (checkAnyValidation(req.contractDetails) && res.statusCode === 400) ||
-    (req.contractDetails.auth &&
-      (res.statusCode === 401 || res.statusCode === 403))
-  ) {
-    req.schemaValidator.validate(req.schemaValidator.string, res.bodyData);
-    return;
-  }
-  if (
-    Object.prototype.hasOwnProperty.call(
-      !req.contractDetails.responses,
-      res.statusCode
-    )
-  ) {
-    if (next) {
-      next(
-        new Error(`Response code ${res.statusCode} not defined in contract.`)
-      );
-    }
-  }
-
-  const schema = req.schemaValidator.schemify(
-    req.contractDetails.responses[res.statusCode]
-  );
-  req.schemaValidator.validate(schema, res.bodyData);
-
-  if (next) {
-    next();
-  }
-}

package/http/types/api.types.ts

@@ -1,83 +0,0 @@
-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;
-    idempotencyKey?: string;
-}
-
-export interface ForklaunchRequest<
-    SV extends AnySchemaValidator,
-    P = ParamsDictionary,
-    ReqBody = unknown,
-    ReqQuery = ParsedQs,
-    Headers = IncomingHttpHeaders
-> {
-    context: Prettify<RequestContext>;
-    contractDetails: HttpContractDetails<SV> | PathParamHttpContractDetails<SV>;
-    schemaValidator: SchemaValidator;
-
-    params: P;
-    headers: Headers;
-    body: ReqBody;
-    query: ReqQuery;
-}
-
-export interface ForklaunchResponse<
-    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 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 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

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

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();
-  });
-});