@forklaunch/core 0.1.0 → 0.1.2

package/http/middlewares/request.middleware.ts

@@ -1,15 +1,26 @@
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-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";
+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<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>
->(schemaValidator: SchemaValidator) {
-    return (req: Request, res: Response, next?: Function) => {
-        req.schemaValidator = schemaValidator;
+    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();
 
@@ -21,29 +32,34 @@ export function createRequestContext<
 
         req.context = {
             correlationId: correlationId
-        }
+        };
 
         if (next) {
             next();
         }
-    }
+    };
 }
 
 export function enrichRequestDetails<
-    SV extends SchemaValidator,
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>
+    SV extends AnySchemaValidator,
+    Request extends ForklaunchRequest<SV>,
+    Response extends ForklaunchResponse,
+    NextFunction extends ForklaunchNextFunction
 >(contractDetails: PathParamHttpContractDetails<SV> | HttpContractDetails<SV>) {
-    return (req: Request, _res: Response, next?: Function) => {
+    return (req: Request, _res: Response, next?: NextFunction) => {
         req.contractDetails = contractDetails;
 
         if (next) {
             next();
         }
-    }
+    };
 }
 
-export function preHandlerParse<SV extends SchemaValidator>(schemaValidator: SV, object: unknown, schemaInput?: StringOnlyObject<SV>) {
+export function preHandlerParse<SV extends AnySchemaValidator>(
+    schemaValidator: SchemaValidator,
+    object: unknown,
+    schemaInput?: StringOnlyObject<SV>
+) {
     if (!schemaInput) {
         return;
     }
@@ -55,33 +71,42 @@ export function preHandlerParse<SV extends SchemaValidator>(schemaValidator: SV,
 }
 
 export function parseRequestParams<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
+    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.");
+        res.status(400).send('Invalid request parameters.');
         if (next) {
-            next(new Error("Invalid request parameters."));
+            next(new Error('Invalid request parameters.'));
         }
-    };
+    }
     if (next) {
         next();
     }
 }
 
 export function parseRequestBody<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
+    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<typeof req.schemaValidator>).body;
-        if (preHandlerParse(req.body, body as StringOnlyObject<typeof req.schemaValidator>) === 400) {
-            res.status(400).send("Invalid request body.");
+        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."));
+                next(new Error('Invalid request body.'));
             }
         }
     }
@@ -91,15 +116,16 @@ export function parseRequestBody<
 }
 
 export function parseRequestHeaders<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
+    SV extends AnySchemaValidator,
+    Request extends ForklaunchRequest<SV>,
+    Response extends ForklaunchResponse,
     NextFunction extends ForklaunchNextFunction
-> (req: Request, res: Response, next?: NextFunction) {
+>(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.");
+        res.status(400).send('Invalid request headers.');
         if (next) {
-            next(new Error("Invalid request headers."));
+            next(new Error('Invalid request headers.'));
         }
     }
     if (next) {
@@ -108,15 +134,16 @@ export function parseRequestHeaders<
 }
 
 export function parseRequestQuery<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
+    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.query, query) === 400) {
-        res.status(400).send("Invalid request query.");
+    if (preHandlerParse(req.schemaValidator, req.query, query) === 400) {
+        res.status(400).send('Invalid request query.');
         if (next) {
-            next(new Error("Invalid request query."));
+            next(new Error('Invalid request query.'));
         }
     }
     if (next) {
@@ -124,43 +151,61 @@ export function parseRequestQuery<
     }
 }
 
-async function checkAuthorizationToken(authorizationMethod?: AuthMethod, authorizationString?: string): Promise<[number, string] | string | undefined> {
+async function checkAuthorizationToken(
+    authorizationMethod?: AuthMethod,
+    authorizationString?: string
+): Promise<[401 | 403, string] | string | undefined> {
     if (!authorizationString) {
-        return [401, "No Authorization token provided."];
+        return [401, 'No Authorization token provided.'];
     }
     switch (authorizationMethod) {
         case 'jwt': {
             if (!authorizationString.startsWith('Bearer ')) {
-                return [401, "Invalid Authorization token format."];
+                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'));
+                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) {
+            } catch (error) {
                 console.error(error);
-                return [403, "Invalid Authorization token."];
+                return [403, 'Invalid Authorization token.'];
             }
         }
         default:
-            return [401, "Invalid Authorization method."];
+            return [401, 'Invalid Authorization method.'];
     }
 }
 
-function mapRoles(authorizationType?: AuthMethod, authorizationToken?: string): string[] {
+function mapRoles(
+    authorizationType?: AuthMethod,
+    authorizationToken?: string
+): string[] {
     return [];
 }
-function mapPermissions(authorizationType?: AuthMethod, authorizationToken?: string): string[] {
+function mapPermissions(
+    authorizationType?: AuthMethod,
+    authorizationToken?: string
+): string[] {
     return [];
 }
 
 export async function parseRequestAuth<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
+    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);
+        const errorAndMessage = await checkAuthorizationToken(
+            auth.method,
+            req.headers.authorization
+        );
         if (Array.isArray(errorAndMessage)) {
             res.status(errorAndMessage[0]).send(errorAndMessage[1]);
             if (next) {
@@ -169,33 +214,44 @@ export async function parseRequestAuth<
         }
 
         // TODO: Implement role and permission checking
-        const permissionSlugs  = mapPermissions(auth.method, req.headers.authorization);
+        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.";
+        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)) {
+        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)) {
+        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,37 +1,63 @@
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-import { ForklaunchNextFunction, ForklaunchRequest, ForklaunchResponse } from "../types/api.types";
-import { HttpContractDetails } from "../types/primitive.types";
+import { AnySchemaValidator } from '@forklaunch/validator';
+import {
+  ForklaunchNextFunction,
+  ForklaunchRequest,
+  ForklaunchResponse
+} from '../types/api.types';
+import { HttpContractDetails } from '../types/primitive.types';
 
-function checkAnyValidation<SV extends SchemaValidator>(contractDetails: HttpContractDetails<SV>) {
-    return contractDetails.body || contractDetails.params || contractDetails.requestHeaders || contractDetails.query;
+function checkAnyValidation<SV extends AnySchemaValidator>(
+  contractDetails: HttpContractDetails<SV>
+) {
+  return (
+    contractDetails.body ||
+    contractDetails.params ||
+    contractDetails.requestHeaders ||
+    contractDetails.query
+  );
 }
 
 export function parseResponse<
-    Request extends ForklaunchRequest<any, any, any, any>,
-    Response extends ForklaunchResponse<any, any>, 
-    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))
-    ) {
-        return;
-    }
-    if (!req.contractDetails.responses.hasOwnProperty(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);
+  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();
+      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,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;