@lakutata/entrypoint 3.0.0-beta.0

package/dist/types/adapter/commander/CommanderCLIEntrypoint.d.ts

@@ -0,0 +1,192 @@
+import { Command } from 'commander';
+import { type Module } from '@lakutata/core';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { CLIContext } from '../../context/CLIContext.js';
+/**
+ * The JSON schema of a property of the input of an action
+ */
+export type PropertySchema = {
+    type?: string | string[];
+    enum?: unknown[];
+    items?: PropertySchema;
+    default?: unknown;
+    description?: string;
+    format?: string;
+    [key: string]: unknown;
+};
+/**
+ * A text of the help or of the prompts of {@link commanderCLIEntrypoint}, given to its `translate` function.
+ */
+export type CLIText = {
+    /**
+     * The key identifying the text: `description` (the program), `commands.<command>.description`,
+     * `commands.<command>.options.<property>`, `commands.<command>.arguments.<name>` (a nested command's words are joined
+     * with dots: `package.exe`), the help titles and labels (`help.usage`, `help.options`, `help.commands`,
+     * `help.default`, `help.choices`…), the prompt messages (`prompt.json`).
+     */
+    key: string;
+    /**
+     * The English text, with its `{name}` placeholders.
+     */
+    text: string;
+    /**
+     * The values of the text's `{name}` placeholders, by name.
+     */
+    params?: Record<string, string>;
+};
+/**
+ * Translate a text of the help or of the prompts into the user's language: return the translated text, its `{name}`
+ * placeholders filled from `params`.
+ */
+export type CLITranslate = (text: CLIText) => string;
+/**
+ * The options of {@link commanderCLIEntrypoint}.
+ */
+export type CommanderCLIEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several CLI adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The program name shown in the help.
+     * @default the name of the script run, without its extension
+     */
+    bin?: string;
+    /**
+     * The program description shown in the help.
+     */
+    description?: string;
+    /**
+     * The descriptions of the command groups, by group name: the first words of the nested commands (`'package'` for
+     * the command `'package exe <file>'`), whose help (`tool package --help`) lists their commands.
+     */
+    groups?: Record<string, string>;
+    /**
+     * The program version; adds the `-V, --version` option.
+     */
+    version?: string;
+    /**
+     * The command-line arguments to parse, without the node executable and the script.
+     * @default process.argv.slice(2)
+     */
+    argv?: string[];
+    /**
+     * Prompt for the missing required options (it needs the optional package `@inquirer/prompts`): `'auto'` when both
+     * stdin and stdout are terminals, `true` always, `false` never. While prompting is on, the required options are not
+     * enforced by the parser; without `@inquirer/prompts` installed, prompting is off (the parser requires them).
+     * @default 'auto'
+     */
+    interactive?: boolean | 'auto';
+    /**
+     * The input stream of the prompts.
+     * @default process.stdin
+     */
+    stdin?: NodeJS.ReadableStream;
+    /**
+     * The output stream of the results, the help and the prompts.
+     * @default process.stdout
+     */
+    stdout?: NodeJS.WritableStream;
+    /**
+     * The output stream of the errors.
+     * @default process.stderr
+     */
+    stderr?: NodeJS.WritableStream;
+    /**
+     * Turn an action's result into the text or bytes written to stdout; `undefined` writes nothing.
+     * @default a string as is (with a final newline), bytes as is, `null` and `undefined` as nothing, any other value as
+     * indented JSON (the bigints as strings)
+     */
+    format?: (result: unknown) => string | Uint8Array | undefined;
+    /**
+     * What happens when no argument is given: `'help'` writes the help and ends with the code 1, `'ignore'` runs no
+     * command and leaves the application running (an application also serving other channels).
+     * @default 'help'
+     */
+    noCommand?: 'help' | 'ignore';
+    /**
+     * What happens once the command ended, with its exit code (0 on success, 1 on failure, the parser's code for a
+     * usage error): `'application'` exits the application with the code, `'process'` only sets `process.exitCode`,
+     * `'none'` does nothing, or a function receiving the code.
+     * @default 'application'
+     */
+    exit?: 'application' | 'process' | 'none' | ((code: number) => void | Promise<void>);
+    /**
+     * Customize the commander program (hooks, global options, additional commands) after the action commands are
+     * added and before the arguments are parsed.
+     */
+    configure?: (program: Command) => void | Promise<void>;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Translate the texts of the help and of the prompts (the program, command, argument and option descriptions, the
+     * help titles) into the user's language: given the entrypoint's module when the arguments are parsed, it returns the
+     * translating function (`commanderTranslator` of `lakutata/com/i18n` returns the one of an i18n component). The
+     * command and option names are never translated.
+     * @default the English texts
+     */
+    translate?: (module: Module) => CLITranslate | Promise<CLITranslate>;
+};
+/**
+ * Create the CLI adapter of an entrypoint, parsing the command-line arguments with commander: each CLI action
+ * (`@CLIAction`) becomes a command, and the properties of its input DTO become its options. It needs the optional peer
+ * dependency `commander` (and `@inquirer/prompts` for the interactive prompts).
+ *
+ * A property becomes a kebab-case option (`deviceId` → `--device-id <value>`), parsed by its type: a number, `true` or
+ * `false`, a JSON object, an array (`--tags <values...>`), a boolean as a flag (with a `--no-<name>` negation when it
+ * defaults to `true`); the enums, the defaults and the descriptions appear in the help. The command text may declare
+ * positional arguments, given to the properties of their names (`'copy <files...> [target]'`), and its leading words
+ * before the last one name its groups (`'package exe <file>'` is the command `exe` of the group `package`).
+ *
+ * The command runs once the application has launched (all its objects, its bootstrap and the other adapters are
+ * ready). Its result is written to stdout (see `format`; an `EventsResult` writes each event's data, a `FileResult`
+ * the file's bytes); a failure writes `error: <message>` to stderr and ends with the code 1. Then the application exits
+ * with the command's code (see `exit`). When the entrypoint stops first, a command not started yet does not run, and
+ * the prompts and the event streams end.
+ * @param options The adapter options; by default it parses `process.argv`, prompts in a terminal, and exits the
+ * application once the command ended.
+ * @returns The adapter, to give to the `cli` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application, DTO} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {CLIAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {commanderCLIEntrypoint} from 'lakutata/adapter/commander'
+ *
+ * class GreetDTO extends DTO {
+ *     @Expect(DTO.String().required().description('The name to greet'))
+ *     public name!: string
+ *
+ *     @Expect(DTO.Number().integer().optional().default(1).description('How many times'))
+ *     public times?: number
+ *
+ *     @Expect(DTO.Boolean().optional().default(false))
+ *     public loud?: boolean
+ * }
+ *
+ * class GreetController extends Controller {
+ *     //tool greet Ada --times 2 --loud
+ *     @CLIAction('greet <name>', GreetDTO)
+ *     public async greet(input: GreetDTO): Promise<string> {
+ *         const text: string = `Hello, ${input.name}`
+ *         return (input.loud ? text.toUpperCase() : text).repeat(input.times ?? 1)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'tool.app',
+ *     name: 'Tool',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [GreetController],
+ *             cli: commanderCLIEntrypoint({bin: 'tool', description: 'A greeting tool', version: '1.0.0'})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function commanderCLIEntrypoint(options?: CommanderCLIEntrypointOptions): EntrypointAdapter<CLIContext>;

package/dist/types/adapter/commander/Prompt.d.ts

@@ -0,0 +1,22 @@
+import type { ChannelActionInfo } from '../../channel/EntrypointAdapter.js';
+/**
+ * The streams of the prompts
+ */
+export type PromptStreams = {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    signal: AbortSignal;
+};
+/**
+ * Load the prompts
+ */
+export declare function loadPrompts(): Promise<any>;
+/**
+ * Prompt for the required properties missing from the input of an action, when @inquirer/prompts is installed
+ * @param action
+ * @param data
+ * @param streams
+ * @param describe the description of a property in the language of the user
+ * @param say the text of the prompts in the language of the user
+ */
+export declare function prompt(action: ChannelActionInfo, data: Record<string, unknown>, streams: PromptStreams, describe?: (property: string) => string | undefined, say?: (key: string, text: string) => string): Promise<void>;

package/dist/types/adapter/commander/Width.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The width of a text in a terminal, the wide characters taking two columns
+ * @param text
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Wrap a text to a width, as commander does, the lines of wide characters wrapped between them
+ * @param text
+ * @param width
+ * @param minimum the width under which the text is not wrapped
+ */
+export declare function boxWrap(text: string, width: number, minimum?: number): string;

package/dist/types/adapter/electron/ElectronIPCServiceEntrypoint.d.ts

@@ -0,0 +1,203 @@
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { ServiceContext } from '../../context/ServiceContext.js';
+/**
+ * The part of Electron's `WebContents` (a renderer) that {@link electronIPCServiceEntrypoint} uses: the sender of the
+ * invocations and the receiver of the events pushed to its pages.
+ */
+export type IPCSender = {
+    /**
+     * Listen once to the renderer's destruction, which aborts its requests in progress and removes its clients.
+     * @param event The `'destroyed'` event.
+     * @param listener Called when the renderer is destroyed.
+     */
+    once(event: 'destroyed', listener: () => void): unknown;
+    /**
+     * Remove a `'destroyed'` listener (`removeListener` is used without it).
+     * @param event The `'destroyed'` event.
+     * @param listener The listener to remove.
+     */
+    off?(event: 'destroyed', listener: () => void): unknown;
+    /**
+     * Remove a `'destroyed'` listener, when `off` is missing.
+     * @param event The `'destroyed'` event.
+     * @param listener The listener to remove.
+     */
+    removeListener?(event: 'destroyed', listener: () => void): unknown;
+    /**
+     * Send a message to the renderer's main frame, used to push an event to a client without a known frame.
+     * @param channel The IPC channel.
+     * @param args The message's arguments.
+     */
+    send?(channel: string, ...args: unknown[]): void;
+    /**
+     * Send a message to a frame of the renderer, used to push an event to the page of a client.
+     * @param frame The frame's process id and frame id.
+     * @param channel The IPC channel.
+     * @param args The message's arguments.
+     */
+    sendToFrame?(frame: [number, number], channel: string, ...args: unknown[]): void;
+    /**
+     * Tell whether the renderer is destroyed; its clients are then dropped instead of receiving the events.
+     * @returns Whether the renderer is destroyed.
+     */
+    isDestroyed?(): boolean;
+};
+/**
+ * The part of Electron's `IpcMainInvokeEvent` that {@link electronIPCServiceEntrypoint} uses, given to the service
+ * actions through {@link ipcEventOfContext}.
+ */
+export type IPCInvokeEvent = {
+    /**
+     * The renderer that invoked.
+     */
+    readonly sender: IPCSender;
+    /**
+     * The id of the renderer process of the invoking frame.
+     */
+    readonly processId?: number;
+    /**
+     * The id of the invoking frame within its process.
+     */
+    readonly frameId?: number;
+    /**
+     * The invoking frame; a frame without `parent` is the main frame of its window.
+     */
+    readonly senderFrame?: {
+        readonly parent?: unknown;
+    } | null;
+};
+/**
+ * The part of Electron's `ipcMain` that {@link electronIPCServiceEntrypoint} uses (give a stand-in in the tests).
+ */
+export type IPCMain = {
+    /**
+     * Handle the invocations of a channel (`ipcRenderer.invoke`).
+     * @param channel The IPC channel.
+     * @param listener Answers an invocation with its result.
+     */
+    handle(channel: string, listener: (event: any, ...args: any[]) => unknown): void;
+    /**
+     * Remove the handler of a channel, when the adapter closes.
+     * @param channel The IPC channel.
+     */
+    removeHandler(channel: string): void;
+    /**
+     * Listen to the messages of a channel (`ipcRenderer.send`), used for the event subscriptions; without it, the pages
+     * are registered as clients only when they invoke with their id.
+     * @param channel The IPC channel.
+     * @param listener Called with each message.
+     */
+    on?(channel: string, listener: (event: any, ...args: any[]) => void): unknown;
+    /**
+     * Remove the listeners of a channel, when the adapter closes.
+     * @param channel The IPC channel.
+     */
+    removeAllListeners?(channel: string): unknown;
+};
+/**
+ * The options of {@link electronIPCServiceEntrypoint}.
+ */
+export type ElectronIPCServiceEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several service adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The IPC channel of the requests (`ipcRenderer.invoke(channel, data, clientId)`). The events pushed to the pages are
+     * sent on `<channel>:event`, and a page subscribes to them by sending its client id on `<channel>:subscribe`.
+     * @default 'lakutata:service'
+     */
+    channel?: string;
+    /**
+     * The `ipcMain` to serve the requests on.
+     * @default the `ipcMain` of Electron's main process
+     */
+    ipcMain?: IPCMain;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+};
+/**
+ * Get the IPC event of a service action's request, when {@link electronIPCServiceEntrypoint} serves it (to reach the
+ * invoking renderer or frame).
+ * @param context The service action's context (`this.context` in a controller).
+ * @returns The IPC event (Electron's `IpcMainInvokeEvent`, typed as `Event`), or `undefined` when another adapter serves
+ * the request.
+ * @example
+ * ```typescript
+ * import {Controller, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ipcEventOfContext} from 'lakutata/adapter/electron'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import type {IpcMainInvokeEvent} from 'electron'
+ *
+ * class WindowController extends Controller {
+ *     //ipcRenderer.invoke('lakutata:service', {cmd: 'window.url'})
+ *     @ServiceAction({cmd: 'window.url'})
+ *     public async url(): Promise<string | undefined> {
+ *         return ipcEventOfContext<IpcMainInvokeEvent>(this.context as ServiceContext)?.sender.getURL()
+ *     }
+ * }
+ * ```
+ */
+export declare function ipcEventOfContext<Event extends IPCInvokeEvent = IPCInvokeEvent>(context: ServiceContext): Event | undefined;
+/**
+ * Create a service adapter of an entrypoint served over Electron's IPC, in the main process. It needs the optional
+ * peer dependency `electron`: without the `ipcMain` option, the entrypoint fails to start outside Electron's main
+ * process.
+ *
+ * A renderer invokes the channel with the action's pattern and input, and optionally its client id:
+ * `ipcRenderer.invoke('lakutata:service', {cmd: 'echo', text: 'hi'}, clientId)`. The invocation resolves to
+ * `{success, error, payload}` (see `ServiceResponseCodec`): `payload` is the result, or `error` the whole error object
+ * when the action failed (no matching action, validation…).
+ *
+ * Each page is a client, identified by the id it gives (a non-empty string of at most 200 characters), which its
+ * requests carry as `ServiceContext.clientId`. A page registers by sending its id on `<channel>:subscribe` (or with
+ * any invocation giving it); a page reloaded in the same frame replaces its previous id. The events pushed by
+ * `Entrypoint.notify` and `Entrypoint.broadcast` are sent to the page's frame on `<channel>:event` with the event name
+ * and its arguments array. A destroyed renderer drops its clients.
+ *
+ * When a renderer is destroyed, its requests in progress are aborted (their abort signal fires). When the entrypoint
+ * stops, the new invocations resolve to an `EntrypointStoppedException` error; once the requests in progress end, the
+ * IPC handlers are removed.
+ * @param options The adapter options; by default it serves the channel `'lakutata:service'` on Electron's `ipcMain`.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {electronIPCServiceEntrypoint} from 'lakutata/adapter/electron'
+ * import type {IpcRenderer, IpcRendererEvent} from 'electron'
+ *
+ * class EchoController extends Controller {
+ *     @ServiceAction({cmd: 'echo'})
+ *     public async echo(input: {text: string}): Promise<string> {
+ *         return input.text
+ *     }
+ * }
+ *
+ * //In the main process
+ * Application.run({
+ *     id: 'desktop.app',
+ *     name: 'Desktop',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [EchoController],
+ *             service: electronIPCServiceEntrypoint()
+ *         })
+ *     }
+ * })
+ *
+ * //In the preload script of a window
+ * declare const ipcRenderer: IpcRenderer
+ * const clientId: string = crypto.randomUUID()
+ * //The events pushed by entrypoint.notify(clientId, 'progress', 50)
+ * ipcRenderer.on('lakutata:service:event', (event: IpcRendererEvent, name: string, args: unknown[]): void => console.log(name, ...args))
+ * ipcRenderer.send('lakutata:service:subscribe', clientId)
+ * //{success: true, error: null, payload: 'hi'}
+ * console.log(await ipcRenderer.invoke('lakutata:service', {cmd: 'echo', text: 'hi'}, clientId))
+ * ```
+ */
+export declare function electronIPCServiceEntrypoint(options?: ElectronIPCServiceEntrypointOptions): EntrypointAdapter<ServiceContext>;

package/dist/types/adapter/express/ExpressHTTPEntrypoint.d.ts

@@ -0,0 +1,172 @@
+import { type Express, type Request, type RequestHandler } from 'express';
+import { type Server, type ServerOptions } from 'node:http';
+import type { Module } from '@lakutata/core';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { HTTPContext } from '../../context/HTTPContext.js';
+import { ExpressResponder } from './Responders.js';
+/**
+ * What the `before` hook of {@link expressHTTPEntrypoint} receives besides the express application: the entrypoint's
+ * module, the HTTP server (not listening yet) and the routes the actions will occupy.
+ */
+export type ExpressHookContext = {
+    /**
+     * The module owning the entrypoint, to get the application's objects from (`await module.getObject('db')`).
+     */
+    readonly module: Module;
+    /**
+     * The HTTP server serving the express application. It does not listen yet when the hook runs; attach other servers
+     * to it there (such as a socket.io server, see the `server` option of `socketIOServiceEntrypoint`).
+     */
+    readonly server: Server;
+    /**
+     * Each action route mapped to its HTTP methods, in lower case as declared (`'/users/:id'` → `{'get', 'delete'}`).
+     */
+    readonly routes: Map<string, Set<string>>;
+    /**
+     * The first segment of each action route (`'/device'`, `'/user'`…). A route starting with a parameter (`/:id`)
+     * adds none.
+     */
+    readonly actionPrefixes: string[];
+    /**
+     * Tell whether a request path belongs to the actions: it equals one of the action prefixes or starts with one
+     * followed by `/`.
+     */
+    readonly isActionPath: (requestPath: string) => boolean;
+};
+/**
+ * The options of {@link expressHTTPEntrypoint}.
+ */
+export type ExpressHTTPEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several HTTP adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The port the server listens on; 0 picks a random free port. The entrypoint fails to start when the port is in use.
+     * @default 80
+     */
+    port?: number;
+    /**
+     * The host or address the server listens on.
+     * @default all the interfaces
+     */
+    host?: string;
+    /**
+     * The options of the Node.js HTTP server (`keepAliveTimeout`, `headersTimeout`, `requestTimeout`, in milliseconds…).
+     */
+    server?: ServerOptions & {
+        keepAliveTimeout?: number;
+        headersTimeout?: number;
+        requestTimeout?: number;
+    };
+    /**
+     * An existing express application to add the action routes to.
+     * @default a new express application
+     */
+    app?: Express;
+    /**
+     * The JSON and URL-encoded body parsers, with their size limit (bytes, or a text such as `'5mb'`); a larger body is
+     * answered with an error (413). `false` installs no parser, leaving the parsing to the application. The parsers are
+     * installed after the `before` hook, so the middlewares added there do not see a parsed body.
+     * @default {limit: '1mb'}
+     */
+    body?: false | {
+        limit?: string | number;
+    };
+    /**
+     * Build an action's input from a request. The route parameters are always merged over its result.
+     * @default the query parameters, then the properties of an object body over them
+     */
+    input?: (request: Request) => Record<string, unknown>;
+    /**
+     * How the results and the errors of the actions are written.
+     * @default JSONResponder
+     */
+    respond?: ExpressResponder;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Run before the action routes are added, to add the application's own express middlewares and routes (they take
+     * precedence over the actions). A failure fails the entrypoint start.
+     */
+    before?: (app: Express, context: ExpressHookContext) => void | Promise<void>;
+    /**
+     * The handler of the requests that match no action and whose path is outside the action prefixes, such as the pages
+     * of a web application (see {@link staticUI}). The unmatched requests inside the action prefixes, and all of them
+     * without a fallback, are answered with a `RouteNotFoundException` (404).
+     */
+    fallback?: RequestHandler;
+    /**
+     * Run when the adapter stops, after the server is closed.
+     */
+    stop?: () => void | Promise<void>;
+    /**
+     * The interval between the comments keeping the event streams (`EventsResult`) alive through the proxies, in
+     * milliseconds.
+     * @default 15000
+     */
+    heartbeat?: number;
+};
+/**
+ * Create the HTTP adapter of an entrypoint served by an express application: each HTTP action (`@GET`, `@POST`,
+ * `@HTTPAction`…) becomes an express route. It needs the optional peer dependency `express`.
+ *
+ * An action's input is the request's query and body (see the `input` option) with the route parameters merged over
+ * them. Its result is written by the responder (JSON by default, 204 for no result); a `StatusResult` sets the status
+ * and the headers, a `FileResult` sends a file, a buffer or a stream (304 when its ETag matches `If-None-Match`), and an
+ * `EventsResult` streams Server-Sent Events. An action that writes the response itself (through
+ * `HTTPContext.response`) is left alone. The errors are written by the responder with their status (400 for the
+ * validation failures, 500 by default).
+ *
+ * When the client disconnects before the response, the action's abort signal fires and nothing is written. When the
+ * entrypoint stops, the server stops accepting connections, the event streams end, and the requests in progress are
+ * given up to one second after they settle to send their responses before the remaining connections are closed.
+ * @param options The adapter options; by default it listens on port 80 of all the interfaces with a new express
+ * application.
+ * @returns The adapter, to give to the `http` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET, POST} from 'lakutata/decorator/ctrl'
+ * import {expressHTTPEntrypoint, staticUI} from 'lakutata/adapter/express'
+ *
+ * class UserController extends Controller {
+ *     //GET /users/1?verbose=true: the route parameter id merged over the query
+ *     @GET('/users/:id')
+ *     public async get(input: {id: string, verbose?: string}): Promise<{id: string}> {
+ *         return {id: input.id}
+ *     }
+ *
+ *     //POST /users with the JSON body {"name": "Ada"}
+ *     @POST('/users')
+ *     public async create(input: {name: string}): Promise<{name: string}> {
+ *         return {name: input.name}
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 body: {limit: '5mb'},
+ *                 //The application's own routes, before the actions
+ *                 before: (app): void => {
+ *                     app.get('/health', (request, response): void => void response.send('ok'))
+ *                 },
+ *                 //The pages of the UI built in ./ui/dist, for the paths outside /users
+ *                 fallback: staticUI('./ui/dist')
+ *             })
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function expressHTTPEntrypoint(options?: ExpressHTTPEntrypointOptions): EntrypointAdapter<HTTPContext>;