@e22m4u/js-http-static-router 0.1.2 → 0.2.1

package/src/static-route.js

@@ -56,7 +56,7 @@ export class StaticRoute {
     }
     if (!routeDef.remotePath.startsWith('/')) {
       throw new InvalidArgumentError(
-        'Option "remotePath" must starts with "/", but %v was given.',
+        'Option "remotePath" must start with "/", but %v was given.',
         routeDef.remotePath,
       );
     }
@@ -67,24 +67,34 @@ export class StaticRoute {
         routeDef.resourcePath,
       );
     }
-    const resourcePath = path.resolve(routeDef.resourcePath);
+    if (!path.isAbsolute(routeDef.resourcePath)) {
+      throw new InvalidArgumentError(
+        'Option "resourcePath" must be an absolute path, but %v was given.',
+        routeDef.resourcePath,
+      );
+    }
     let stats;
     try {
-      stats = fs.statSync(resourcePath);
+      stats = fs.statSync(routeDef.resourcePath);
     } catch (error) {
       console.error(error);
       throw new InvalidArgumentError(
         'Resource path %v does not exist.',
-        resourcePath,
+        routeDef.resourcePath,
       );
     }
     const isFile = stats.isFile();
     const escapedRemotePath = escapeRegexp(routeDef.remotePath);
-    const regexp = isFile
-      ? new RegExp(`^${escapedRemotePath}$`)
-      : new RegExp(`^${escapedRemotePath}(?:$|\\/)`);
+    let regexp;
+    if (isFile) {
+      regexp = new RegExp(`^${escapedRemotePath}$`);
+    } else if (escapedRemotePath === '/') {
+      regexp = new RegExp(`^(?:$|\\/)`);
+    } else {
+      regexp = new RegExp(`^${escapedRemotePath}(?:$|\\/)`);
+    }
     this.remotePath = routeDef.remotePath;
-    this.resourcePath = resourcePath;
+    this.resourcePath = routeDef.resourcePath;
     this.regexp = regexp;
     this.isFile = isFile;
   }

package/src/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A callable type with the "new" operator
+ * allows class and constructor.
+ */
+export interface Constructor<T = unknown> {
+  new (...args: any[]): T;
+}

package/src/utils/create-cookie-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create cookie string.
+ *
+ * @param data
+ */
+export declare function createCookieString(data: object): string;

package/src/utils/create-cookie-string.js

@@ -0,0 +1,28 @@
+import {InvalidArgumentError} from '@e22m4u/js-format';
+
+/**
+ * Create cookie string.
+ *
+ * @param {object} data
+ * @returns {string}
+ */
+export function createCookieString(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new InvalidArgumentError(
+      'Cookie data must be an Object, but %v was given.',
+      data,
+    );
+  }
+  let cookies = '';
+  for (const key in data) {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      continue;
+    }
+    const val = data[key];
+    if (val == null) {
+      continue;
+    }
+    cookies += `${key}=${val}; `;
+  }
+  return cookies.trim().replace(/;$/, '');
+}

package/src/utils/create-cookie-string.spec.js

@@ -0,0 +1,32 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {createCookieString} from './create-cookie-string.js';
+
+describe('createCookieString', function () {
+  it('should require the parameter "data" to be an object', function () {
+    const throwable = v => () => createCookieString(v);
+    const error = v =>
+      format('Cookie data must be an Object, but %s was given.', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    throwable({key: 'value'})();
+    throwable({})();
+  });
+
+  it('should return an empty string for an empty object', function () {
+    expect(createCookieString({})).to.be.eq('');
+  });
+
+  it('should return the cookie string for the given object', function () {
+    const data = {foo: 'bar', baz: 'quz'};
+    const result = createCookieString(data);
+    expect(result).to.be.eq('foo=bar; baz=quz');
+  });
+});

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

@@ -0,0 +1,14 @@
+import {Constructor} from '../types.js';
+
+/**
+ * Create error.
+ *
+ * @param errorCtor
+ * @param message
+ * @param args
+ */
+export declare function createError<T>(
+  errorCtor: Constructor<T>,
+  message: string,
+  ...args: unknown[]
+): T;

package/src/utils/create-error.js

@@ -0,0 +1,29 @@
+import {format, InvalidArgumentError} from '@e22m4u/js-format';
+
+/**
+ * Create error.
+ *
+ * @param {Function} errorCtor
+ * @param {string} message
+ * @param {*[]|undefined} args
+ * @returns {object}
+ */
+export function createError(errorCtor, message, ...args) {
+  if (typeof errorCtor !== 'function') {
+    throw new InvalidArgumentError(
+      'Parameter "errorCtor" must be a Function, but %v was given.',
+      errorCtor,
+    );
+  }
+  if (message != null && typeof message !== 'string') {
+    throw new InvalidArgumentError(
+      'Parameter "message" must be a String, but %v was given.',
+      message,
+    );
+  }
+  if (message == null) {
+    return new errorCtor();
+  }
+  const interpolatedMessage = format(message, ...args);
+  return new errorCtor(interpolatedMessage);
+}

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

@@ -0,0 +1,42 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {createError} from './create-error.js';
+
+describe('createError', function () {
+  it('should require the parameter "errorCtor" to be a Function', function () {
+    const throwable = v => () => createError(v);
+    const error = v =>
+      format('Parameter "errorCtor" must be a Function, but %s was given.', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    throwable(Error)();
+  });
+
+  it('should require the parameter "message" to be a String', function () {
+    const throwable = v => () => createError(Error, v);
+    const error = v =>
+      format('Parameter "message" must be a String, but %s was given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable('str')();
+    throwable('')();
+    throwable(null)();
+    throwable(undefined)();
+  });
+
+  it('should interpolate 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-request-mock.d.ts

@@ -0,0 +1,35 @@
+import {Readable} from 'stream';
+import {IncomingMessage} from 'http';
+
+/**
+ * Request headers input.
+ */
+type RequestHeadersInput = {
+  [name: string]: string | string[];
+};
+
+/**
+ * Request options.
+ */
+type RequestOptions = {
+  host?: string;
+  method?: string;
+  secure?: boolean;
+  url?: string;
+  path?: string;
+  query?: string | object;
+  cookies?: object;
+  headers?: RequestHeadersInput;
+  body?: unknown;
+  stream?: Readable;
+  encoding?: BufferEncoding;
+};
+
+/**
+ * Create request mock.
+ *
+ * @param options
+ */
+export declare function createRequestMock(
+  options?: RequestOptions,
+): IncomingMessage;