@forklaunch/core 0.1.1 → 0.1.2

package/entityMapper/models/responseEntityMapper.model.ts

@@ -1,8 +1,7 @@
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-import { BaseEntity } from "../../database/mikro/models/entities/base.entity";
-import { EntityMapperConstructor } from "../interfaces/entityMapper.interface";
-import { EntityMapperStaticSchema } from "../types/entityMapper.types";
-import { BaseEntityMapper, construct } from "./baseEntityMapper.model";
+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.
@@ -11,67 +10,89 @@ import { BaseEntityMapper, construct } from "./baseEntityMapper.model";
  * @template SV - A type that extends SchemaValidator.
  * @extends {BaseEntityMapper<SV>}
  */
-export abstract class ResponseEntityMapper<Entity extends BaseEntity | unknown, SV extends SchemaValidator> extends BaseEntityMapper<SV> {
-    /**
-     * The entity type.
-     * @type {Entity}
-     * @protected
-     */
-    _Entity!: Entity;
+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;
+  /**
+   * 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;
+  /**
+   * 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();
-    }
+  /**
+   * 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 EntityMapperType - A type that extends ResponseEntityMapper.
-     * @param {EntityMapperConstructor<EntityMapperType>} this - The constructor of the EntityMapperType.
-     * @param {EntityMapperType['_Entity']} entity - The entity to convert.
-     * @returns {EntityMapperType} - An instance of the EntityMapperType.
-     */
-    static fromEntity<EntityMapperType extends ResponseEntityMapper<unknown, any>>(this: EntityMapperConstructor<EntityMapperType, EntityMapperType['_SV']>, schemaValidator: EntityMapperType['_SV'], entity: EntityMapperType['_Entity']): EntityMapperType {
-        return construct(this, schemaValidator).fromEntity(entity);
-    }
+  /**
+   * 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 EntityMapperType - A type that extends ResponseEntityMapper.
-     * @param {EntityMapperConstructor<EntityMapperType>} this - The constructor of the EntityMapperType.
-     * @param {EntityMapperType['_Entity']} entity - The entity to serialize.
-     * @returns {EntityMapperStaticSchema<EntityMapperType>} - The JSON object.
-     */
-    static serializeEntityToJson<EntityMapperType extends ResponseEntityMapper<unknown, any>>(this: EntityMapperConstructor<EntityMapperType, EntityMapperType['_SV']>, schemaValidator: EntityMapperType['_SV'], entity: EntityMapperType['_Entity']): EntityMapperStaticSchema<EntityMapperType> {
-        return construct(this, schemaValidator).serializeEntityToJson(entity) as EntityMapperStaticSchema<EntityMapperType>;
-    }
+  /**
+   * 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,29 +1,12 @@
-import { Schema, SchemaCatchall, ValidSchemaObject } from "@forklaunch/validator/";
-import { SchemaValidator } from "@forklaunch/validator/interfaces";
-import { UnboxedObjectSchema } from "@forklaunch/validator/types";
-import { BaseEntityMapper } from "../models/baseEntityMapper.model";
+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 SchemaValidator> = ValidSchemaObject<SV> | UnboxedObjectSchema<SchemaCatchall<SV>>;
-
-/**
- * Type representing the static schema of an entity mapper.
- * 
- * @template T - A type that extends BaseEntityMapper with a schema property.
- * @typedef {Schema<T['schema'], T['_SV']> & {}} EntityMapperStaticSchema
- */
-export type EntityMapperStaticSchema<T extends BaseEntityMapper<any> & { schema: any }> = Schema<T['schema'], T['_SV']>;
-
-/**
- * Type representing the schema of an entity mapper.
- * 
- * @template T - A type that extends ValidSchemaObject or UnboxedObjectSchema with SchemaCatchall.
- * @template SV - A type that extends SchemaValidator.
- * @typedef {Schema<T, SV> & {}} EntityMapperSchema
- */
-export type EntityMapperSchema<T extends ValidSchemaObject<SV> | UnboxedObjectSchema<SchemaCatchall<SV>>, SV extends SchemaValidator> = Schema<T, SV>;
+export type EntityMapperSchemaValidatorObject<SV extends AnySchemaValidator> =
+  | SV['_ValidSchemaObject']
+  | UnboxedObjectSchema<SV>;

package/http/index.ts

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

package/http/middlewares/index.ts

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

package/http/middlewares/request.middleware.ts

@@ -1,17 +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<
-    SV extends 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;
+        req.schemaValidator = schemaValidator as SchemaValidator;
 
         let correlationId = v4();
 
@@ -23,16 +32,16 @@ export function createRequestContext<
 
         req.context = {
             correlationId: correlationId
-        }
+        };
 
         if (next) {
             next();
         }
-    }
+    };
 }
 
 export function enrichRequestDetails<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
     Response extends ForklaunchResponse,
     NextFunction extends ForklaunchNextFunction
@@ -43,10 +52,14 @@ export function enrichRequestDetails<
         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;
     }
@@ -58,35 +71,42 @@ export function preHandlerParse<SV extends SchemaValidator>(schemaValidator: SV,
 }
 
 export function parseRequestParams<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse, 
+    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<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse, 
+    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.'));
             }
         }
     }
@@ -96,16 +116,16 @@ export function parseRequestBody<
 }
 
 export function parseRequestHeaders<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse, 
+    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) {
@@ -114,16 +134,16 @@ export function parseRequestHeaders<
 }
 
 export function parseRequestQuery<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse, 
+    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.");
+        res.status(400).send('Invalid request query.');
         if (next) {
-            next(new Error("Invalid request query."));
+            next(new Error('Invalid request query.'));
         }
     }
     if (next) {
@@ -131,44 +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<
-    SV extends SchemaValidator,
+    SV extends AnySchemaValidator,
     Request extends ForklaunchRequest<SV>,
-    Response extends ForklaunchResponse, 
+    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) {
@@ -177,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,38 +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<
-    SV extends SchemaValidator,
-    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))
-    ) {
-        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);
+  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();
+  }
+}