@edium/halifax 1.0.0 → 2.1.0

package/dist/adapters/http/ExpressAdapter.d.ts

@@ -1,17 +1,46 @@
-import type { Express } from 'express';
+import type { Request, Response } from 'express';
 import { Router } from 'express';
 import type { HttpMethod, HttpRouteHandler, HttpServer } from '../../core/types.js';
 import { type CrudApiOptions } from '../../core/crudRouter.js';
 import type { ResourceDefinition } from '../../core/types.js';
-/** Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface. */
+/** A route-registration method as exposed by an Express app or router (e.g. `app.get`). */
+type ExpressRouteRegistrar = (path: string, handler: (req: Request, res: Response) => void) => void;
+/**
+ * The minimal slice of an Express application or router that Halifax actually drives.
+ *
+ * Typing against this structural interface — rather than importing the concrete `Express`
+ * type from a specific `@types/express` major — is what lets {@link ExpressHttpServer}
+ * accept an Express **4** or **5** app/router interchangeably: both versions structurally
+ * satisfy it, and the published `.d.ts` no longer pins consumers to one `@types/express`
+ * version. The route methods (`get`/`post`/.../`all`) and `listen` are present and
+ * signature-compatible across both majors.
+ */
+export interface ExpressAppLike {
+    get: ExpressRouteRegistrar;
+    post: ExpressRouteRegistrar;
+    put: ExpressRouteRegistrar;
+    patch: ExpressRouteRegistrar;
+    delete: ExpressRouteRegistrar;
+    all: ExpressRouteRegistrar;
+    /** Present on an `App` but not a `Router`; when absent, {@link ExpressHttpServer.start} is a no-op. */
+    listen?: (port: number, host: string | undefined, callback: () => void) => unknown;
+}
+/**
+ * Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface.
+ *
+ * Works with both Express 4 and Express 5 — the adapter only uses the route methods,
+ * `listen`, and the request/response surface that are identical across both majors, and
+ * every route path it registers uses plain segments and `:id` named params (never `*`
+ * path wildcards), so it sidesteps the Express 5 `path-to-regexp` routing-syntax change.
+ */
 export declare class ExpressHttpServer implements HttpServer {
     private readonly app;
     /**
-     * @param app - Express application or router to register routes on.
+     * @param app - Express application or router to register routes on (Express 4 or 5).
      *   When an `App` is provided, `start()` will call `listen()`.
      *   When a `Router` is provided, `start()` is a no-op.
      */
-    constructor(app: Express | Router);
+    constructor(app: ExpressAppLike);
     /**
      * Registers a route on the Express app for the given method and path.
      * @param method - HTTP method (or `'*'` to register a catch-all via `app.all`).
@@ -37,4 +66,4 @@ export type ExpressCrudRouterOptions = CrudApiOptions;
  * @returns An Express `Router` ready to mount with `app.use('/api', router)`.
  */
 export declare function createExpressCrudRouter(resources: ResourceDefinition[], options?: ExpressCrudRouterOptions): Router;
-//# sourceMappingURL=ExpressAdapter.d.ts.map
+export {};

package/dist/adapters/http/ExpressAdapter.js

@@ -1,5 +1,13 @@
 import { Router } from 'express';
 import { registerCrudApi } from '../../core/crudRouter.js';
+/** Maps a Halifax {@link HttpMethod} to the corresponding Express registration method name. */
+const METHOD_TO_REGISTRAR = {
+    GET: 'get',
+    POST: 'post',
+    PUT: 'put',
+    PATCH: 'patch',
+    DELETE: 'delete'
+};
 /**
  * Casts Express's header map to Halifax's `Record<string, string | string[] | undefined>` type.
  * Express guarantees header names are lowercase and values are strings or string arrays,
@@ -48,11 +56,18 @@ function adaptResponse(res) {
         }
     };
 }
-/** Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface. */
+/**
+ * Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface.
+ *
+ * Works with both Express 4 and Express 5 — the adapter only uses the route methods,
+ * `listen`, and the request/response surface that are identical across both majors, and
+ * every route path it registers uses plain segments and `:id` named params (never `*`
+ * path wildcards), so it sidesteps the Express 5 `path-to-regexp` routing-syntax change.
+ */
 export class ExpressHttpServer {
     app;
     /**
-     * @param app - Express application or router to register routes on.
+     * @param app - Express application or router to register routes on (Express 4 or 5).
      *   When an `App` is provided, `start()` will call `listen()`.
      *   When a `Router` is provided, `start()` is a no-op.
      */
@@ -69,13 +84,8 @@ export class ExpressHttpServer {
         const cb = (req, res) => {
             void Promise.resolve(handler(adaptRequest(req), adaptResponse(res)));
         };
-        if (method === '*') {
-            ;
-            this.app.all(path, cb);
-            return;
-        }
-        ;
-        this.app[method.toLowerCase()](path, cb);
+        const register = method === '*' ? this.app.all : this.app[METHOD_TO_REGISTRAR[method]];
+        register.call(this.app, path, cb);
     }
     /**
      * Starts the Express server. No-op when the underlying app does not expose a `listen` method
@@ -85,8 +95,7 @@ export class ExpressHttpServer {
      */
     async start(port, host) {
         await new Promise((resolve) => {
-            if ('listen' in this.app && typeof this.app.listen === 'function') {
-                ;
+            if (typeof this.app.listen === 'function') {
                 this.app.listen(port, host, () => resolve());
                 return;
             }
@@ -106,4 +115,3 @@ export function createExpressCrudRouter(resources, options = {}) {
     registerCrudApi(new ExpressHttpServer(router), resources, options);
     return router;
 }
-//# sourceMappingURL=ExpressAdapter.js.map

package/dist/adapters/http/FastifyAdapter.d.ts

@@ -0,0 +1,93 @@
+import type { HttpMethod, HttpRouteHandler, HttpServer, ResourceDefinition } from '../../core/types.js';
+import { type CrudApiOptions } from '../../core/crudRouter.js';
+/** The minimal slice of a Fastify request Halifax reads. Fastify pre-parses the JSON body. */
+interface FastifyRequestLike {
+    method: string;
+    params: unknown;
+    query: unknown;
+    body: unknown;
+    headers: Record<string, string | string[] | undefined>;
+}
+/** The minimal slice of a Fastify reply Halifax writes. */
+interface FastifyReplyLike {
+    code(statusCode: number): FastifyReplyLike;
+    send(payload?: unknown): unknown;
+    header(name: string, value: string): unknown;
+}
+/** A Fastify route handler bound to the structural request/reply shapes above. */
+type FastifyHandlerLike = (req: FastifyRequestLike, reply: FastifyReplyLike) => unknown;
+/**
+ * The minimal slice of a Fastify instance that Halifax drives.
+ *
+ * Typing against this structural interface keeps the published `.d.ts` from pinning
+ * consumers to a specific `fastify` version, mirroring the approach used for Express.
+ */
+export interface FastifyAppLike {
+    route(opts: {
+        method: string | string[];
+        url: string;
+        handler: FastifyHandlerLike;
+    }): unknown;
+    addContentTypeParser(contentType: string | RegExp | string[], opts: {
+        parseAs: 'string' | 'buffer';
+    }, parser: (req: unknown, body: string | Buffer, done: (err: Error | null, body?: unknown) => void) => void): unknown;
+    listen(opts: {
+        port: number;
+        host?: string;
+    }): Promise<unknown>;
+}
+/**
+ * Adapts a Fastify instance to Halifax's {@link HttpServer} interface.
+ *
+ * Two Fastify-specific concerns are handled here so the resulting API behaves like the
+ * Express adapter:
+ *
+ * - **415 parity.** A catch-all content-type parser is installed so non-JSON bodies are
+ *   accepted (as raw strings) and reach the router, which then emits the structured 415
+ *   — instead of Fastify's own non-Halifax 415 error page.
+ * - **405 parity.** The `'*'` catch-all is registered for every CRUD verb *not* already
+ *   bound on the path, so unsupported methods return 405 (with the `Allow` header the
+ *   router sets) rather than Fastify's default 404.
+ */
+export declare class FastifyHttpServer implements HttpServer {
+    private readonly app;
+    /** Tracks which HTTP methods have been bound per URL, to compute the `'*'` complement. */
+    private readonly registered;
+    /**
+     * @param app - The Fastify instance (or encapsulated plugin instance) to register routes on.
+     */
+    constructor(app: FastifyAppLike);
+    /**
+     * Registers a route on the Fastify instance for the given method and path.
+     * @param method - HTTP method (or `'*'` for a catch-all spanning every unbound CRUD verb).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void;
+    /**
+     * Starts the Fastify server listening on the given port and host.
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    start(port: number, host?: string): Promise<void>;
+}
+/** Options for {@link createFastifyCrudPlugin}. Alias of {@link CrudApiOptions}. */
+export type FastifyCrudPluginOptions = CrudApiOptions;
+/** A Fastify plugin function: registered with `app.register(plugin, { prefix: '/api' })`. */
+export type FastifyCrudPlugin = (instance: FastifyAppLike) => Promise<void>;
+/**
+ * Creates a Fastify plugin that registers CRUD routes for every resource.
+ *
+ * Fastify's mounting mechanism is plugins-with-prefixes rather than mountable routers, so
+ * this is the idiomatic equivalent of {@link createExpressCrudRouter}:
+ *
+ * ```ts
+ * app.register(createFastifyCrudPlugin([postResource], { authStrategy }), { prefix: '/api/v1' })
+ * ```
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns A Fastify plugin function ready to pass to `app.register`.
+ */
+export declare function createFastifyCrudPlugin(resources: ResourceDefinition[], options?: FastifyCrudPluginOptions): FastifyCrudPlugin;
+export {};

package/dist/adapters/http/FastifyAdapter.js

@@ -0,0 +1,125 @@
+import { registerCrudApi } from '../../core/crudRouter.js';
+/**
+ * The CRUD HTTP verbs Halifax registers. Used to compute the complement set for the
+ * `'*'` catch-all so unsupported methods produce a 405 (as Express's `app.all` does)
+ * rather than Fastify's default 404. `HEAD` is intentionally excluded because Fastify
+ * auto-exposes a `HEAD` route for every `GET`; including it would collide.
+ */
+const ALL_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];
+/**
+ * Wraps a Fastify request in Halifax's framework-agnostic {@link HttpRequest}.
+ * @param req - The Fastify request to adapt.
+ * @returns A Halifax-compatible {@link HttpRequest} with the original request in `raw`.
+ */
+function adaptRequest(req) {
+    return {
+        method: req.method,
+        params: (req.params ?? {}),
+        query: (req.query ?? {}),
+        body: req.body,
+        headers: req.headers,
+        raw: req
+    };
+}
+/**
+ * Wraps a Fastify reply in Halifax's framework-agnostic {@link HttpResponse}.
+ * @param reply - The Fastify reply to adapt.
+ * @returns A Halifax-compatible {@link HttpResponse} with the original reply in `raw`.
+ */
+function adaptResponse(reply) {
+    return {
+        raw: reply,
+        status(code) {
+            reply.code(code);
+            return this;
+        },
+        json(payload) {
+            reply.send(payload);
+        },
+        send(payload) {
+            reply.send(payload);
+        },
+        setHeader(name, value) {
+            reply.header(name, value);
+        }
+    };
+}
+/**
+ * Adapts a Fastify instance to Halifax's {@link HttpServer} interface.
+ *
+ * Two Fastify-specific concerns are handled here so the resulting API behaves like the
+ * Express adapter:
+ *
+ * - **415 parity.** A catch-all content-type parser is installed so non-JSON bodies are
+ *   accepted (as raw strings) and reach the router, which then emits the structured 415
+ *   — instead of Fastify's own non-Halifax 415 error page.
+ * - **405 parity.** The `'*'` catch-all is registered for every CRUD verb *not* already
+ *   bound on the path, so unsupported methods return 405 (with the `Allow` header the
+ *   router sets) rather than Fastify's default 404.
+ */
+export class FastifyHttpServer {
+    app;
+    /** Tracks which HTTP methods have been bound per URL, to compute the `'*'` complement. */
+    registered = new Map();
+    /**
+     * @param app - The Fastify instance (or encapsulated plugin instance) to register routes on.
+     */
+    constructor(app) {
+        this.app = app;
+        // Accept any Content-Type so the router — not Fastify — owns the 415 decision. The
+        // built-in `application/json` parser still takes precedence for JSON bodies.
+        try {
+            this.app.addContentTypeParser('*', { parseAs: 'string' }, (_req, body, done) => done(null, body));
+        }
+        catch {
+            // A parser for '*' is already registered on this instance — nothing to do.
+        }
+    }
+    /**
+     * Registers a route on the Fastify instance for the given method and path.
+     * @param method - HTTP method (or `'*'` for a catch-all spanning every unbound CRUD verb).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method, path, handler) {
+        const run = (req, reply) => Promise.resolve(handler(adaptRequest(req), adaptResponse(reply)));
+        if (method === '*') {
+            const bound = this.registered.get(path) ?? new Set();
+            const complement = ALL_METHODS.filter((m) => !bound.has(m));
+            if (complement.length)
+                this.app.route({ method: complement, url: path, handler: run });
+            return;
+        }
+        const bound = this.registered.get(path) ?? new Set();
+        bound.add(method);
+        this.registered.set(path, bound);
+        this.app.route({ method, url: path, handler: run });
+    }
+    /**
+     * Starts the Fastify server listening on the given port and host.
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    async start(port, host) {
+        await this.app.listen(host ? { port, host } : { port });
+    }
+}
+/**
+ * Creates a Fastify plugin that registers CRUD routes for every resource.
+ *
+ * Fastify's mounting mechanism is plugins-with-prefixes rather than mountable routers, so
+ * this is the idiomatic equivalent of {@link createExpressCrudRouter}:
+ *
+ * ```ts
+ * app.register(createFastifyCrudPlugin([postResource], { authStrategy }), { prefix: '/api/v1' })
+ * ```
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns A Fastify plugin function ready to pass to `app.register`.
+ */
+export function createFastifyCrudPlugin(resources, options = {}) {
+    return async function halifaxCrudPlugin(instance) {
+        registerCrudApi(new FastifyHttpServer(instance), resources, options);
+    };
+}

package/dist/adapters/http/HyperExpressAdapter.d.ts

@@ -0,0 +1,82 @@
+import HyperExpress from 'hyper-express';
+import type { HttpMethod, HttpRouteHandler, HttpServer, ResourceDefinition } from '../../core/types.js';
+import { type CrudApiOptions } from '../../core/crudRouter.js';
+/**
+ * The minimal slice of a HyperExpress request Halifax reads. HyperExpress exposes an
+ * Express-flavoured API on top of uWebSockets, but — unlike Express — the request body
+ * is not pre-parsed by middleware; it is downloaded on demand via {@link json}.
+ */
+interface HyperExpressRequest {
+    method: string;
+    path_parameters: Record<string, string>;
+    query_parameters: Record<string, string>;
+    headers: Record<string, string | string[] | undefined>;
+    json<T = unknown, D = undefined>(default_value?: D): Promise<T | D>;
+}
+/** The minimal slice of a HyperExpress response Halifax writes. */
+interface HyperExpressResponse {
+    status(code: number): HyperExpressResponse;
+    json(payload: unknown): unknown;
+    send(payload?: unknown): unknown;
+    header(name: string, value: string): unknown;
+}
+/** A HyperExpress route-registration method (e.g. `app.get`). */
+type HyperExpressRouteRegistrar = (path: string, handler: (req: HyperExpressRequest, res: HyperExpressResponse) => unknown) => unknown;
+/**
+ * The minimal slice of a HyperExpress `Server` or `Router` that Halifax drives.
+ *
+ * Typing against this structural interface keeps the published `.d.ts` from pinning
+ * consumers to a specific `hyper-express` version, mirroring the approach used for Express.
+ */
+export interface HyperExpressAppLike {
+    get: HyperExpressRouteRegistrar;
+    post: HyperExpressRouteRegistrar;
+    put: HyperExpressRouteRegistrar;
+    patch: HyperExpressRouteRegistrar;
+    delete: HyperExpressRouteRegistrar;
+    /** Registers a handler for any HTTP method — HyperExpress's catch-all, used for 405 fallbacks. */
+    any: HyperExpressRouteRegistrar;
+    /** Present on a `Server` but not a `Router`; when absent, {@link HyperExpressHttpServer.start} is a no-op. */
+    listen?: (port: number, host?: string) => Promise<unknown>;
+}
+/**
+ * Adapts a HyperExpress `Server` or `Router` to Halifax's {@link HttpServer} interface.
+ *
+ * Like the Express adapter, every route uses plain segments and `:id` named params. The
+ * `'*'` catch-all maps to HyperExpress's `any()`, which matches methods not otherwise
+ * registered on the path — giving the same 405 behaviour as Express's `app.all`.
+ */
+export declare class HyperExpressHttpServer implements HttpServer {
+    private readonly app;
+    /**
+     * @param app - HyperExpress server or router to register routes on.
+     *   When a `Server` is provided, `start()` will call `listen()`.
+     *   When a `Router` is provided, `start()` is a no-op.
+     */
+    constructor(app: HyperExpressAppLike);
+    /**
+     * Registers a route on the app for the given method and path.
+     * @param method - HTTP method (or `'*'` to register a catch-all via `app.any`).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void;
+    /**
+     * Starts the server. No-op when the underlying app does not expose a `listen` method
+     * (e.g. when `app` is a `Router` mounted on an existing server).
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    start(port: number, host?: string): Promise<void>;
+}
+/** Options for {@link createHyperExpressCrudRouter}. Alias of {@link CrudApiOptions}. */
+export type HyperExpressCrudRouterOptions = CrudApiOptions;
+/**
+ * Creates a fully-wired HyperExpress `Router` with CRUD routes for every resource.
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns A HyperExpress `Router` ready to mount with `app.use('/api', router)`.
+ */
+export declare function createHyperExpressCrudRouter(resources: ResourceDefinition[], options?: HyperExpressCrudRouterOptions): InstanceType<typeof HyperExpress.Router>;
+export {};

package/dist/adapters/http/HyperExpressAdapter.js

@@ -0,0 +1,128 @@
+import HyperExpress from 'hyper-express';
+import { registerCrudApi } from '../../core/crudRouter.js';
+/** Maps a Halifax {@link HttpMethod} to the corresponding HyperExpress registration method name. */
+const METHOD_TO_REGISTRAR = {
+    GET: 'get',
+    POST: 'post',
+    PUT: 'put',
+    PATCH: 'patch',
+    DELETE: 'delete'
+};
+/** HTTP methods that may carry a request body Halifax needs to parse. */
+const BODY_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+/**
+ * Reads the first value of a (possibly array) header.
+ * @param value - The raw header value.
+ * @returns The header as a lowercase-safe string, or `''` when absent.
+ */
+function headerValue(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === 'string' ? first : '';
+}
+/**
+ * Wraps a HyperExpress request in Halifax's framework-agnostic {@link HttpRequest}.
+ *
+ * The JSON body is downloaded here (HyperExpress does not pre-parse it). Only requests
+ * that both carry a body-bearing method and declare a JSON `Content-Type` are parsed;
+ * everything else is left as `undefined`, which lets the CRUD router emit a 415 for
+ * non-JSON payloads exactly as the Express adapter (with `express.json()`) does.
+ * @param req - The HyperExpress request to adapt.
+ * @returns A Halifax-compatible {@link HttpRequest} with the original request in `raw`.
+ */
+async function adaptRequest(req) {
+    let body;
+    const contentType = headerValue(req.headers['content-type']);
+    if (BODY_METHODS.has(req.method.toUpperCase()) && contentType.includes('application/json')) {
+        try {
+            body = await req.json(undefined);
+        }
+        catch {
+            body = undefined;
+        }
+    }
+    return {
+        method: req.method,
+        params: req.path_parameters,
+        query: req.query_parameters,
+        body,
+        headers: req.headers,
+        raw: req
+    };
+}
+/**
+ * Wraps a HyperExpress response in Halifax's framework-agnostic {@link HttpResponse}.
+ * @param res - The HyperExpress response to adapt.
+ * @returns A Halifax-compatible {@link HttpResponse} with the original response in `raw`.
+ */
+function adaptResponse(res) {
+    return {
+        raw: res,
+        status(code) {
+            res.status(code);
+            return this;
+        },
+        json(payload) {
+            res.json(payload);
+        },
+        send(payload) {
+            res.send(payload);
+        },
+        setHeader(name, value) {
+            res.header(name, value);
+        }
+    };
+}
+/**
+ * Adapts a HyperExpress `Server` or `Router` to Halifax's {@link HttpServer} interface.
+ *
+ * Like the Express adapter, every route uses plain segments and `:id` named params. The
+ * `'*'` catch-all maps to HyperExpress's `any()`, which matches methods not otherwise
+ * registered on the path — giving the same 405 behaviour as Express's `app.all`.
+ */
+export class HyperExpressHttpServer {
+    app;
+    /**
+     * @param app - HyperExpress server or router to register routes on.
+     *   When a `Server` is provided, `start()` will call `listen()`.
+     *   When a `Router` is provided, `start()` is a no-op.
+     */
+    constructor(app) {
+        this.app = app;
+    }
+    /**
+     * Registers a route on the app for the given method and path.
+     * @param method - HTTP method (or `'*'` to register a catch-all via `app.any`).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method, path, handler) {
+        const cb = async (req, res) => {
+            await Promise.resolve(handler(await adaptRequest(req), adaptResponse(res)));
+        };
+        const register = method === '*' ? this.app.any : this.app[METHOD_TO_REGISTRAR[method]];
+        register.call(this.app, path, cb);
+    }
+    /**
+     * Starts the server. No-op when the underlying app does not expose a `listen` method
+     * (e.g. when `app` is a `Router` mounted on an existing server).
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    async start(port, host) {
+        if (typeof this.app.listen !== 'function')
+            return;
+        await (host ? this.app.listen(port, host) : this.app.listen(port));
+    }
+}
+/**
+ * Creates a fully-wired HyperExpress `Router` with CRUD routes for every resource.
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns A HyperExpress `Router` ready to mount with `app.use('/api', router)`.
+ */
+export function createHyperExpressCrudRouter(resources, options = {}) {
+    const router = new HyperExpress.Router();
+    registerCrudApi(new HyperExpressHttpServer(router), resources, options);
+    return router;
+}

package/dist/adapters/http/UltimateExpressAdapter.d.ts

@@ -0,0 +1,84 @@
+import ultimateExpress from 'ultimate-express';
+import type { HttpMethod, HttpRouteHandler, HttpServer, ResourceDefinition } from '../../core/types.js';
+import { type CrudApiOptions } from '../../core/crudRouter.js';
+declare const Router: typeof ultimateExpress.Router;
+/** A route-registration method as exposed by an Ultimate Express app or router (e.g. `app.get`). */
+type UltimateExpressRouteRegistrar = (path: string, handler: (req: UltimateExpressRequest, res: UltimateExpressResponse) => void) => void;
+/**
+ * The minimal slice of an Ultimate Express request Halifax reads. Ultimate Express is a
+ * drop-in, uWebSockets-backed reimplementation of the Express API, so this mirrors the
+ * Express request surface exactly.
+ */
+interface UltimateExpressRequest {
+    method: string;
+    params: Record<string, string>;
+    query: Record<string, unknown>;
+    body: unknown;
+    headers: Record<string, string | string[] | undefined>;
+}
+/** The minimal slice of an Ultimate Express response Halifax writes. */
+interface UltimateExpressResponse {
+    status(code: number): UltimateExpressResponse;
+    json(payload: unknown): unknown;
+    send(payload?: unknown): unknown;
+    setHeader(name: string, value: string): unknown;
+}
+/**
+ * The minimal slice of an Ultimate Express application or router that Halifax drives.
+ *
+ * Typing against this structural interface — rather than importing concrete types from
+ * `ultimate-express` — keeps the published `.d.ts` from pinning consumers to a specific
+ * version, exactly as {@link ExpressHttpServer} does for Express.
+ */
+export interface UltimateExpressAppLike {
+    get: UltimateExpressRouteRegistrar;
+    post: UltimateExpressRouteRegistrar;
+    put: UltimateExpressRouteRegistrar;
+    patch: UltimateExpressRouteRegistrar;
+    delete: UltimateExpressRouteRegistrar;
+    all: UltimateExpressRouteRegistrar;
+    /** Present on an `App` but not a `Router`; when absent, {@link UltimateExpressHttpServer.start} is a no-op. */
+    listen?: (port: number, host: string | undefined, callback: () => void) => unknown;
+}
+/**
+ * Adapts an Ultimate Express `App` or `Router` to Halifax's {@link HttpServer} interface.
+ *
+ * Because Ultimate Express implements the Express API, this adapter is a near-identical
+ * twin of {@link ExpressHttpServer}: it uses the same route methods, `:id` named params
+ * (never `*` path wildcards), and request/response surface. The difference is purely the
+ * underlying transport (uWebSockets), which is faster but otherwise transparent.
+ */
+export declare class UltimateExpressHttpServer implements HttpServer {
+    private readonly app;
+    /**
+     * @param app - Ultimate Express application or router to register routes on.
+     *   When an `App` is provided, `start()` will call `listen()`.
+     *   When a `Router` is provided, `start()` is a no-op.
+     */
+    constructor(app: UltimateExpressAppLike);
+    /**
+     * Registers a route on the app for the given method and path.
+     * @param method - HTTP method (or `'*'` to register a catch-all via `app.all`).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void;
+    /**
+     * Starts the server. No-op when the underlying app does not expose a `listen` method
+     * (e.g. when `app` is a `Router` mounted on an existing app).
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    start(port: number, host?: string): Promise<void>;
+}
+/** Options for {@link createUltimateExpressCrudRouter}. Alias of {@link CrudApiOptions}. */
+export type UltimateExpressCrudRouterOptions = CrudApiOptions;
+/**
+ * Creates a fully-wired Ultimate Express `Router` with CRUD routes for every resource.
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns An Ultimate Express `Router` ready to mount with `app.use('/api', router)`.
+ */
+export declare function createUltimateExpressCrudRouter(resources: ResourceDefinition[], options?: UltimateExpressCrudRouterOptions): ReturnType<typeof Router>;
+export {};