@nr1e/commons 0.1.0-alpha.1 → 0.1.1-alpha.0

package/src/bitsnbytes/b64.mts

@@ -0,0 +1,158 @@
+import {IllegalArgumentError} from '../errors/errors.mjs';
+
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const encoder = new TextEncoder();
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const decoder = new TextDecoder();
+
+export const BASE64_CHARS: Uint8Array = new Uint8Array([
+  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f, 0x3d,
+]);
+// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='
+
+export const URL_MODIFIED_BASE64_CHARS: Uint8Array = new Uint8Array([
+  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2d, 0x5f,
+]);
+// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
+
+export const YUI_BASE64_CHARS: Uint8Array = new Uint8Array([
+  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2e, 0x5f, 0x2d,
+]);
+// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '_', '-'
+
+export type Base64CharSet = 'b64' | 'url' | 'yui';
+
+export interface Base64Options {
+  readonly fromIndex?: number;
+  readonly toIndex?: number;
+  readonly b64chars?: Uint8Array | Base64CharSet;
+}
+
+/**
+ * Returns a base64 character set and validates one if passed in.
+ *
+ * @param b64chars a base64 character set
+ */
+export function b64Charset(b64chars?: Uint8Array | Base64CharSet): Uint8Array {
+  if (b64chars === undefined || b64chars === null) {
+    return BASE64_CHARS;
+  }
+  if (b64chars instanceof Uint8Array) {
+    if (b64chars.length !== 65 && b64chars.length !== 64) {
+      throw new IllegalArgumentError(
+        'b64chars',
+        'Base 64 character sets must be 64 or 65 characters.'
+      );
+    }
+    return b64chars;
+  }
+  switch (b64chars) {
+    case 'b64':
+      return BASE64_CHARS;
+    case 'url':
+      return URL_MODIFIED_BASE64_CHARS;
+    case 'yui':
+      return YUI_BASE64_CHARS;
+    default:
+      throw new IllegalArgumentError(
+        'b64chars',
+        `Invalid base64 character set '${b64chars}'`
+      );
+  }
+}
+
+/**
+ * Base64 encodes a series of bytes.
+ *
+ * @param buf Bytes to encode
+ * @param opts Encoding options
+ * @return a base64 string
+ */
+export function tob64(buf: Uint8Array, opts?: Base64Options): Uint8Array {
+  const b64chars = b64Charset(opts?.b64chars);
+  const toIndex = opts?.toIndex ?? buf.length;
+  const fromIndex = opts?.fromIndex ?? 0;
+  // every 3 bytes is 4 characters in padded base64 (6 bits per char)
+  const num = toIndex - fromIndex;
+  const numc =
+    b64chars.length === 65
+      ? ((num + 2 - ((num + 2) % 3)) / 3) * 4 // padded
+      : (num * 8) / 6 + ((num * 8) % 6 !== 0 ? 1 : 0); // not padded
+  const b64 = new Uint8Array(numc);
+  let n = 0;
+  for (let i = 0; i < toIndex; i += 3) {
+    const v =
+      ((buf[i] & 0xff) << 16) |
+      (i + 1 < toIndex ? (buf[i + 1] & 0xff) << 8 : 0) |
+      (i + 2 < toIndex ? buf[i + 2] & 0xff : 0);
+    b64[n++] = b64chars[(v >>> 18) & 0x3f];
+    b64[n++] = b64chars[(v >>> 12) & 0x3f];
+    switch (
+      toIndex - i // calculate bytes remaining to be processed
+    ) {
+      case 1: // 0 bytes left to process
+        if (b64chars.length === 65) {
+          b64[n++] = b64chars[64];
+          b64[n++] = b64chars[64];
+        }
+        break;
+      case 2: // 1 byte left to process
+        b64[n++] = b64chars[(v >>> 6) & 0x3f];
+        if (b64chars.length === 65) {
+          b64[n++] = b64chars[64];
+        }
+        break;
+      default:
+        b64[n++] = b64chars[(v >>> 6) & 0x3f];
+        b64[n++] = b64chars[v & 0x3f];
+        break;
+    }
+  }
+  return b64;
+}
+
+/**
+ * Base64 encodes a series of bytes to a string.
+ *
+ * @param buf Bytes to encode
+ * @param opts Encoding options
+ * @return a base64 string
+ */
+export function tob64s(buf: Uint8Array, opts?: Base64Options): string {
+  return decoder.decode(tob64(buf, opts));
+}
+
+/**
+ * Base64 encodes a string to a string.
+ *
+ * @param str String to encode
+ * @param opts Encoding options
+ * @return a base64 string
+ */
+export function stob64s(str: string, opts?: Base64Options): string {
+  return tob64s(encoder.encode(str), opts);
+}

package/src/bitsnbytes/b64.test.mts

@@ -0,0 +1,78 @@
+import {test, expect} from 'vitest';
+import {stob64s, tob64s} from './b64.mjs';
+import * as crypto from 'crypto';
+
+test('Test tob64', () => {
+  const str = '"Computer, compute to the last digit the value of pi" -- Spock';
+  let b64s = [
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s=',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw==',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A=',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw==',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0=',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ==',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI=',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ==',
+  ];
+  for (let i = 0; i < b64s.length; i++) {
+    expect(b64s[i]).toBe(stob64s(str.substring(0, str.length - i)));
+  }
+
+  // Test URL modified base64 encoding
+  b64s = [
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ',
+  ];
+  for (let i = 0; i < b64s.length; i++) {
+    expect(b64s[i]).toBe(
+      stob64s(str.substring(0, str.length - i), {b64chars: 'url'})
+    );
+  }
+
+  // Test YUI modified base64 encoding
+  b64s = [
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s-',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw--',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A-',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw--',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0-',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ--',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI-',
+    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ--',
+  ];
+  for (let i = 0; i < b64s.length; i++) {
+    expect(b64s[i]).toBe(
+      stob64s(str.substring(0, str.length - i), {b64chars: 'yui'})
+    );
+  }
+});
+
+test('Compare to Node', () => {
+  for (let i = 0; i < 100; i++) {
+    const bytes = crypto.randomBytes(16);
+    const str = tob64s(bytes, {b64chars: 'url'});
+    const nodeStr = bytes.toString('base64url');
+    expect(str).toEqual(nodeStr);
+  }
+  for (let i = 0; i < 100; i++) {
+    const bytes = crypto.randomBytes(16);
+    const str = tob64s(bytes, {b64chars: 'b64'});
+    const nodeStr = bytes.toString('base64');
+    expect(str).toEqual(nodeStr);
+  }
+});

package/src/bitsnbytes/index.mts

@@ -0,0 +1 @@
+export * from './b64.mjs';

package/src/errors/errors.mts

@@ -0,0 +1,271 @@
+import {HttpStatusCode} from '../http/index.mjs';
+import {isError, isObject} from '../lang/index.mjs';
+
+/**
+ * An extended version of Error that includes an HttpStatusCode.
+ * This can be useful in middleware error handlers to determine http status codes to return to the client.
+ */
+export interface HttpError extends Error {
+  /**
+   * The HTTP status code.
+   */
+  statusCode: HttpStatusCode | number;
+}
+
+/**
+ * Checks if the given parameter is an HttpError.
+ *
+ * @param e The parameter to check
+ */
+export function isHttpError(e?: unknown): e is HttpError {
+  return isObject(e) && !!(e && e.stack && e.statusCode && e.message && e.name);
+}
+
+/**
+ * Thrown when a resource cannot be found.
+ */
+export class NotFoundError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.NOT_FOUND;
+  /**
+   * The max-age value to set in the Cache-Control header if used in a middleware.
+   */
+  readonly maxAge?: number;
+  constructor(message?: string, maxAge?: number) {
+    message = message ?? 'Not found';
+    super(message);
+    this.name = 'NotFoundError';
+    this.maxAge = maxAge;
+  }
+}
+
+/**
+ * Checks if the given parameter is a NotFoundError.
+ *
+ * @param e The parameter to check
+ */
+export function isNotFoundError(e?: unknown): e is NotFoundError {
+  return isHttpError(e) && e.name === 'NotFoundError';
+}
+
+/**
+ * Thrown when a request is missing authentication credentials.
+ */
+export class UnauthorizedError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.UNAUTHORIZED;
+  constructor(message?: string) {
+    message = message ?? 'Unauthorized';
+    super(message);
+    this.name = 'UnauthorizedError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a UnauthorizedError.
+ *
+ * @param e The parameter to check
+ */
+export function isUnauthorizedError(e?: unknown): e is UnauthorizedError {
+  return isHttpError(e) && e.name === 'UnauthorizedError';
+}
+
+/**
+ * Thrown when credentials are present, but the requested operations is not allowed.
+ */
+export class ForbiddenError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.FORBIDDEN;
+  constructor(message?: string) {
+    message = message ?? 'Forbidden';
+    super(message);
+    this.name = 'ForbiddenError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a ForbiddenError.
+ *
+ * @param e The parameter to check
+ */
+export function isForbiddenError(e?: unknown): e is ForbiddenError {
+  return isHttpError(e) && e.name === 'ForbiddenError';
+}
+
+/**
+ * Thrown when a validation error occurs.
+ */
+export class ValidationError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.BAD_REQUEST;
+  constructor(message?: string) {
+    message = message ?? 'Validation error';
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Checks if the given variable is a ValidationError.
+ *
+ * @param e The variable to check
+ */
+export function isValidationError(e?: unknown): e is ValidationError {
+  return isHttpError(e) && e.name === 'ValidationError';
+}
+
+/**
+ * Thrown when a bad request is made.
+ */
+export class BadRequestError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.BAD_REQUEST;
+  constructor(message?: string) {
+    message = message ?? 'Bad request';
+    super(message ?? 'Bad request');
+    this.name = 'BadRequestError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a BadRequestError.
+ *
+ * @param e The parameter to check
+ */
+export function isBadRequestError(e?: unknown): e is BadRequestError {
+  return isHttpError(e) && e.name === 'BadRequestError';
+}
+
+/**
+ * Throws when an internal server error occurs.
+ */
+export class InternalServerError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.INTERNAL_SERVER_ERROR;
+  constructor(message?: string) {
+    message = message ?? 'Internal server error';
+    super(message);
+    this.name = 'InternalServerError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a InternalServerError.
+ *
+ * @param e The parameter to check
+ */
+export function isInternalServerError(e?: unknown): e is InternalServerError {
+  return isHttpError(e) && e.name === 'InternalServerError';
+}
+
+/**
+ * Thrown when a conflict occurs.
+ */
+export class ConflictError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.CONFLICT;
+  constructor(message?: string) {
+    message = message ?? 'Conflict';
+    super(message);
+    this.name = 'ConflictError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a ConflictError.
+ *
+ * @param e The parameter to check
+ */
+export function isConflictError(e?: unknown): e is ConflictError {
+  return isHttpError(e) && e.name === 'ConflictError';
+}
+
+/**
+ * Thrown when a unsupported media type is used.
+ */
+export class UnsupportedMediaTypeError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.UNSUPPORTED_MEDIA_TYPE;
+  constructor(message?: string) {
+    message = message ?? 'Unsupported media type';
+    super(message);
+    this.name = 'UnsupportedMediaTypeError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a UnsupportedMediaTypeError.
+ *
+ * @param e The parameter to check
+ */
+export function isUnsupportedMediaTypeError(
+  e?: unknown
+): e is UnsupportedMediaTypeError {
+  return isHttpError(e) && e.name === 'UnsupportedMediaTypeError';
+}
+
+/**
+ * Thrown when a requested operation is not implemented.
+ */
+export class NotImplementedError extends Error implements HttpError {
+  readonly statusCode = HttpStatusCode.NOT_IMPLEMENTED;
+  readonly expose = true;
+  constructor(message?: string) {
+    message = message ?? 'Not implemented';
+    super(message);
+    this.name = 'NotImplementedError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a NotImplementedError.
+ *
+ * @param e The parameter to check
+ */
+export function isNotImplementedError(e?: unknown): e is NotImplementedError {
+  return isHttpError(e) && e.name === 'NotImplementedError';
+}
+
+/**
+ * Thrown when an illegal argument is passed to a function.
+ */
+export class IllegalArgumentError extends Error {
+  readonly argName: string;
+  constructor(argName: string, message?: string) {
+    message = message ?? `Illegal argument ${argName}`;
+    super(message);
+    this.argName = argName;
+    this.name = 'IllegalArgumentError';
+  }
+}
+
+/**
+ * Checks if the given parameter is a IllegalArgumentError.
+ *
+ * @param e The parameter to check
+ */
+export function isIllegalArgumentError(e?: unknown): e is IllegalArgumentError {
+  return isError(e) && e.name === 'IllegalArgumentError';
+}
+
+/**
+ * Converts the given parameter to an HttpError.
+ *
+ * @param code The HTTP status code
+ * @param message The error message
+ */
+export function toError(
+  code: number | HttpStatusCode,
+  message?: string
+): Error {
+  switch (code) {
+    case HttpStatusCode.NOT_FOUND:
+      return new NotFoundError(message);
+    case HttpStatusCode.FORBIDDEN:
+      return new ForbiddenError(message);
+    case HttpStatusCode.BAD_REQUEST:
+      return new BadRequestError(message);
+    case HttpStatusCode.INTERNAL_SERVER_ERROR:
+      return new InternalServerError(message);
+    case HttpStatusCode.CONFLICT:
+      return new ConflictError(message);
+    case HttpStatusCode.UNSUPPORTED_MEDIA_TYPE:
+      return new UnsupportedMediaTypeError(message);
+    case HttpStatusCode.NOT_IMPLEMENTED:
+      return new NotImplementedError(message);
+    default:
+      return new Error(message);
+  }
+}

package/src/errors/errors.test.mts

@@ -0,0 +1,74 @@
+import {test, expect} from 'vitest';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalServerError,
+  isBadRequestError,
+  isForbiddenError,
+  isInternalServerError,
+  isNotFoundError,
+  isValidationError,
+  NotFoundError,
+  toError,
+  ValidationError,
+} from './errors.mjs';
+import {HttpStatusCode} from '../http/index.mjs';
+
+test('Test isNotFoundError', () => {
+  expect(isNotFoundError(undefined)).toBeFalsy();
+  expect(isNotFoundError(null)).toBeFalsy();
+  expect(isNotFoundError({})).toBeFalsy();
+  expect(isNotFoundError(new ForbiddenError('just a test'))).toBeFalsy();
+  expect(isNotFoundError(new NotFoundError('just a test'))).toBeTruthy();
+});
+
+test('Test isForbiddenError', () => {
+  expect(isForbiddenError(undefined)).toBeFalsy();
+  expect(isForbiddenError(null)).toBeFalsy();
+  expect(isForbiddenError({})).toBeFalsy();
+  expect(isForbiddenError(new NotFoundError('just a test'))).toBeFalsy();
+  expect(isForbiddenError(new ForbiddenError('just a test'))).toBeTruthy();
+});
+
+test('Test isValidationError', () => {
+  expect(isValidationError(undefined)).toBeFalsy();
+  expect(isValidationError(null)).toBeFalsy();
+  expect(isValidationError({})).toBeFalsy();
+  expect(isValidationError(new NotFoundError('just a test'))).toBeFalsy();
+  expect(isValidationError(new ValidationError('just a test'))).toBeTruthy();
+});
+
+test('Test isBadRequestError', () => {
+  expect(isBadRequestError(undefined)).toBeFalsy();
+  expect(isBadRequestError(null)).toBeFalsy();
+  expect(isBadRequestError({})).toBeFalsy();
+  expect(isBadRequestError(new NotFoundError('just a test'))).toBeFalsy();
+  expect(isBadRequestError(new BadRequestError('just a test'))).toBeTruthy();
+});
+
+test('Test isInternalServerError', () => {
+  expect(isInternalServerError(undefined)).toBeFalsy();
+  expect(isInternalServerError(null)).toBeFalsy();
+  expect(isInternalServerError({})).toBeFalsy();
+  expect(isInternalServerError(new NotFoundError('just a test'))).toBeFalsy();
+  expect(
+    isInternalServerError(new InternalServerError('just a test'))
+  ).toBeTruthy();
+});
+
+test('Test toError', () => {
+  expect(
+    isNotFoundError(toError(HttpStatusCode.NOT_FOUND, 'some message'))
+  ).toBeTruthy();
+  expect(
+    isForbiddenError(toError(HttpStatusCode.FORBIDDEN, 'some message'))
+  ).toBeTruthy();
+  expect(
+    isBadRequestError(toError(HttpStatusCode.BAD_REQUEST, 'some message'))
+  ).toBeTruthy();
+  expect(
+    isInternalServerError(
+      toError(HttpStatusCode.INTERNAL_SERVER_ERROR, 'some message')
+    )
+  ).toBeTruthy();
+});

package/src/errors/index.mts

@@ -0,0 +1 @@
+export * from './errors.mjs';

package/src/http/http-method.mts

@@ -0,0 +1,9 @@
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+  HEAD = 'HEAD',
+  OPTIONS = 'OPTIONS',
+}

package/src/http/http-status-code.mts

@@ -0,0 +1,42 @@
+export enum HttpStatusCode {
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  MULTIPLE_CHOICES = 300,
+  PERMANENT_REDIRECT = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  USE_PROXY = 305,
+  TEMPORARY_REDIRECT = 307,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  REQUEST_ENTITY_TOO_LARGE = 413,
+  REQUEST_URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+}

package/src/http/index.mts

@@ -0,0 +1,2 @@
+export * from './http-status-code.mjs';
+export * from './http-method.mjs';

package/src/lang/index.mts

@@ -0,0 +1,2 @@
+export * from './type-functions.mjs';
+export * from './sleep.mjs';

package/src/lang/sleep.mts

@@ -0,0 +1,8 @@
+/**
+ * Sleep for a given amount of time
+ *
+ * @param ms the number of milliseconds to sleep
+ */
+export function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/lang/type-functions.mts

@@ -0,0 +1,13 @@
+export function isObject(item: unknown): item is Record<string, unknown> {
+  return (
+    item !== null && typeof item === 'object' && Array.isArray(item) === false
+  );
+}
+
+export function isString(item: unknown): item is string {
+  return typeof item === 'string';
+}
+
+export function isError(item: unknown): item is Error {
+  return item instanceof Error;
+}