@autofleet/node-common 4.0.0 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/node-common",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -8,14 +8,17 @@
   "types": "dist/index.d.ts",
   "exports": {
     "import": {
-      "default": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "require": {
-      "default": "./dist/index.cjs",
-      "types": "./dist/index.d.cts"
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "coverage": "vitest --coverage",
     "test": "vitest",

package/.nvmrc

@@ -1 +0,0 @@
-22.9.0

package/src/consts/index.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { consts } from '.';
-
-describe('consts', () => {
-  it('should be an object', () => {
-    expect(typeof consts).toBe('object');
-  });
-
-  it('should have ok', () => {
-    expect('ok' in consts).toBeTruthy();
-    expect(typeof consts.ok).toBe('string');
-    expect(consts.ok).toBe('OK');
-  });
-
-  it('should have error', () => {
-    expect('error' in consts).toBeTruthy();
-    expect(typeof consts.error).toBe('string');
-    expect(consts.error).toBe('ERROR');
-  });
-
-  it('should have fail', () => {
-    expect('fail' in consts).toBeTruthy();
-    expect(typeof consts.fail).toBe('string');
-    expect(consts.fail).toBe('FAIL');
-  });
-});

package/src/consts/index.ts

@@ -1,5 +0,0 @@
-export const consts = Object.freeze({
-  ok: 'OK',
-  error: 'ERROR',
-  fail: 'FAIL',
-});

package/src/index.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as nodeCommon from '.';
-import { consts } from './consts';
-import { AfRouter } from './router';
-
-describe('node-common', () => {
-  it('exports consts', () => {
-    expect(nodeCommon.consts).toBe(consts);
-  });
-
-  it('exports AfRouter', () => {
-    expect(nodeCommon.AfRouter).toBe(AfRouter);
-  });
-
-  it('exports AFRouter aliased as Router', () => {
-    expect(nodeCommon.Router).toBe(AfRouter);
-  });
-});

package/src/index.ts

@@ -1,6 +0,0 @@
-import { AfRouter } from './router';
-
-export { AfRouter } from './router';
-export { consts } from './consts';
-
-export const Router = AfRouter;

package/src/router/index.test.ts

@@ -1,149 +0,0 @@
-import Logger from '@autofleet/logger';
-import type { Request, Response, NextFunction } from 'express';
-import {
-  describe, expect, it, vi,
-} from 'vitest';
-import { AfRouter, METHODS } from '.';
-
-const logger = Logger();
-const noop = () => null;
-
-describe('Router', () => {
-  it('is a function', () => {
-    expect(typeof AfRouter).toBe('function');
-    expect(AfRouter.length).toBe(1);
-  });
-
-  it('returns a Router instance', () => {
-    const router = AfRouter({ logger });
-    expect(typeof router).toBe('function');
-    expect(typeof router.use).toBe('function');
-    expect(typeof router.get).toBe('function');
-    expect(typeof router.post).toBe('function');
-    expect(typeof router.put).toBe('function');
-    expect(typeof router.delete).toBe('function');
-    expect(typeof router.patch).toBe('function');
-    expect(typeof router.options).toBe('function');
-    expect(typeof router.head).toBe('function');
-  });
-
-  describe.each(METHODS)('Route method %s', { timeout: 1000 }, (method) => {
-    it('handles sync routes', async () => {
-      const router = AfRouter({ logger });
-      router[method]('/test', (_req, res) => {
-        res.send('ok');
-      });
-      const { promise, resolve } = Promise.withResolvers<string>();
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = { send: (data: string) => resolve(data) };
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, noop);
-      expect(await promise).toBe('ok');
-    });
-
-    it('handles async routes', async () => {
-      const router = AfRouter({ logger });
-      router[method]('/test', async (req, res) => {
-        res.send('ok');
-      });
-      const { promise, resolve } = Promise.withResolvers<string>();
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = { send: (data: string) => resolve(data) };
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, noop);
-      expect(await promise).toBe('ok');
-    });
-
-    it('handles arrays of handlers', async () => {
-      const router = AfRouter({ logger });
-      router[method]('/test', [
-        (_req: Request, _res: Response, next: NextFunction) => next(),
-        (_req: Request, res: Response) => res.send('ok'),
-      ]);
-      const { promise, resolve } = Promise.withResolvers<string>();
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = { send: (data: string) => resolve(data) };
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, noop);
-      expect(await promise).toBe('ok');
-    });
-
-    it('handles errors', async () => {
-      const router = AfRouter({ logger });
-      const error = new Error('test error');
-      router[method]('/test', () => {
-        throw error;
-      });
-      const { promise, resolve } = Promise.withResolvers();
-      const next = vi.fn(resolve);
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = {};
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, next);
-      await promise;
-      expect(next).toHaveBeenCalledExactlyOnceWith(error);
-    });
-
-    it('handles rejections', async () => {
-      const router = AfRouter({ logger });
-      const error = new Error('test error');
-      router[method]('/test', () => Promise.reject(error));
-      const { promise, resolve } = Promise.withResolvers();
-      const next = vi.fn(resolve);
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = {};
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, next);
-      await promise;
-      // expect(await promise).toBe({ error: 'test error', status: "ERROR" });
-      expect(next).toHaveBeenCalledExactlyOnceWith(error);
-    });
-
-    it('forces errors with status code 400 if not 500', async () => {
-      const router = AfRouter({ logger });
-      const error = Object.assign(new Error('test error'), { statusCode: 418 });
-      router[method]('/test', () => Promise.reject(error));
-      const { promise, resolve } = Promise.withResolvers();
-      const status = vi.fn(() => ({ json: resolve }));
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = { status };
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, noop);
-      await promise;
-      expect(await promise).toEqual({ error: 'test error', status: 'ERROR' });
-      expect(status).toHaveBeenCalledExactlyOnceWith(400);
-    });
-
-    it('keeps original errors when status code is 500', async () => {
-      const router = AfRouter({ logger });
-      const error = Object.assign(new Error('test error'), { statusCode: 500 });
-      router[method]('/test', () => Promise.reject(error));
-      const { promise, resolve } = Promise.withResolvers();
-      const next = vi.fn(resolve);
-      const req = { method, url: '/test', baseUrl: '' };
-      const res = {};
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, next);
-      await promise;
-      expect(next).toHaveBeenCalledExactlyOnceWith(error);
-    });
-
-    it('defaults to mergeParams true', async () => {
-      const router = AfRouter({ mergeParams: false, logger });
-      const childRouter = AfRouter({ logger });
-      router.use('/:parentParam', childRouter);
-      childRouter[method]<{ parentParam: string; param: string; }>('/:param', (req, res) => res.send({ param: req.params.param, parentParam: req.params.parentParam }));
-
-      const { promise, resolve } = Promise.withResolvers<string>();
-      const req = { method, url: '/foo/bar', baseUrl: '' };
-      const res = { send: (data: string) => resolve(data) };
-      // @ts-expect-error handle is not typed for an unclear reason.
-      router.handle(req, res, noop);
-      expect(await promise).toEqual({ parentParam: 'foo', param: 'bar' });
-      // @ts-expect-error mergeParams is a private field
-      expect(router.mergeParams).toBeFalsy();
-      // @ts-expect-error mergeParams is a private field
-      expect(childRouter.mergeParams).toBeTruthy();
-    });
-  });
-});

package/src/router/index.ts

@@ -1,45 +0,0 @@
-import {
-  Router, type Request, type Response, type NextFunction, type Handler, type RouterOptions, type IRouterMatcher,
-} from 'express';
-import Logger, { type LoggerInstanceManager } from '@autofleet/logger';
-
-export const METHODS = [
-  'all',
-  'get',
-  'post',
-  'put',
-  'delete',
-  'patch',
-  'options',
-  'head',
-] as const;
-
-const AfEntryPoint = (logger: LoggerInstanceManager, func: (req: Request, res: Response, nextFn: NextFunction) => void | PromiseLike<void>): Handler => async (req, res, next) => {
-  try {
-    await func(req, res, next);
-  } catch (err) {
-    const e = err as Error & { statusCode?: number };
-    logger.error(e.message);
-    if (e.statusCode && e.statusCode < 500) {
-      res.status(400).json({ error: e.message, status: 'ERROR' });
-      return;
-    }
-    next(e);
-  }
-};
-
-/** @returns a monkey-patched express router that will handle async routes (and force a 400 status for codes <500) */
-export const AfRouter = ({ logger = Logger(), ...options }: RouterOptions & { logger: LoggerInstanceManager }): Router => {
-  const myRouter = Router({ mergeParams: true, ...options });
-  METHODS.forEach((method) => {
-    const internalMethod = myRouter[method].bind(myRouter);
-    const newMethodHandler: IRouterMatcher<Router> = (...args: [...unknown[]]) => internalMethod(...args.map(argMapper) as [string]);
-    myRouter[method] = newMethodHandler;
-  });
-  return myRouter;
-
-  function argMapper(args: unknown): unknown {
-    if (Array.isArray(args)) return args.map(argMapper);
-    return typeof args === 'function' ? AfEntryPoint(logger, args as Handler) : args;
-  }
-};

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "lib": [
-      "ESNext"
-    ]
-  },
-  "include": ["src", "tsup.config.ts", "vitest.config.ts"],
-}

package/tsup.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig((options) => ({
-  entry: ['src/index.ts'],
-  target: 'node18.0',
-  dts: true,
-  format: ['esm', 'cjs'],
-  clean: !options.watch,
-  minify: !options.watch,
-  removeNodeProtocol: false,
-  treeshake: true,
-  sourcemap: true,
-}));

package/vitest.config.ts

@@ -1,14 +0,0 @@
-// eslint-disable-next-line import/no-unresolved
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    coverage: {
-      provider: 'v8',
-      reporter: ['text'],
-      thresholds: {
-        lines: 80,
-      },
-    },
-  },
-});