@takaro/http 0.0.0-next.0da151e

package/src/middleware/paginationMiddleware.ts

@@ -0,0 +1,29 @@
+import { NextFunction, Request, Response } from 'express';
+import * as yup from 'yup';
+import { errors, logger } from '@takaro/util';
+
+const log = logger('http:pagination');
+
+const paginationSchema = yup.object({
+  page: yup.number().default(0).min(0),
+  limit: yup.number().default(100).min(1).max(1000),
+});
+
+export async function paginationMiddleware(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const merged = { ...req.query, ...req.body };
+  try {
+    const result = await paginationSchema.validate(merged);
+
+    res.locals.page = result.page;
+    res.locals.limit = result.limit;
+
+    next();
+  } catch (error) {
+    if (error instanceof yup.ValidationError) {
+      next(new errors.ValidationError('Invalid pagination', [error]));
+    } else {
+      log.error('Unexpected error', error);
+      next(new errors.InternalServerError());
+    }
+  }
+}

package/src/middleware/rateLimit.ts

@@ -0,0 +1,73 @@
+import { Request, Response, NextFunction } from 'express';
+import { Redis } from '@takaro/db';
+import { logger, errors, ctx } from '@takaro/util';
+import { RateLimiterRes, RateLimiterRedis, RateLimiterMemory } from 'rate-limiter-flexible';
+
+export interface IRateLimitMiddlewareOptions {
+  max: number;
+  windowSeconds: number;
+  keyPrefix?: string;
+  useInMemory?: boolean;
+}
+
+export async function createRateLimitMiddleware(opts: IRateLimitMiddlewareOptions) {
+  const log = logger('http:rateLimit');
+  const redis = await Redis.getClient('http:rateLimit');
+
+  // We create a randomHash to use in Redis keys
+  // This makes sure that each endpoint can get different rate limits without too much hassle
+  const randomHash = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+
+  let rateLimiter: RateLimiterMemory | RateLimiterRedis;
+
+  if (opts.useInMemory) {
+    rateLimiter = new RateLimiterMemory({
+      points: opts.max,
+      duration: opts.windowSeconds,
+      keyPrefix: `http:rateLimit:${opts.keyPrefix ? opts.keyPrefix : randomHash}`,
+    });
+  } else {
+    rateLimiter = new RateLimiterRedis({
+      points: opts.max,
+      duration: opts.windowSeconds,
+      storeClient: redis,
+      keyPrefix: `http:rateLimit:${opts.keyPrefix ? opts.keyPrefix : randomHash}`,
+    });
+  }
+
+  return async (req: Request, res: Response, next: NextFunction) => {
+    const ctxData = ctx.data;
+    let limitedKey = null;
+    if (ctxData.user) {
+      limitedKey = ctxData.user;
+    } else {
+      // TODO: should handle case ip is undefined
+      limitedKey = req.ip!;
+    }
+
+    let rateLimiterRes: RateLimiterRes | null = null;
+
+    try {
+      rateLimiterRes = await rateLimiter.consume(limitedKey);
+    } catch (err) {
+      if (err instanceof RateLimiterRes) {
+        rateLimiterRes = err;
+        log.warn(`rate limited, try again in ${err.msBeforeNext}ms`);
+      } else {
+        throw err;
+      }
+    }
+
+    if (rateLimiterRes) {
+      res.set('X-RateLimit-Limit', opts.max.toString());
+      res.set('X-RateLimit-Remaining', rateLimiterRes.remainingPoints.toString());
+      res.set('X-RateLimit-Reset', rateLimiterRes.msBeforeNext.toString());
+
+      if (rateLimiterRes.remainingPoints === 0) {
+        next(new errors.TooManyRequestsError());
+      }
+    }
+
+    return next();
+  };
+}

package/src/util/apiResponse.ts

@@ -0,0 +1,112 @@
+import { errors, isTakaroDTO, TakaroDTO } from '@takaro/util';
+import { Type } from 'class-transformer';
+import {
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  ValidateNested,
+  IsString,
+  ValidationError as ClassValidatorError,
+} from 'class-validator';
+import { Request, Response } from 'express';
+
+class ErrorOutput {
+  @IsString()
+  code?: string;
+
+  @IsString()
+  message?: string;
+
+  @IsString()
+  details?: string | ClassValidatorError[];
+}
+
+class MetadataOutput {
+  @IsString()
+  @IsISO8601()
+  serverTime!: string;
+
+  @Type(() => ErrorOutput)
+  @ValidateNested()
+  error?: ErrorOutput;
+
+  /**
+   * The page number of the response
+   */
+  @IsNumber()
+  @IsOptional()
+  page?: number;
+
+  /**
+   * The number of items returned in the response (aka page size)
+   */
+  @IsNumber()
+  @IsOptional()
+  limit?: number;
+
+  /**
+   * The total number of items in the collection
+   */
+  @IsNumber()
+  @IsOptional()
+  total?: number;
+}
+export class APIOutput<T> extends TakaroDTO<APIOutput<T>> {
+  @Type(() => MetadataOutput)
+  @ValidateNested()
+  meta!: MetadataOutput;
+
+  data!: T;
+}
+
+interface IApiResponseOptions {
+  error?: Error;
+  meta?: Record<string, string | number>;
+  req: Request;
+  res: Response;
+}
+
+export function apiResponse(data: unknown = {}, opts?: IApiResponseOptions): APIOutput<unknown> {
+  const returnVal = new APIOutput<unknown>();
+
+  returnVal.meta = new MetadataOutput();
+  returnVal.data = {};
+
+  if (opts?.error) {
+    returnVal.meta.error = new ErrorOutput();
+
+    returnVal.meta.error.code = String(opts.error.name);
+
+    if ('details' in opts.error) {
+      if (opts.error instanceof errors.ValidationError) {
+        returnVal.meta.error.details = opts.error.details as ClassValidatorError[];
+      } else {
+        returnVal.meta.error.details = opts.error.details as string;
+      }
+    }
+
+    returnVal.meta.error.message = String(opts.error.message);
+  }
+
+  if (opts?.meta) {
+    returnVal.meta.page = opts?.res.locals.page;
+    returnVal.meta.limit = opts?.res.locals.limit;
+    returnVal.meta.total = opts?.meta.total as number;
+  }
+
+  if (isTakaroDTO(data)) {
+    returnVal.data = data.toJSON();
+  } else if (Array.isArray(data)) {
+    returnVal.data = data.map((item) => {
+      if (isTakaroDTO(item)) {
+        return item.toJSON();
+      }
+
+      return item;
+    });
+  } else {
+    returnVal.data = data;
+  }
+
+  return returnVal;
+}

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}

package/typedoc.json

@@ -0,0 +1,3 @@
+{
+  "entryPoints": ["src/main.ts"]
+}