oc-fastify-server-adapter 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# oc-fastify-server-adapter
+
+Fastify HTTP server adapter for the OC registry. The adapter is opt-in and implements OC's neutral `HttpServerAdapter` interface.
+
+## Installation
+
+```sh
+npm install oc-fastify-server-adapter fastify
+```
+
+`oc` is a peer dependency. Use this adapter with an OC version that exports the HTTP server adapter types (`>=0.50.56`).
+
+## Usage
+
+```js
+const oc = require('oc');
+const createFastifyAdapter = require('oc-fastify-server-adapter').default;
+
+const registry = oc.Registry({
+  // regular OC registry options...
+  server: {
+    adapter: createFastifyAdapter,
+    options: {
+      host: '0.0.0.0',
+      port: 3030,
+      trustProxy: true
+    }
+  }
+});
+```
+
+`options.host` defaults to `0.0.0.0`, matching Node/Express `server.listen(port)` behavior. Set it to `127.0.0.1` or another interface to bind more narrowly.
+
+## Opt-in contract and differences from Express
+
+- `registry.start()` returns a Fastify instance as `app`, not an Express application. Code that reaches into `app` must use Fastify APIs.
+- `server.httpServer()` and the `{ server }` value returned by `registry.start()` are the underlying Node `http.Server`.
+- User routes are registered through Fastify's router. OC route patterns such as `:param` and `*splat` are normalized, but advanced Express-only route syntax is not supported.
+- `fromConnect()` supports common Connect middleware, including middleware that ends the response without calling `next()`. Middleware that depends on Express-specific request/response APIs may still need changes.
+- JSON and urlencoded body limits follow the OC/Express configuration. Gzip, deflate, and brotli encoded request bodies are inflated before Fastify parses them.
+- Urlencoded bodies use `qs` parsing to match Express `extended: true` semantics. Query strings use Node's `querystring` parser to match Express 5's simple parser.
+- Cookies use OC/Express-style options. `maxAge` is accepted in milliseconds and translated to Fastify's seconds-based serializer, with `Path=/` as the default. Signed cookies are not supported unless the adapter grows a Fastify cookie secret option.
+- Multipart uploads are normalized to OC's uploaded file shape. Oversized fields return a `LIMIT_FIELD_VALUE`-style 413 instead of silently truncating.
+- Strong ETags and 304 conditional responses are enabled to match the Express registry.
+- `OPTIONS` requests are handled by the adapter so OC CORS middleware can answer preflight requests. The `Allow` header is scoped to matching routes when possible; unmatched `OPTIONS` paths still receive the global adapter method set for preflight compatibility.
+- Handler errors are rendered by OC's configured error handler. The Fastify adapter returns `text/html` error bodies when OC enables the error handler, but default Fastify 404/error body shapes can differ from Express for requests outside OC routes.
+- Non-empty OC route handler chains must eventually send a response. This matches existing OC callback-style handlers; empty handler arrays return 404 defensively.
+- Logging uses Fastify response timing, so formatting is not byte-for-byte identical to Morgan's Express output.

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import type http from 'node:http';
+type CookieOptions = {
+    domain?: string;
+    encode?: (value: string) => string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    partitioned?: boolean;
+    path?: string;
+    priority?: 'low' | 'medium' | 'high';
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+    secure?: boolean;
+    signed?: boolean;
+};
+type Method = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+type UploadedFile = {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size: number;
+    destination: string;
+    filename: string;
+    path: string;
+    buffer?: Buffer;
+    stream?: NodeJS.ReadableStream;
+    truncated?: boolean;
+};
+type OcRequest = {
+    method: string;
+    url: string;
+    path: string;
+    originalUrl: string;
+    protocol: string;
+    secure: boolean;
+    ip: string;
+    headers: http.IncomingHttpHeaders;
+    params: Record<string, string>;
+    query: Record<string, unknown>;
+    body: unknown;
+    cookies: Record<string, string>;
+    files?: UploadedFile[] | Record<string, UploadedFile[]>;
+    user?: string;
+    routeId: string;
+    get(header: string): string | undefined;
+    raw: http.IncomingMessage;
+};
+type OcResponse = {
+    conf: any;
+    errorCode?: string;
+    errorDetails?: string;
+    statusCode: number;
+    status(code: number): OcResponse;
+    json(body: unknown): void;
+    send(body: unknown): void;
+    set(field: string | Record<string, string>, value?: string): OcResponse;
+    header(name: string, value: string): OcResponse;
+    setHeader(name: string, value: string): OcResponse;
+    removeHeader(name: string): OcResponse;
+    type(mime: string): OcResponse;
+    cookie(name: string, value: string, opts?: CookieOptions): OcResponse;
+    redirect(url: string): void;
+    end(chunk?: unknown): void;
+    stream(readable: NodeJS.ReadableStream): void;
+    raw: http.ServerResponse;
+};
+type OcHandler = (req: OcRequest, res: OcResponse) => void | Promise<void>;
+type ExpressMiddleware = (req: any, res: any, next: (err?: unknown) => void) => void;
+export type HttpServerAdapter = {
+    name: string;
+    enableBodyParser(opts: {
+        limit?: number | string;
+    }): void;
+    enableCookies(): void;
+    enableFileUploads(opts: {
+        tempDir: string;
+        filename: (originalName: string) => string;
+    }): void;
+    enableRequestTiming(onDone: (req: OcRequest, res: OcResponse, ms: number) => void): void;
+    enableLogging(opts: {
+        skip: (req: OcRequest, res: OcResponse) => boolean;
+    }): void;
+    enableErrorHandler(): void;
+    use(handler: OcHandler): void;
+    route(method: Method, path: string, id: string, handlers: OcHandler[]): void;
+    fromConnect(handler: ExpressMiddleware): OcHandler;
+    listen(opts: {
+        port: number | string;
+        timeout: number;
+        keepAliveTimeout?: number;
+    }, cb: (err?: Error) => void): void;
+    onServerError(cb: (err: Error) => void): void;
+    close(cb: (err?: Error) => void): void;
+    isListening(): boolean;
+    native(): unknown;
+    httpServer(): http.Server;
+};
+export interface FastifyServerAdapterOptions {
+    host?: string;
+    port?: number | string;
+    trustProxy?: boolean | string | string[] | number;
+}
+export default function createFastifyAdapter(options?: FastifyServerAdapterOptions | number | string): HttpServerAdapter;
+export {};

package/dist/index.js

@@ -0,0 +1,581 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createFastifyAdapter;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_querystring_1 = require("node:querystring");
+const promises_2 = require("node:stream/promises");
+const node_zlib_1 = require("node:zlib");
+const cookie_1 = __importDefault(require("@fastify/cookie"));
+const etag_1 = __importDefault(require("@fastify/etag"));
+const formbody_1 = __importDefault(require("@fastify/formbody"));
+const multipart_1 = __importDefault(require("@fastify/multipart"));
+const fastify_1 = __importDefault(require("fastify"));
+const qs_1 = require("qs");
+const ocRequestSym = Symbol('ocRequest');
+const ocResponseSym = Symbol('ocResponse');
+const timingStartSym = Symbol('timingStart');
+const multipartParsedSym = Symbol('multipartParsed');
+const defaultBodyLimit = 100 * 1024;
+function createFastifyAdapter(options) {
+    const adapterOptions = typeof options === 'object' && options !== null
+        ? options
+        : { port: options };
+    return new FastifyHttpServerAdapter(adapterOptions);
+}
+class FastifyHttpServerAdapter {
+    name = 'fastify';
+    app;
+    bodyInflationRegistered = false;
+    bodyLimit = defaultBodyLimit;
+    host;
+    routes = [];
+    optionsRoutesRegistered = false;
+    constructor(options = {}) {
+        this.host = options.host;
+        this.app = (0, fastify_1.default)({
+            bodyLimit: this.bodyLimit,
+            exposeHeadRoutes: true,
+            logger: false,
+            routerOptions: {
+                querystringParser: (str) => (0, node_querystring_1.parse)(str)
+            },
+            trustProxy: options.trustProxy
+        });
+        this.app.register(etag_1.default, { weak: false, replyWith304: true });
+    }
+    enableBodyParser(opts) {
+        this.bodyLimit = parseBodyLimit(opts.limit);
+        this.registerBodyInflation();
+        this.app.register(formbody_1.default, {
+            bodyLimit: this.bodyLimit,
+            parser: (body) => (0, qs_1.parse)(body)
+        });
+    }
+    enableCookies() {
+        this.app.register(cookie_1.default);
+    }
+    enableFileUploads(opts) {
+        this.app.register(multipart_1.default, {
+            limits: {
+                fieldSize: 10,
+                fileSize: Number.MAX_SAFE_INTEGER
+            }
+        });
+        this.app.addHook('preHandler', async (request) => {
+            const req = request;
+            if (req[multipartParsedSym] ||
+                typeof req.isMultipart !== 'function' ||
+                !req.isMultipart()) {
+                return;
+            }
+            req[multipartParsedSym] = true;
+            await (0, promises_1.mkdir)(opts.tempDir, { recursive: true });
+            const files = [];
+            const body = {};
+            for await (const part of req.parts({
+                limits: { fieldSize: 10, fileSize: Number.MAX_SAFE_INTEGER }
+            })) {
+                if (part.type === 'file') {
+                    const originalName = part.filename || 'file';
+                    const filename = opts.filename(originalName);
+                    const destination = opts.tempDir;
+                    const filePath = node_path_1.default.join(destination, filename);
+                    await (0, promises_2.pipeline)(part.file, (0, node_fs_1.createWriteStream)(filePath));
+                    const fileStats = await (0, promises_1.stat)(filePath);
+                    files.push({
+                        destination,
+                        encoding: part.encoding,
+                        fieldname: part.fieldname,
+                        filename,
+                        mimetype: part.mimetype,
+                        originalname: originalName,
+                        path: filePath,
+                        size: fileStats.size,
+                        stream: part.file,
+                        truncated: part.file.truncated
+                    });
+                }
+                else {
+                    if (part.valueTruncated) {
+                        throw fastifyMultipartFieldLimitError(part.fieldname);
+                    }
+                    assignBodyField(body, part.fieldname, part.value);
+                }
+            }
+            req.body = body;
+            this.toOcRequest(req).files = files;
+        });
+    }
+    enableRequestTiming(onDone) {
+        this.app.addHook('onRequest', (request, _reply, done) => {
+            request[timingStartSym] =
+                process.hrtime.bigint();
+            done();
+        });
+        this.app.addHook('onResponse', (request, reply, done) => {
+            const req = request;
+            const start = req[timingStartSym] ?? process.hrtime.bigint();
+            const ms = Number(process.hrtime.bigint() - start) / 1_000_000;
+            onDone(this.toOcRequest(req), this.toOcResponse(reply), ms);
+            done();
+        });
+    }
+    enableLogging(opts) {
+        this.app.addHook('onResponse', (request, reply, done) => {
+            const req = this.toOcRequest(request);
+            const res = this.toOcResponse(reply);
+            let skip = false;
+            try {
+                skip = opts.skip(req, res);
+            }
+            catch {
+                skip = false;
+            }
+            if (!skip) {
+                console.log(`${req.method} ${req.url} ${res.statusCode} - ${Math.round(reply.elapsedTime)} ms`);
+            }
+            done();
+        });
+    }
+    enableErrorHandler() {
+        this.app.setErrorHandler((error, _request, reply) => {
+            const err = error;
+            const statusCode = typeof err.statusCode === 'number' ? err.statusCode : 500;
+            reply
+                .code(statusCode)
+                .type('text/html; charset=utf-8')
+                .send(err.stack || err.message || String(error));
+        });
+    }
+    use(handler) {
+        this.app.addHook('preHandler', async (request, reply) => {
+            const ocReq = this.toOcRequest(request);
+            const ocRes = this.toOcResponse(reply);
+            await handler(ocReq, ocRes);
+        });
+    }
+    route(method, routePath, id, handlers) {
+        const url = toFastifyRoutePath(routePath);
+        this.routes.push({ method, path: url });
+        this.app.route({
+            bodyLimit: this.bodyLimit,
+            handler: (request, reply) => {
+                const ocReq = this.toOcRequest(request, id);
+                const ocRes = this.toOcResponse(reply);
+                void this.runRouteHandlers(handlers, ocReq, ocRes).catch((err) => {
+                    if (!reply.sent) {
+                        reply.send(err);
+                    }
+                });
+                return reply;
+            },
+            method: method.toUpperCase(),
+            url
+        });
+    }
+    fromConnect(handler) {
+        return (req, res) => new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (err) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            };
+            const cleanup = () => {
+                res.raw.off('finish', onFinish);
+                res.raw.off('close', onFinish);
+                res.raw.off('error', onError);
+            };
+            const onFinish = () => finish();
+            const onError = (err) => finish(err);
+            res.raw.once('finish', onFinish);
+            res.raw.once('close', onFinish);
+            res.raw.once('error', onError);
+            try {
+                handler(req, res, (err) => finish(err));
+                if (isResponseSent(res)) {
+                    finish();
+                }
+            }
+            catch (err) {
+                finish(err);
+            }
+        });
+    }
+    listen(opts, cb) {
+        this.registerOptionsRoutes();
+        this.app.server.timeout = opts.timeout;
+        if (opts.keepAliveTimeout) {
+            this.app.server.keepAliveTimeout = opts.keepAliveTimeout;
+        }
+        let port;
+        try {
+            port = normalisePort(opts.port);
+        }
+        catch (err) {
+            cb(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        this.app.listen({ host: this.host ?? '0.0.0.0', port }, (err) => cb(err ?? undefined));
+    }
+    onServerError(cb) {
+        this.app.server.on('error', cb);
+    }
+    close(cb) {
+        this.app.close().then(() => cb(), cb);
+    }
+    isListening() {
+        return this.app.server.listening;
+    }
+    native() {
+        return this.app;
+    }
+    httpServer() {
+        return this.app.server;
+    }
+    async runRouteHandlers(handlers, req, res) {
+        if (handlers.length === 0) {
+            res.status(404).end();
+            return;
+        }
+        for (const handler of handlers) {
+            await handler(req, res);
+            if (isResponseSent(res)) {
+                return;
+            }
+        }
+    }
+    registerBodyInflation() {
+        if (this.bodyInflationRegistered) {
+            return;
+        }
+        this.bodyInflationRegistered = true;
+        this.app.addHook('preParsing', (request, _reply, payload, done) => {
+            const encoding = String(request.headers['content-encoding'] || '').toLowerCase();
+            const decoder = encoding === 'gzip'
+                ? (0, node_zlib_1.createGunzip)()
+                : encoding === 'deflate'
+                    ? (0, node_zlib_1.createInflate)()
+                    : encoding === 'br'
+                        ? (0, node_zlib_1.createBrotliDecompress)()
+                        : undefined;
+            if (!decoder) {
+                done(null, payload);
+                return;
+            }
+            Object.defineProperty(decoder, 'receivedEncodedLength', {
+                get: () => decoder.bytesWritten
+            });
+            done(null, payload.pipe(decoder));
+        });
+    }
+    toOcRequest(request, routeId) {
+        const cached = request[ocRequestSym];
+        const params = normaliseParams(request.params);
+        const cookies = normaliseCookies(request.cookies);
+        const originalUrl = request.originalUrl || request.url;
+        if (cached) {
+            Object.assign(cached, {
+                body: request.body,
+                cookies,
+                headers: request.headers,
+                ip: request.ip,
+                method: request.method,
+                originalUrl,
+                params,
+                path: getPath(request.url),
+                protocol: request.protocol,
+                query: request.query,
+                routeId: routeId ?? cached.routeId,
+                secure: request.protocol === 'https',
+                url: request.url
+            });
+            return cached;
+        }
+        const ocReq = {
+            body: request.body,
+            cookies,
+            get: (header) => getHeader(request, header),
+            headers: request.headers,
+            ip: request.ip,
+            method: request.method,
+            originalUrl,
+            params,
+            path: getPath(request.url),
+            protocol: request.protocol,
+            query: request.query,
+            raw: request.raw,
+            routeId: routeId ?? '',
+            secure: request.protocol === 'https',
+            url: request.url
+        };
+        request[ocRequestSym] = ocReq;
+        return ocReq;
+    }
+    toOcResponse(reply) {
+        const res = reply;
+        if (!res[ocResponseSym]) {
+            res[ocResponseSym] = new FastifyOcResponse(reply);
+        }
+        return res[ocResponseSym];
+    }
+    registerOptionsRoutes() {
+        if (this.optionsRoutesRegistered) {
+            return;
+        }
+        this.optionsRoutesRegistered = true;
+        const handler = (request, reply) => {
+            reply.header('Allow', this.getAllowHeader(getPath(request.url))).send('');
+        };
+        this.app.route({ method: 'OPTIONS', url: '/', handler });
+        this.app.route({ method: 'OPTIONS', url: '/*', handler });
+    }
+    getAllowHeader(pathname) {
+        const matchingRoutes = this.routes.filter((route) => routePathMatches(route.path, pathname));
+        const routes = matchingRoutes.length > 0 ? matchingRoutes : this.routes;
+        const methods = new Set(['OPTIONS']);
+        for (const route of routes) {
+            methods.add(route.method.toUpperCase());
+            if (route.method === 'get') {
+                methods.add('HEAD');
+            }
+        }
+        return ['GET', 'HEAD', 'PUT', 'POST', 'PATCH', 'DELETE', 'OPTIONS']
+            .filter((method) => methods.has(method))
+            .join(', ');
+    }
+}
+class FastifyOcResponse {
+    reply;
+    conf;
+    errorCode;
+    errorDetails;
+    raw;
+    hasSent = false;
+    constructor(reply) {
+        this.reply = reply;
+        this.raw = reply.raw;
+    }
+    get statusCode() {
+        return this.reply.statusCode;
+    }
+    set statusCode(code) {
+        this.reply.code(code);
+    }
+    get sent() {
+        return this.hasSent || this.reply.sent || this.raw.writableEnded;
+    }
+    status(code) {
+        this.reply.code(code);
+        return this;
+    }
+    json(body) {
+        this.hasSent = true;
+        this.reply.type('application/json; charset=utf-8').send(body);
+    }
+    send(body) {
+        if (typeof body === 'string' && !this.reply.hasHeader('content-type')) {
+            this.reply.type('text/html; charset=utf-8');
+        }
+        this.hasSent = true;
+        this.reply.send(body);
+    }
+    set(field, value) {
+        if (typeof field === 'string') {
+            this.reply.header(field, value);
+        }
+        else {
+            this.reply.headers(field);
+        }
+        return this;
+    }
+    header(name, value) {
+        return this.set(name, value);
+    }
+    setHeader(name, value) {
+        return this.set(name, value);
+    }
+    removeHeader(name) {
+        this.reply.removeHeader(name);
+        return this;
+    }
+    type(mime) {
+        this.reply.type(mime);
+        return this;
+    }
+    cookie(name, value, opts) {
+        this.reply.cookie(name, String(value), toFastifyCookieOptions(opts));
+        return this;
+    }
+    redirect(url) {
+        this.hasSent = true;
+        this.reply.redirect(url);
+    }
+    end(chunk) {
+        this.hasSent = true;
+        this.reply.send(chunk);
+    }
+    stream(readable) {
+        readable.on('error', (err) => {
+            if (this.raw.headersSent) {
+                this.raw.destroy(err instanceof Error ? err : undefined);
+            }
+            else if (!this.sent) {
+                this.status(500).end(String(err));
+            }
+        });
+        this.hasSent = true;
+        this.reply.send(readable);
+    }
+}
+function toFastifyCookieOptions(opts) {
+    if (opts?.signed) {
+        throw new Error('Signed cookies require a Fastify cookie secret');
+    }
+    const next = { ...(opts ?? {}), path: opts?.path ?? '/' };
+    if (typeof opts?.maxAge === 'number') {
+        next.maxAge = Math.floor(opts.maxAge / 1000);
+        if (!opts.expires) {
+            next.expires = new Date(Date.now() + opts.maxAge);
+        }
+    }
+    return next;
+}
+function fastifyMultipartFieldLimitError(fieldname) {
+    const err = new Error(`Field value too long: ${fieldname}`);
+    err.code = 'LIMIT_FIELD_VALUE';
+    err.statusCode = 413;
+    return err;
+}
+function parseBodyLimit(limit) {
+    if (typeof limit === 'number') {
+        return limit;
+    }
+    if (!limit) {
+        return defaultBodyLimit;
+    }
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(limit);
+    if (!match) {
+        throw new Error(`Invalid body parser limit: ${limit}`);
+    }
+    const value = Number(match[1]);
+    const unit = (match[2] || 'b').toLowerCase();
+    const multiplier = unit === 'gb'
+        ? 1024 ** 3
+        : unit === 'mb'
+            ? 1024 ** 2
+            : unit === 'kb'
+                ? 1024
+                : 1;
+    return Math.floor(value * multiplier);
+}
+function normalisePort(port) {
+    if (typeof port === 'number') {
+        return port;
+    }
+    const parsed = Number(port);
+    if (!Number.isInteger(parsed)) {
+        throw new Error(`Fastify adapter requires a numeric port, got "${port}"`);
+    }
+    return parsed;
+}
+function toFastifyRoutePath(routePath) {
+    return routePath.replace(/\*[A-Za-z0-9_]+/g, '*');
+}
+function routePathMatches(routePath, pathname) {
+    if (routePath === pathname) {
+        return true;
+    }
+    const pattern = routePath
+        .split('/')
+        .map((segment) => {
+        if (segment === '*') {
+            return '.*';
+        }
+        if (segment.startsWith(':')) {
+            return '[^/]+';
+        }
+        return escapeRegExp(segment);
+    })
+        .join('/');
+    return new RegExp(`^${pattern}$`).test(pathname);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function normaliseParams(raw) {
+    const params = {};
+    for (const [key, value] of Object.entries(raw || {})) {
+        if (typeof value === 'string') {
+            params[key] = value;
+        }
+        else if (Array.isArray(value)) {
+            params[key] = value.join('/');
+        }
+        else if (typeof value !== 'undefined') {
+            params[key] = String(value);
+        }
+    }
+    const splat = raw['*'];
+    if (typeof splat === 'string') {
+        params['splat'] = splat;
+        delete params['*'];
+    }
+    else if (Array.isArray(splat)) {
+        params['splat'] = splat.join('/');
+        delete params['*'];
+    }
+    return params;
+}
+function normaliseCookies(cookies) {
+    const result = {};
+    for (const [key, value] of Object.entries(cookies || {})) {
+        if (typeof value !== 'undefined') {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function getHeader(request, header) {
+    const value = request.headers[header.toLowerCase()];
+    if (Array.isArray(value)) {
+        return value.join(', ');
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    return value;
+}
+function getPath(url) {
+    const queryStart = url.indexOf('?');
+    return queryStart === -1 ? url : url.slice(0, queryStart);
+}
+function assignBodyField(body, field, value) {
+    if (typeof body[field] === 'undefined') {
+        body[field] = value;
+    }
+    else if (Array.isArray(body[field])) {
+        body[field].push(value);
+    }
+    else {
+        body[field] = [body[field], value];
+    }
+}
+function isResponseSent(res) {
+    return res instanceof FastifyOcResponse
+        ? res.sent
+        : res.raw.writableEnded || res.raw.headersSent;
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "oc-fastify-server-adapter",
+	"version": "0.1.0",
+	"description": "Fastify HTTP server adapter for OC",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/opencomponents/oc.git",
+		"directory": "packages/oc-fastify-server-adapter"
+	},
+	"bugs": {
+		"url": "https://github.com/opencomponents/oc/issues"
+	},
+	"homepage": "https://github.com/opencomponents/oc/tree/master/packages/oc-fastify-server-adapter#readme",
+	"keywords": [
+		"oc",
+		"opencomponents",
+		"fastify",
+		"server",
+		"adapter"
+	],
+	"author": "Matteo Figus",
+	"license": "MIT",
+	"files": [
+		"dist",
+		"!dist/test/**"
+	],
+	"scripts": {
+		"prebuild": "rimraf dist",
+		"build": "npm run lint && tsc",
+		"lint": "npx @biomejs/biome check src test",
+		"lint:apply": "npx @biomejs/biome check --write src test",
+		"test": "jest --runInBand && npm run test:integration",
+		"test-silent": "jest --runInBand --silent && npm run test:integration",
+		"test:integration": "tsc --project tsconfig.test.json && node dist/test/registry-node.js"
+	},
+	"jest": {
+		"preset": "ts-jest",
+		"testEnvironment": "node",
+		"testPathIgnorePatterns": ["/dist/"]
+	},
+	"dependencies": {
+		"@fastify/cookie": "^11.0.2",
+		"@fastify/etag": "^6.1.0",
+		"@fastify/formbody": "^8.0.2",
+		"@fastify/multipart": "^10.0.0",
+		"fastify": "^5.10.0",
+		"qs": "^6.15.3"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.0",
+		"@types/jest": "^29.5.14",
+		"@types/node": "^25.9.3",
+		"@types/qs": "^6.15.1",
+		"jest": "^29.7.0",
+		"rimraf": "^6.1.3",
+		"ts-jest": "^29.2.5",
+		"typescript": "^6.0.3"
+	}
+}