@e22m4u/ts-rest-router 0.0.2

package/src/decorators/request-data/request-data-reflector.ts

@@ -0,0 +1,57 @@
+import {Constructor} from '../../types.js';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {RequestDataMetadata} from './request-data-metadata.js';
+import {RequestDataMetadataMap} from './request-data-metadata.js';
+import {REQUEST_DATA_METADATA_KEY} from './request-data-metadata.js';
+
+/**
+ * Request data reflector.
+ */
+export class RequestDataReflector {
+  /**
+   * Set metadata.
+   *
+   * @param metadata
+   * @param target
+   * @param index
+   * @param propertyKey
+   */
+  static setMetadata(
+    metadata: RequestDataMetadata,
+    target: Constructor,
+    index: number,
+    propertyKey: string,
+  ) {
+    const oldMap = Reflector.getOwnMetadata(
+      REQUEST_DATA_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    const newMap = new Map(oldMap);
+    newMap.set(index, metadata);
+    Reflector.defineMetadata(
+      REQUEST_DATA_METADATA_KEY,
+      newMap,
+      target,
+      propertyKey,
+    );
+  }
+
+  /**
+   * Get metadata.
+   *
+   * @param target
+   * @param propertyKey
+   */
+  static getMetadata(
+    target: Constructor,
+    propertyKey: string,
+  ): RequestDataMetadataMap {
+    const metadata = Reflector.getOwnMetadata(
+      REQUEST_DATA_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    return metadata ?? new Map();
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1 @@
+export * from './not-a-controller-error.js';

package/src/errors/not-a-controller-error.ts

@@ -0,0 +1,15 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Not a controller error.
+ */
+export class NotAControllerError extends Errorf {
+  /**
+   * Constructor.
+   *
+   * @param value
+   */
+  constructor(value: unknown) {
+    super('%v is not a controller, do use @controller decorator on it.', value);
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './utils/index.js';
+export * from './rest-router.js';
+export * from './errors/index.js';
+export * from './decorators/index.js';
+export * from './controller-registry.js';

package/src/rest-router.ts

@@ -0,0 +1,31 @@
+import {Constructor} from './types.js';
+import {TrieRouter} from '@e22m4u/js-trie-router';
+import {DebuggableService} from './debuggable-service.js';
+import {ControllerRegistry} from './controller-registry.js';
+import {ControllerRootOptions} from './controller-registry.js';
+
+/**
+ * Rest router.
+ */
+export class RestRouter extends DebuggableService {
+  /**
+   * Request listener.
+   */
+  get requestListener() {
+    return this.getService(TrieRouter).requestListener;
+  }
+
+  /**
+   * Add controller.
+   *
+   * @param ctor
+   * @param options
+   */
+  addController<T extends object>(
+    ctor: Constructor<T>,
+    options?: ControllerRootOptions,
+  ): this {
+    this.getService(ControllerRegistry).addController(ctor, options);
+    return this;
+  }
+}

package/src/types.ts

@@ -0,0 +1,59 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */
+
+/**
+ * Function type that excludes
+ * class and constructor types.
+ */
+export type Callable<T = unknown> = (...args: any[]) => T;
+
+/**
+ * Callable type with the "new" operator
+ * that allows class and constructor types.
+ */
+export interface Constructor<T = unknown> {
+  new (...args: any[]): T;
+}
+
+/**
+ * Object prototype that excludes
+ * function and scalar values.
+ */
+export type Prototype<T = unknown> = T &
+  object & {bind?: never} & {call?: never} & {prototype?: object};
+
+/**
+ * Make a specific property as optional.
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * A part of the Flatten type.
+ */
+export type Identity<T> = T;
+
+/**
+ * Makes T more human-readable.
+ */
+export type Flatten<T> = Identity<{[k in keyof T]: T[k]}>;
+
+/**
+ * A promise or value.
+ */
+export type ValueOrPromise<T> = T | PromiseLike<T>;
+
+/**
+ * Plain object.
+ */
+export type PlainObject = {[key: string]: unknown};
+
+/**
+ * Remove null and undefined from T.
+ */
+export type NoUndef<T> = Exclude<T, null | undefined>;
+
+/**
+ * Object type with open properties.
+ */
+export type AnyObject = {
+  [property: PropertyKey]: any;
+};

package/src/utils/capitalize.spec.ts

@@ -0,0 +1,9 @@
+import {expect} from 'chai';
+import {capitalize} from './capitalize.js';
+
+describe('capitalize', function () {
+  it('makes the first letter to upper case', function () {
+    expect(capitalize('foo')).to.be.eq('Foo');
+    expect(capitalize('foo bar')).to.be.eq('Foo bar');
+  });
+});

package/src/utils/capitalize.ts

@@ -0,0 +1,8 @@
+/**
+ * Capitalize.
+ *
+ * @param input
+ */
+export function capitalize(input: string): string {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}

package/src/utils/create-debugger.spec.ts

@@ -0,0 +1,9 @@
+import {expect} from 'chai';
+import {createDebugger} from './create-debugger.js';
+
+describe('createDebugger', function () {
+  it('returns a function', function () {
+    const res = createDebugger('name');
+    expect(typeof res).to.be.eq('function');
+  });
+});

package/src/utils/create-debugger.ts

@@ -0,0 +1,21 @@
+import DebugFactory from 'debug';
+import {format} from '@e22m4u/js-format';
+
+/**
+ * Debugger.
+ */
+export type Debugger = (...args: Parameters<typeof format>) => void;
+
+/**
+ * Create debugger.
+ *
+ * @param name
+ */
+export function createDebugger(name: string): Debugger {
+  const debug = DebugFactory(`tsRestRouter:${name}`);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function (message: string, ...args: any[]) {
+    const interpolatedMessage = format(message, ...args);
+    return debug(interpolatedMessage);
+  };
+}

package/src/utils/create-error.spec.ts

@@ -0,0 +1,9 @@
+import {expect} from 'chai';
+import {createError} from './create-error.js';
+
+describe('createError', function () {
+  it('interpolates the given message with arguments', function () {
+    const res = createError(Error, 'My %s', 'message');
+    expect(res.message).to.be.eq('My message');
+  });
+});

package/src/utils/create-error.ts

@@ -0,0 +1,19 @@
+import {Constructor} from '../types.js';
+import {format} from '@e22m4u/js-format';
+
+/**
+ * Create error.
+ *
+ * @param {Function} errorCtor
+ * @param {string} message
+ * @param {*[]|undefined} args
+ * @returns {object}
+ */
+export function createError<T>(
+  errorCtor: Constructor<T>,
+  message: string,
+  ...args: unknown[]
+): T {
+  const interpolatedMessage = format(message, ...args);
+  return new errorCtor(interpolatedMessage);
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './capitalize.js';
+export * from './create-error.js';
+export * from './to-camel-case.js';
+export * from './create-debugger.js';

package/src/utils/to-camel-case.spec.ts

@@ -0,0 +1,11 @@
+import {expect} from 'chai';
+import {toCamelCase} from './to-camel-case.js';
+
+describe('toCamelCase', function () {
+  it('returns a camelCase string', function () {
+    expect(toCamelCase('TestString')).to.be.eq('testString');
+    expect(toCamelCase('test-string')).to.be.eq('testString');
+    expect(toCamelCase('test string')).to.be.eq('testString');
+    expect(toCamelCase('Test string')).to.be.eq('testString');
+  });
+});

package/src/utils/to-camel-case.ts

@@ -0,0 +1,11 @@
+/**
+ * To camel case.
+ *
+ * @param input
+ */
+export function toCamelCase(input: string): string {
+  return input
+    .replace(/(^\w|[A-Z]|\b\w)/g, c => c.toUpperCase())
+    .replace(/\W+/g, '')
+    .replace(/(^\w)/g, c => c.toLowerCase());
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist/esm",
+    "target": "es2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true
+  }
+}