apeframework 0.0.0-dev.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Matthieu Symoens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# Ape Framework
+
+[Node.js](https://nodejs.org) API framework.
+
+NPM package: [apeframework](https://www.npmjs.com/package/apeframework)
+
+GitHub repository: [ApeCommerce/ape-framework](https://github.com/ApeCommerce/ape-framework)
+
+## Installation
+
+```
+npm install apeframework
+```
+
+## Hello Ape!
+
+Let's make an API serving a `/hello` endpoint, in TypeScript.
+
+Create a `boot.ts` file at the root of the project:
+
+```ts
+import type { Boot, Bundle } from 'apeframework/app';
+
+const welcome: Bundle = {
+  bundleId: 'welcome',
+  name: 'Welcome',
+  routes: async () => [
+    {
+      endpoint: {
+        method: 'GET',
+        path: '/hello',
+      },
+      handler: async (request, reply) => reply.send('Hello Ape!'),
+    },
+  ],
+};
+
+const boot: Boot = {
+  bundles: async () => [welcome],
+};
+
+export default boot;
+```
+
+Start the API using Ape Framework's CLI:
+
+```
+npx ape-cli-ts api start
+```
+
+Request the API:
+
+```
+curl http://localhost:3000/hello
+```

package/api/api.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPI } from 'openapi-types';
+export interface Api {
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+    getUrl: () => string;
+    doc: () => OpenAPI.Document;
+}

package/api/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/api.ts

@@ -0,0 +1,8 @@
+import { OpenAPI } from 'openapi-types'
+
+export interface Api {
+  start: () => Promise<void>,
+  close: () => Promise<void>,
+  getUrl: () => string,
+  doc: () => OpenAPI.Document,
+}

package/api/auth.d.ts

@@ -0,0 +1,9 @@
+export declare const tokenType = "authorization";
+export declare const headerRegex: RegExp;
+export declare const bearerPrefix = "Bearer ";
+declare const _default: {
+    bearerPrefix: string;
+    headerRegex: RegExp;
+    tokenType: string;
+};
+export default _default;

package/api/auth.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bearerPrefix = exports.headerRegex = exports.tokenType = void 0;
+exports.tokenType = 'authorization';
+exports.headerRegex = /^Bearer [0-9A-Za-z]+\.[0-9A-Za-z]+\.[0-9A-Za-z-_]+$/;
+exports.bearerPrefix = 'Bearer ';
+exports.default = {
+    bearerPrefix: exports.bearerPrefix,
+    headerRegex: exports.headerRegex,
+    tokenType: exports.tokenType,
+};

package/api/auth.ts

@@ -0,0 +1,9 @@
+export const tokenType = 'authorization'
+export const headerRegex = /^Bearer [0-9A-Za-z]+\.[0-9A-Za-z]+\.[0-9A-Za-z-_]+$/
+export const bearerPrefix = 'Bearer '
+
+export default {
+  bearerPrefix,
+  headerRegex,
+  tokenType,
+}

package/api/config.d.ts

@@ -0,0 +1,13 @@
+import type { FastifyCorsOptions as CorsOptions } from '@fastify/cors';
+import type { FastifyListenOptions as ListenOptions, FastifyServerOptions as ServerOptions } from 'fastify';
+import type { Options as ResponseValidationOptions } from '@fastify/response-validation';
+declare const _default: {
+    name: string;
+    version: string;
+    listenOptions: ListenOptions;
+    serverOptions: ServerOptions;
+    corsOptions: CorsOptions;
+    swaggerOptions: import("@fastify/swagger").FastifyDynamicSwaggerOptions;
+    responseValidationOptions: ResponseValidationOptions;
+};
+export default _default;

package/api/config.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../config");
+var config = (0, config_1.getConfig)();
+if (!config.apiName) {
+    throw new Error('api: name not provided');
+}
+if (!config.apiVersion) {
+    throw new Error('api: version not provided');
+}
+if (!config.apiHost) {
+    throw new Error('api: host not provided');
+}
+if (!config.apiPort) {
+    throw new Error('api: port not provided');
+}
+if (!config.apiConnectionTimeout) {
+    throw new Error('api: connection timeout not provided');
+}
+if (!config.apiRequestTimeout) {
+    throw new Error('api: request timeout not provided');
+}
+if (!config.apiKeepAliveTimeout) {
+    throw new Error('api: keep alive timeout not provided');
+}
+if (!config.apiBodyLimit) {
+    throw new Error('api: body limit not provided');
+}
+var listenOptions = {
+    host: config.apiHost,
+    port: config.apiRandomPort ? undefined : config.apiPort,
+};
+var serverOptions = {
+    connectionTimeout: config.apiConnectionTimeout,
+    requestTimeout: config.apiRequestTimeout,
+    keepAliveTimeout: config.apiKeepAliveTimeout,
+    bodyLimit: config.apiBodyLimit,
+};
+var corsOptions = {};
+var swaggerOptions = {
+    openapi: {
+        info: {
+            title: "".concat(config.apiName, " API Documentation"),
+            version: config.apiVersion,
+        },
+    },
+};
+var responseValidationOptions = {
+    responseValidation: config.apiResponseValidation,
+};
+exports.default = {
+    name: config.apiName,
+    version: config.apiVersion,
+    listenOptions: listenOptions,
+    serverOptions: serverOptions,
+    corsOptions: corsOptions,
+    swaggerOptions: swaggerOptions,
+    responseValidationOptions: responseValidationOptions,
+};

package/api/config.ts

@@ -0,0 +1,69 @@
+import type { FastifyCorsOptions as CorsOptions } from '@fastify/cors'
+import type { FastifyListenOptions as ListenOptions, FastifyServerOptions as ServerOptions } from 'fastify'
+import type { Options as ResponseValidationOptions } from '@fastify/response-validation'
+import type { SwaggerOptions } from '@fastify/swagger'
+import { getConfig } from '../config'
+
+const config = getConfig()
+
+if (!config.apiName) {
+  throw new Error('api: name not provided')
+}
+if (!config.apiVersion) {
+  throw new Error('api: version not provided')
+}
+if (!config.apiHost) {
+  throw new Error('api: host not provided')
+}
+if (!config.apiPort) {
+  throw new Error('api: port not provided')
+}
+if (!config.apiConnectionTimeout) {
+  throw new Error('api: connection timeout not provided')
+}
+if (!config.apiRequestTimeout) {
+  throw new Error('api: request timeout not provided')
+}
+if (!config.apiKeepAliveTimeout) {
+  throw new Error('api: keep alive timeout not provided')
+}
+if (!config.apiBodyLimit) {
+  throw new Error('api: body limit not provided')
+}
+
+const listenOptions: ListenOptions = {
+  host: config.apiHost,
+  port: config.apiRandomPort ? undefined : config.apiPort,
+}
+
+const serverOptions: ServerOptions = {
+  connectionTimeout: config.apiConnectionTimeout,
+  requestTimeout: config.apiRequestTimeout,
+  keepAliveTimeout: config.apiKeepAliveTimeout,
+  bodyLimit: config.apiBodyLimit,
+}
+
+const corsOptions: CorsOptions = {}
+
+const swaggerOptions: SwaggerOptions = {
+  openapi: {
+    info: {
+      title: `${config.apiName} API Documentation`,
+      version: config.apiVersion,
+    },
+  },
+}
+
+const responseValidationOptions: ResponseValidationOptions = {
+  responseValidation: config.apiResponseValidation,
+}
+
+export default {
+  name: config.apiName,
+  version: config.apiVersion,
+  listenOptions,
+  serverOptions,
+  corsOptions,
+  swaggerOptions,
+  responseValidationOptions,
+}

package/api/endpoint.d.ts

@@ -0,0 +1,20 @@
+export interface Endpoint {
+    path: string;
+    method: Method;
+    requiredRoles?: string[];
+    forbidden?: boolean;
+    requestSchema?: Schema;
+    replySchema?: Schema;
+    description?: string;
+    requestExample?: any;
+    replyExample?: any;
+}
+export interface Schema {
+    type: 'object';
+    additionalProperties: false;
+    required: string[];
+    properties: any;
+}
+export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export declare const querystringMethods: Method[];
+export declare const bodyMethods: Method[];

package/api/endpoint.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyMethods = exports.querystringMethods = void 0;
+exports.querystringMethods = ['DELETE', 'GET'];
+exports.bodyMethods = ['PATCH', 'POST', 'PUT'];

package/api/endpoint.ts

@@ -0,0 +1,23 @@
+export interface Endpoint {
+  path: string,
+  method: Method,
+  requiredRoles?: string[],
+  forbidden?: boolean,
+  requestSchema?: Schema,
+  replySchema?: Schema,
+  description?: string,
+  requestExample?: any,
+  replyExample?: any,
+}
+
+export interface Schema {
+  type: 'object',
+  additionalProperties: false,
+  required: string[],
+  properties: any,
+}
+
+export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT'
+
+export const querystringMethods: Method[] = ['DELETE', 'GET']
+export const bodyMethods: Method[] = ['PATCH', 'POST', 'PUT']

package/api/handler.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyError as Error, FastifyReply as Reply, FastifyRequest } from 'fastify';
+import type { User } from '../jwt/user';
+export type Handler = (request: Request, reply: Reply) => Promise<void>;
+export type ErrorHandler = (error: Error, request: Request, reply: Reply) => Promise<void>;
+export interface Request extends FastifyRequest {
+    user?: User;
+}
+export declare const send: (reply: Reply, value?: unknown) => void;

package/api/handler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.send = void 0;
+var send = function (reply, value) {
+    if (value === void 0) { value = true; }
+    if (value === true)
+        reply.send();
+    else if (value === false)
+        reply.status(403).send();
+    else
+        reply.send(value);
+};
+exports.send = send;

package/api/handler.ts

@@ -0,0 +1,23 @@
+import type { FastifyError as Error, FastifyReply as Reply, FastifyRequest } from 'fastify'
+import type { User } from '../jwt/user'
+
+export type Handler = (
+  request: Request,
+  reply: Reply
+) => Promise<void>
+
+export type ErrorHandler = (
+  error: Error,
+  request: Request,
+  reply: Reply
+) => Promise<void>
+
+export interface Request extends FastifyRequest {
+  user?: User,
+}
+
+export const send = (reply: Reply, value: unknown = true) => {
+  if (value === true) reply.send()
+  else if (value === false) reply.status(403).send()
+  else reply.send(value)
+}

package/api/index.d.ts

@@ -0,0 +1,7 @@
+import type { Api } from './api';
+export declare const start: () => Promise<void>;
+export declare const close: () => Promise<void>;
+export declare const getUrl: () => string;
+export declare const doc: () => import("openapi-types").OpenAPI.Document<{}>;
+declare const api: Api;
+export default api;

package/api/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doc = exports.getUrl = exports.close = exports.start = void 0;
+var cors_1 = __importDefault(require("@fastify/cors"));
+var fastify_1 = __importDefault(require("fastify"));
+var response_validation_1 = __importDefault(require("@fastify/response-validation"));
+var swagger_1 = __importDefault(require("@fastify/swagger"));
+var utils_1 = require("../utils");
+var auth_1 = require("./auth");
+var jwt_1 = require("../jwt");
+var config_1 = __importDefault(require("./config"));
+var log_1 = __importDefault(require("../log"));
+var router_1 = __importStar(require("./router"));
+var onRequest = function (request, reply) { return __awaiter(void 0, void 0, void 0, function () {
+    var roles, authorized, user;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                roles = (0, router_1.getRequiredRoles)((0, utils_1.basePath)(request.routerPath));
+                if (!roles) return [3 /*break*/, 3];
+                authorized = false;
+                if (!((_a = request.headers.authorization) === null || _a === void 0 ? void 0 : _a.match(auth_1.headerRegex))) return [3 /*break*/, 2];
+                return [4 /*yield*/, (0, jwt_1.verifyToken)(request.headers.authorization.substring(auth_1.bearerPrefix.length), auth_1.tokenType, (0, utils_1.timestamp)())];
+            case 1:
+                user = _b.sent();
+                if (user && (0, jwt_1.hasRoles)(user, roles)) {
+                    authorized = true;
+                    request.user = user;
+                }
+                _b.label = 2;
+            case 2:
+                if (!authorized) {
+                    reply.status(401).send();
+                }
+                _b.label = 3;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var onResponse = function (request, reply) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        log_1.default.debug([
+            "api: ".concat(request.method, " ").concat((0, utils_1.basePath)(request.url, '?')),
+            "".concat(reply.statusCode, " ").concat(reply.getResponseTime().toFixed(0), "ms"),
+        ].join(' '));
+        return [2 /*return*/];
+    });
+}); };
+var onTimeout = function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        log_1.default.error([
+            "api: ".concat(request.method, " ").concat(request.routerPath),
+            "timeout ".concat(config_1.default.serverOptions.connectionTimeout, "ms"),
+        ].join(' '));
+        return [2 /*return*/];
+    });
+}); };
+var notFoundHandler = function (request, reply) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        reply.status(404).send();
+        return [2 /*return*/];
+    });
+}); };
+var errorHandler = function (error, request, reply) { return __awaiter(void 0, void 0, void 0, function () {
+    var status;
+    var _a;
+    return __generator(this, function (_b) {
+        status = (_a = error.statusCode) !== null && _a !== void 0 ? _a : 500;
+        reply.status(status).send();
+        if (status === 400) {
+            log_1.default.debug(error);
+        }
+        else {
+            log_1.default.error(error);
+        }
+        return [2 /*return*/];
+    });
+}); };
+var server = (0, fastify_1.default)(config_1.default.serverOptions)
+    .addHook('onRequest', onRequest)
+    .addHook('onResponse', onResponse)
+    .addHook('onTimeout', onTimeout)
+    .setNotFoundHandler(notFoundHandler)
+    .setErrorHandler(errorHandler)
+    .register(cors_1.default, config_1.default.corsOptions)
+    .register(swagger_1.default, config_1.default.swaggerOptions)
+    .register(response_validation_1.default, config_1.default.responseValidationOptions)
+    .register(router_1.default);
+var url;
+var start = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, server.listen(config_1.default.listenOptions)];
+            case 1:
+                url = _a.sent();
+                log_1.default.info("api: started v".concat(config_1.default.version, " @").concat(url));
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.start = start;
+var close = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, server.close()];
+            case 1:
+                _a.sent();
+                log_1.default.info('api: closed');
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.close = close;
+var getUrl = function () { return url; };
+exports.getUrl = getUrl;
+var doc = function () { return server.swagger(); };
+exports.doc = doc;
+var api = {
+    start: exports.start,
+    close: exports.close,
+    getUrl: exports.getUrl,
+    doc: exports.doc,
+};
+exports.default = api;

package/api/index.ts

@@ -0,0 +1,97 @@
+import cors from '@fastify/cors'
+import fastify from 'fastify'
+import responseValidation from '@fastify/response-validation'
+import swagger from '@fastify/swagger'
+import { basePath, timestamp } from '../utils'
+import { bearerPrefix, headerRegex, tokenType } from './auth'
+import { hasRoles, verifyToken } from '../jwt'
+import config from './config'
+import log from '../log'
+import router, { getRequiredRoles } from './router'
+import type { Api } from './api'
+import type { ErrorHandler, Handler } from './handler'
+
+const onRequest: Handler = async (request, reply) => {
+  const roles = getRequiredRoles(basePath(request.routerPath))
+  if (roles) {
+    let authorized = false
+    if (request.headers.authorization?.match(headerRegex)) {
+      const user = await verifyToken(
+        request.headers.authorization.substring(bearerPrefix.length),
+        tokenType,
+        timestamp(),
+      )
+      if (user && hasRoles(user, roles)) {
+        authorized = true
+        request.user = user
+      }
+    }
+    if (!authorized) {
+      reply.status(401).send()
+    }
+  }
+}
+
+const onResponse: Handler = async (request, reply) => {
+  log.debug([
+    `api: ${request.method} ${basePath(request.url, '?')}`,
+    `${reply.statusCode} ${reply.getResponseTime().toFixed(0)}ms`,
+  ].join(' '))
+}
+
+const onTimeout: Handler = async (request) => {
+  log.error([
+    `api: ${request.method} ${request.routerPath}`,
+    `timeout ${config.serverOptions.connectionTimeout}ms`,
+  ].join(' '))
+}
+
+const notFoundHandler: Handler = async (request, reply) => {
+  reply.status(404).send()
+}
+
+const errorHandler: ErrorHandler = async (error, request, reply) => {
+  const status = error.statusCode ?? 500
+  reply.status(status).send()
+  if (status === 400) {
+    log.debug(error)
+  } else {
+    log.error(error)
+  }
+}
+
+const server = fastify(config.serverOptions)
+  .addHook('onRequest', onRequest)
+  .addHook('onResponse', onResponse)
+  .addHook('onTimeout', onTimeout)
+  .setNotFoundHandler(notFoundHandler)
+  .setErrorHandler(errorHandler)
+  .register(cors, config.corsOptions)
+  .register(swagger, config.swaggerOptions)
+  .register(responseValidation, config.responseValidationOptions)
+  .register(router)
+
+let url: string
+
+export const start = async () => {
+  url = await server.listen(config.listenOptions)
+  log.info(`api: started v${config.version} @${url}`)
+}
+
+export const close = async () => {
+  await server.close()
+  log.info('api: closed')
+}
+
+export const getUrl = () => url
+
+export const doc = () => server.swagger()
+
+const api: Api = {
+  start,
+  close,
+  getUrl,
+  doc,
+}
+
+export default api

package/api/route.d.ts

@@ -0,0 +1,6 @@
+import type { Endpoint } from './endpoint';
+import type { Handler } from './handler';
+export interface Route {
+    endpoint: Endpoint;
+    handler: Handler;
+}