@ololoepepe/controllers 0.2.38 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.3.0] - 2026-08-28
+
+### Changed
+
+- Rewritten in TypeScript. The package now ships compiled ESM plus type declarations
+  under `dist/node/` instead of raw sources, so consumers get types without a separate
+  `@types/…` package. Runtime behaviour is unchanged.
+- The request and the response are type parameters defaulting to Express's `Request`
+  and `Response`, so callbacks need no annotation on Express and the controllers still
+  accept any object of the right shape elsewhere.
+- `stringController` now requires its callback to return a `string` or `undefined`.
+  Returning an object used to compile and made Express send JSON from a controller
+  whose whole purpose is text.
+- The test suite drives a real Express app over real HTTP instead of asserting on stub
+  objects, and covers what was previously untested: failures reaching the error
+  middleware, a promise result being awaited, and `stringController` at all — its tests
+  existed but were never registered with the runner, and their assertions were wrong.
+- Migrated from mocha and chai to the built-in `node:test` runner.
+- ESLint config replaced with `@ololoepepe/eslint-config-typescript` on the ESLint 10
+  flat format, and the code style violations it surfaced were fixed.
+- CI image bumped to `node:24-alpine`; the pipeline now also runs `typecheck` and
+  `build`.
+- Dependencies updated.
+
+### Added
+
+- `engines` field: Node.js >= 24.
+- `exports` map, `sideEffects: false`, and per-target `package.json` in the build
+  output that remaps `#src/*.ts` to the compiled files.
+- `npm run build` and `npm run typecheck`.
+- Exported types: `Controller`, `ControllerCallback`, `ControllerRequest`,
+  `JsonResponse`, `NextFunction`, `NoContentResponse`, `StringResponse`.
+- Full README, and this changelog.
+
+### Removed
+
+- The `main` field, replaced by the `exports` map. Deep imports into the package are
+  no longer possible; import the package root.
+- `body-parser`, `chai`, `chai-http` and `mocha`, along with `.mocharc.yml` and the
+  `.ncurc.yml` that existed to hold chai and ESLint back.
+- `.npmignore`, replaced by the `files` field.
+- The runtime check for a non-string request method in the status code helper — the
+  type says `string`, and the only caller is Express, which always sets it.
+- The undocumented fallback in `noContentController` where an explicit `statusCode` of
+  `0` selected the code by request method instead. `0` is not a status code.

package/README.md

@@ -1 +1,182 @@
-# Common Express controllers library
+# @ololoepepe/controllers
+
+Express route handlers built from plain functions.
+
+You write a function that takes the request and returns the data. The controller
+sends that data, picks the status code from the HTTP method, and routes any
+failure to your error middleware. What disappears from every route is the
+`try`/`catch` around the handler, the `next(error)` inside it, and the decision
+of whether this particular route answers with 200 or 201.
+
+## Installation
+
+```sh
+npm install @ololoepepe/controllers
+```
+
+Requires Node.js >= 24. Written in TypeScript — the declarations ship with the
+package, so there is no `@types/…` to install.
+
+## Usage
+
+```ts
+import express, {type Request} from 'express';
+import {jsonController, noContentController, stringController} from '@ololoepepe/controllers';
+
+const app = express();
+
+app.use(express.json());
+
+app.get('/users', jsonController(() => listUsers()));
+app.post('/users', jsonController(request => createUser(request.body)));
+app.delete('/users/:id', noContentController((request: Request<{id: string}>) => deleteUser(request.params.id)));
+app.get('/health', stringController(() => 'ok'));
+
+app.use(errorHandler);
+```
+
+`GET /users` answers `200` with the array as JSON. `POST /users` answers `201`
+with the created user. `DELETE /users/:id` answers `204` with an empty body. If
+`createUser` throws or rejects, `errorHandler` gets the error and the client
+never sees a hung request.
+
+The callbacks are mostly unannotated and do not need to be: `request` and
+`response` are Express's own `Request` and `Response` by default. The one
+annotation above is about route parameters — see
+[Route parameters](#route-parameters).
+
+## The three controllers
+
+Each one takes a callback and returns an Express handler. The callback receives
+the request and the response, and may return a promise — the controller waits
+for it.
+
+### `jsonController(callback, statusCode?)`
+
+Sends the callback's result as JSON. `undefined` is sent as `{}`; `null` is sent
+as `null`, since only `undefined` stands for "nothing to send".
+
+```ts
+app.get('/settings', jsonController(async () => loadSettings()));
+```
+
+### `stringController(callback, statusCode?)`
+
+Sends the callback's result as text. The callback must return a `string` or
+`undefined`; `undefined` is sent as an empty string.
+
+```ts
+app.get('/robots.txt', stringController(() => 'User-agent: *\nDisallow:'));
+```
+
+### `noContentController(callback, statusCode = 204)`
+
+Runs the callback and answers with a status code and an empty body. Whatever the
+callback returns is discarded.
+
+```ts
+app.post('/cache/flush', noContentController(async () => flushCache()));
+```
+
+## Status codes
+
+`jsonController` and `stringController` choose the code from the request method
+unless you pass one explicitly:
+
+| Method | Status code |
+| --- | --- |
+| `POST`, `PUT` | `201` |
+| everything else | `200` |
+
+`noContentController` does not look at the method: it answers `204` unless told
+otherwise.
+
+To override, pass the code as the second argument:
+
+```ts
+app.post('/jobs', jsonController(request => enqueue(request.body), 202));
+```
+
+## Errors
+
+Anything the callback throws or rejects with is passed to `next`, so it reaches
+the next error-handling middleware in the chain. So is a failure of the response
+itself — including the `ERR_HTTP_HEADERS_SENT` you get when the callback has
+already answered on its own. Nothing is swallowed, and nothing escapes as an
+unhandled promise rejection.
+
+The library does not format error responses; that is the job of your error
+middleware. [`@ololoepepe/middlewares`](https://www.npmjs.com/package/@ololoepepe/middlewares)
+ships one.
+
+## Route parameters
+
+Express types `request.params` from the route string, but only when it can see
+the handler and the route together. A controller is built before it reaches
+`app.get`, so that link is broken and `request.params.id` falls back to Express's
+own default, `string | string[]`.
+
+Name the parameters on the callback to get them back:
+
+```ts
+import type {Request} from 'express';
+
+app.get('/users/:id/posts/:postId', jsonController((request: Request<{id: string; postId: string}>) => {
+  return loadPosts(request.params.id, request.params.postId);
+}));
+```
+
+Properties your own middleware puts on the request are a different matter: they
+belong on Express's `Request` itself, through declaration merging, and then every
+callback sees them with no annotation at all.
+
+```ts
+declare global {
+  namespace Express {
+    interface Request {
+      currentUser: User;
+    }
+  }
+}
+
+app.get('/me', jsonController(request => request.currentUser));
+```
+
+## Types
+
+The request and the response are type parameters, defaulting to Express's
+`Request` and `Response`. On Express you rarely name them. Anywhere else, pass
+your own shapes — the controllers only require what they actually use:
+
+```ts
+import {jsonController, type ControllerRequest, type JsonResponse} from '@ololoepepe/controllers';
+
+interface TenantRequest extends ControllerRequest {
+  tenantId: string;
+}
+
+const controller = jsonController<TenantRequest, JsonResponse>(request => loadTenant(request.tenantId));
+```
+
+Exported types: `Controller`, `ControllerCallback`, `ControllerRequest`,
+`JsonResponse`, `NextFunction`, `NoContentResponse`, `StringResponse`.
+
+## Development
+
+| Command | What it does |
+| --- | --- |
+| `npm run lint` | ESLint over the whole repository. |
+| `npm run typecheck` | `tsc` over `src`, `test`, `test-support` and `scripts`, no emit. |
+| `npm test` | The `node:test` suite; Node runs the TypeScript sources directly. |
+| `npm run build` | Compiles `src` into `dist/node/` — the ESM and `.d.ts` that get published. |
+
+The tests drive a real Express app over real HTTP, so they assert what a client
+sees rather than which methods were called on a stub.
+
+Internal imports go through the `#src/*.ts` subpath map rather than relative
+paths. `dist/node/` gets its own `package.json` remapping `#src/*.ts` to the
+compiled files, which is what makes those imports resolve for consumers.
+
+## License
+
+UNLICENSED — private package.

package/dist/node/controllers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as jsonController } from '#src/controllers/json-controller.ts';
+export { default as noContentController } from '#src/controllers/no-content-controller.ts';
+export { default as stringController } from '#src/controllers/string-controller.ts';

package/dist/node/controllers/index.js

@@ -0,0 +1,3 @@
+export { default as jsonController } from '#src/controllers/json-controller.ts';
+export { default as noContentController } from '#src/controllers/no-content-controller.ts';
+export { default as stringController } from '#src/controllers/string-controller.ts';

package/dist/node/controllers/json-controller.d.ts

@@ -0,0 +1,17 @@
+import type { Request, Response } from 'express';
+import type { Controller, ControllerCallback, ControllerRequest, JsonResponse } from '#src/types.ts';
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет его результат
+ * в виде JSON.
+ *
+ * Если `callback` вернул `undefined`, вместо него отправляется пустой объект `{}`. Если вернул
+ * промис — контроллер дожидается его результата.
+ *
+ * Код ответа по умолчанию — 201 для POST и PUT и 200 для остальных запросов.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа, если нужен не тот, что выбирается по методу запроса
+ */
+export default function jsonController<TRequest extends ControllerRequest = Request, TResponse extends JsonResponse = Response>(callback: ControllerCallback<TRequest, TResponse>, statusCode?: number): Controller<TRequest, TResponse>;

package/dist/node/controllers/json-controller.js

@@ -0,0 +1,28 @@
+import selectStatusCode from '#src/lib/select-status-code.ts';
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет его результат
+ * в виде JSON.
+ *
+ * Если `callback` вернул `undefined`, вместо него отправляется пустой объект `{}`. Если вернул
+ * промис — контроллер дожидается его результата.
+ *
+ * Код ответа по умолчанию — 201 для POST и PUT и 200 для остальных запросов.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа, если нужен не тот, что выбирается по методу запроса
+ */
+export default function jsonController(callback, statusCode) {
+    return async (request, response, next) => {
+        try {
+            const result = await callback(request, response);
+            // Пустым объектом подменяется только `undefined`: `null` — осмысленное тело ответа
+            const body = (result === undefined) ? {} : result;
+            response.status(statusCode ?? selectStatusCode(request.method)).json(body);
+        }
+        catch (error) {
+            next(error);
+        }
+    };
+}

package/dist/node/controllers/no-content-controller.d.ts

@@ -0,0 +1,13 @@
+import type { Request, Response } from 'express';
+import type { Controller, ControllerCallback, ControllerRequest, NoContentResponse } from '#src/types.ts';
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет один только код
+ * ответа. Тело ответа остается пустым, что бы `callback` ни вернул. Если он вернул промис —
+ * контроллер дожидается его результата.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа (по умолчанию 204)
+ */
+export default function noContentController<TRequest extends ControllerRequest = Request, TResponse extends NoContentResponse = Response>(callback: ControllerCallback<TRequest, TResponse>, statusCode?: number): Controller<TRequest, TResponse>;

package/dist/node/controllers/no-content-controller.js

@@ -0,0 +1,22 @@
+const NO_CONTENT = 204;
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет один только код
+ * ответа. Тело ответа остается пустым, что бы `callback` ни вернул. Если он вернул промис —
+ * контроллер дожидается его результата.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа (по умолчанию 204)
+ */
+export default function noContentController(callback, statusCode = NO_CONTENT) {
+    return async (request, response, next) => {
+        try {
+            await callback(request, response);
+            response.sendStatus(statusCode);
+        }
+        catch (error) {
+            next(error);
+        }
+    };
+}

package/dist/node/controllers/string-controller.d.ts

@@ -0,0 +1,17 @@
+import type { Request, Response } from 'express';
+import type { Controller, ControllerCallback, ControllerRequest, StringResponse } from '#src/types.ts';
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет его результат
+ * в виде строки.
+ *
+ * Если `callback` вернул `undefined`, отправляется пустая строка. Если вернул промис —
+ * контроллер дожидается его результата.
+ *
+ * Код ответа по умолчанию — 201 для POST и PUT и 200 для остальных запросов.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа, если нужен не тот, что выбирается по методу запроса
+ */
+export default function stringController<TRequest extends ControllerRequest = Request, TResponse extends StringResponse = Response>(callback: ControllerCallback<TRequest, TResponse, string | undefined>, statusCode?: number): Controller<TRequest, TResponse>;

package/dist/node/controllers/string-controller.js

@@ -0,0 +1,26 @@
+import selectStatusCode from '#src/lib/select-status-code.ts';
+/**
+ * Создает контроллер, который вызывает `callback` на каждый запрос и отправляет его результат
+ * в виде строки.
+ *
+ * Если `callback` вернул `undefined`, отправляется пустая строка. Если вернул промис —
+ * контроллер дожидается его результата.
+ *
+ * Код ответа по умолчанию — 201 для POST и PUT и 200 для остальных запросов.
+ *
+ * Ошибка `callback`, как и ошибка самой отправки ответа, передается следующему обработчику
+ * ошибок в цепочке.
+ * @param callback - функция, вызываемая на входящий запрос
+ * @param statusCode - код ответа, если нужен не тот, что выбирается по методу запроса
+ */
+export default function stringController(callback, statusCode) {
+    return async (request, response, next) => {
+        try {
+            const result = await callback(request, response);
+            response.status(statusCode ?? selectStatusCode(request.method)).send(result ?? '');
+        }
+        catch (error) {
+            next(error);
+        }
+    };
+}

package/dist/node/index.d.ts

@@ -0,0 +1,2 @@
+export { jsonController, noContentController, stringController } from '#src/controllers/index.ts';
+export type { Controller, ControllerCallback, ControllerRequest, JsonResponse, NextFunction, NoContentResponse, StringResponse } from '#src/types.ts';

package/dist/node/index.js

@@ -0,0 +1 @@
+export { jsonController, noContentController, stringController } from '#src/controllers/index.ts';

package/dist/node/lib/select-status-code.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Возвращает код ответа, подходящий методу запроса: 201 для POST и PUT, 200 для остальных.
+ * Регистр не имеет значения.
+ * @param method - метод HTTP-запроса
+ */
+export default function selectStatusCode(method: string): number;

package/dist/node/lib/select-status-code.js

@@ -0,0 +1,12 @@
+const CREATED = 201;
+const OK = 200;
+// Методы, для которых успешный ответ означает, что что-то было создано
+const CREATING_METHODS = new Set(['POST', 'PUT']);
+/**
+ * Возвращает код ответа, подходящий методу запроса: 201 для POST и PUT, 200 для остальных.
+ * Регистр не имеет значения.
+ * @param method - метод HTTP-запроса
+ */
+export default function selectStatusCode(method) {
+    return CREATING_METHODS.has(method.toUpperCase()) ? CREATED : OK;
+}

package/dist/node/package.json

@@ -0,0 +1,6 @@
+{
+  "imports": {
+    "#src/*.ts": "./*.js"
+  },
+  "type": "module"
+}

package/dist/node/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Общие типы контроллеров.
+ *
+ * Запрос и ответ везде остаются параметрами типа. По умолчанию это `Request` и `Response` из
+ * Express, поэтому в обычном случае аннотировать ничего не нужно. Подставить можно любые объекты
+ * подходящей формы — из другого фреймворка или из теста.
+ */
+/** Продолжение цепочки Express. Аргумент — ошибка, если она произошла. */
+export type NextFunction = (error?: unknown) => void;
+/** Минимальная часть запроса, которая нужна контроллерам: по методу выбирается код ответа. */
+export interface ControllerRequest {
+    method: string;
+}
+/** Ответ, умеющий отдать тело в виде JSON. */
+export interface JsonResponse {
+    status: (statusCode: number) => {
+        json: (body: unknown) => unknown;
+    };
+}
+/** Ответ, умеющий отдать тело в виде строки. */
+export interface StringResponse {
+    status: (statusCode: number) => {
+        send: (body: string) => unknown;
+    };
+}
+/** Ответ, умеющий отдать один только код без тела. */
+export interface NoContentResponse {
+    sendStatus: (statusCode: number) => unknown;
+}
+/** Готовый обработчик Express — то, что возвращает каждый контроллер. */
+export type Controller<TRequest, TResponse> = (request: TRequest, response: TResponse, next: NextFunction) => Promise<void>;
+/** Функция, которую контроллер вызывает на каждый входящий запрос. */
+export type ControllerCallback<TRequest, TResponse, TResult = unknown> = (request: TRequest, response: TResponse) => Promise<TResult> | TResult;

package/dist/node/types.js

@@ -0,0 +1,8 @@
+/**
+ * Общие типы контроллеров.
+ *
+ * Запрос и ответ везде остаются параметрами типа. По умолчанию это `Request` и `Response` из
+ * Express, поэтому в обычном случае аннотировать ничего не нужно. Подставить можно любые объекты
+ * подходящей формы — из другого фреймворка или из теста.
+ */
+export {};

package/package.json

@@ -1,23 +1,39 @@
 {
   "name": "@ololoepepe/controllers",
-  "version": "0.2.38",
+  "version": "0.3.0",
   "description": "Common Express controllers library",
-  "main": "src/index.js",
+  "type": "module",
   "imports": {
-    "#src/*.js": "./src/*.js"
+    "#src/*.ts": "./src/*.ts",
+    "#test-support/*.ts": "./test-support/*.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
   },
-  "type": "module",
   "scripts": {
-    "lint": "eslint ./src",
-    "test": "mocha ./test/*"
+    "build": "npm run build:node",
+    "build:node": "node scripts/build-node.ts",
+    "lint": "eslint .",
+    "prepack": "npm run build",
+    "test": "node --test",
+    "typecheck": "tsc"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.com"
   },
   "files": [
-    "src",
+    "dist",
     "package.json",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "repository": {
     "type": "git",
@@ -29,13 +45,14 @@
     "url": "https://gitlab.void-walkers.com/libs/node.js/controllers/issues"
   },
   "homepage": "https://gitlab.void-walkers.com/libs/node.js/controllers#README",
+  "dependencies": {
+    "@types/express": "^5.0.6"
+  },
   "devDependencies": {
-    "@ololoepepe/eslint-config": "^0.0.20",
-    "body-parser": "^2.2.0",
-    "chai": "^4.4.1",
-    "chai-http": "^4.4.0",
-    "eslint": "^8.57.0",
-    "express": "^5.1.0",
-    "mocha": "^11.4.0"
+    "@ololoepepe/eslint-config-typescript": "^0.2.0",
+    "@types/node": "^26.4.0",
+    "eslint": "^10.9.1",
+    "express": "^5.2.1",
+    "typescript": "^6.0.3"
   }
 }

package/src/controllers/index.js

@@ -1,5 +0,0 @@
-import jsonController from './json-controller.js';
-import noContentController from './no-content-controller.js';
-import stringController from './string-controller.js';
-
-export {jsonController, noContentController, stringController};

package/src/controllers/json-controller.js

@@ -1,32 +0,0 @@
-import {selectStatusCode} from '#src/lib/helper.js';
-
-/**
- * Создает функцию-контроллер, вызывающую переданный callback при запросах
- * и отправляющую результат ее выполнения в виде JSON.
- *
- * Если функция-callback возвращает undefined, вместо этого значения подставляется пустой объект {}.
- *
- * Если функция-callback возвращает экземпляр Promise, контроллер будет ожидать его результат.
- *
- * По умолчанию HTTP-код ответа (statusCode) устанавливается в 201, если запрос POST или PUT,
- * и в 200 в остальных случаях.
- *
- * При ошибке вызывается следующий middleware или контроллер в цепочке.
- *
- * @param {function} callback - функция, вызываемая для входящих запросов
- * @param {number} [statusCode] - HTTP-код ответа (по умолчанию 201 для POST и PUT и 200 для остальных запросов)
- *
- * @return {function} - функция-контроллер
- */
-
-export default (callback, statusCode) => async (req, res, next) => {
-  try {
-    const result = await callback(req, res);
-
-    const json = (result === undefined) ? {} : result;
-
-    res.status(statusCode || selectStatusCode(req.method)).json(json);
-  } catch (err) {
-    next(err);
-  }
-};

package/src/controllers/no-content-controller.js

@@ -1,26 +0,0 @@
-import {selectStatusCode} from '#src/lib/helper.js';
-
-/**
- * Создает функцию-контроллер, вызывающую переданный callback при запросах
- * и устанавливающую код ответа после ее выполнения. Тело ответа оставляется пустым.
- * Если функция-callback возвращает экземпляр Promise, контроллер будет ожидать его результат.
- *
- * По умолчанию HTTP-код ответа (statusCode) устанавливается в 204.
- *
- * При ошибке вызывается следующий middleware или контроллер в цепочке.
- *
- * @param {function} callback - функция, вызываемая для входящих запросов
- * @param {number} [statusCode=204] - HTTP-код ответа
- *
- * @return {function} - функция-контроллер
- */
-
-export default (callback, statusCode = 204) => async (req, res, next) => {
-  try {
-    await callback(req, res);
-
-    res.sendStatus(statusCode || selectStatusCode(req.method));
-  } catch (err) {
-    next(err);
-  }
-};

package/src/controllers/string-controller.js

@@ -1,32 +0,0 @@
-import {selectStatusCode} from '#src/lib/helper.js';
-
-/**
- * Создает функцию-контроллер, вызывающую переданный callback при запросах
- * и отправляющую результат ее выполнения в виде строки.
- *
- * Если функция-callback возвращает undefined, вместо этого значения подставляется пустая строка.
- *
- * Если функция-callback возвращает экземпляр Promise, контроллер будет ожидать его результат.
- *
- * По умолчанию HTTP-код ответа (statusCode) устанавливается в 201, если запрос POST или PUT,
- * и в 200 в остальных случаях.
- *
- * При ошибке вызывается следующий middleware или контроллер в цепочке.
- *
- * @param {function} callback - функция, вызываемая для входящих запросов
- * @param {number} [statusCode] - HTTP-код ответа (по умолчанию 201 для POST и PUT и 200 для остальных запросов)
- *
- * @return {function} - функция-контроллер
- */
-
-export default (callback, statusCode) => async (req, res, next) => {
-  try {
-    const result = await callback(req, res);
-
-    const string = (result === undefined) ? '' : result;
-
-    res.status(statusCode || selectStatusCode(req.method)).send(string);
-  } catch (err) {
-    next(err);
-  }
-};

package/src/index.js

@@ -1 +0,0 @@
-export {jsonController, noContentController, stringController} from './controllers/index.js';

package/src/lib/helper.js

@@ -1,26 +0,0 @@
-/**
- * Возвращает HTTP-код ответа в зависимости от типа запроса:
- * 201, если запрос POST или PUT, и в 200 в остальных случаях.
- *
- * Не зависит от регистра.
- *
- * @param {string} method - тип HTTP-запроса
- *
- * @return {number} - HTTP-код ответа
- */
-
-export function selectStatusCode(method) {
-  if (typeof method === 'string') {
-    method = method.toUpperCase();
-  }
-
-  switch (method) {
-  case 'POST':
-  case 'PUT':
-    return 201;
-  case 'GET':
-  case 'DELETE':
-  default:
-    return 200;
-  }
-}