express-fastify-runtime 0.1.0

package/dist/fastify/adapters/response.js

@@ -0,0 +1,667 @@
+"use strict";
+/**
+ * FastifyReply → Express-like res.
+ * Full Express 5.x response API so existing apps work unchanged.
+ * Aligns with Express 5.2.1 (see docs/EXPRESS_REFERENCE.md); uses encodeurl for location().
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptResponse = adaptResponse;
+exports.createResponseAdapter = createResponseAdapter;
+const node_http_1 = require("node:http");
+const encodeurl_1 = __importDefault(require("encodeurl"));
+const STATUS_CODES = node_http_1.STATUS_CODES;
+function normalizeHeaderValue(value) {
+    if (Array.isArray(value))
+        return value.join(', ');
+    return String(value);
+}
+/**
+ * Record res._startAt (high-res time) the first time we send, so morgan's :response-time
+ * token has the value it normally gets from on-headers (which patches the real writeHead).
+ * Set at send time ≈ header-write time; morgan computes response-time = res._startAt - req._startAt.
+ */
+function recordStartAt(self) {
+    if (self._startAt === undefined)
+        self._startAt = process.hrtime();
+}
+/**
+ * Wrap res in a Proxy that delegates unknown properties/methods to the raw Node response.
+ * Only delegates when the value exists and is callable; never calls .bind on undefined.
+ */
+function responseProxy(res, raw) {
+    return new Proxy(res, {
+        get(target, prop) {
+            if (Object.prototype.hasOwnProperty.call(target, prop)) {
+                const v = Reflect.get(target, prop);
+                if (typeof v === 'function')
+                    return v.bind(target);
+                return v;
+            }
+            const rawVal = Reflect.get(raw, prop);
+            if (rawVal === undefined || rawVal === null)
+                return rawVal;
+            if (typeof rawVal === 'function')
+                return rawVal.bind(raw);
+            return rawVal;
+        },
+        has(target, prop) {
+            return (Object.prototype.hasOwnProperty.call(target, prop) ||
+                Reflect.has(raw, prop));
+        },
+    });
+}
+/** One-shot adapter: creates a new res per call (e.g. for adaptResponse(reply, req)). */
+function adaptResponse(fastifyReply, _fastifyReq) {
+    const raw = fastifyReply.raw;
+    const res = Object.create(raw);
+    let statusCode = 200;
+    res._locals = {};
+    // Custom 'finish'/'end' so morgan (on-finished) runs when we've sent, not when OS flushes (keep-alive fix).
+    const finishListeners = [];
+    let finishEmitted = false;
+    res.__efrFinishListeners = finishListeners;
+    res.__efrEmitFinish = () => {
+        if (finishEmitted)
+            return;
+        finishEmitted = true;
+        res.__efrFinishEmitted = true;
+        const toRun = [...finishListeners];
+        finishListeners.length = 0;
+        toRun.forEach(({ fn }) => {
+            try {
+                fn();
+            }
+            catch (_) {
+                /* ignore */
+            }
+        });
+    };
+    Object.assign(res, {
+        on(event, listener) {
+            if (event === "finish" || event === "end") {
+                finishListeners.push({ fn: listener, once: false });
+                return res;
+            }
+            return raw.on.apply(raw, arguments);
+        },
+        once(event, listener) {
+            if (event === "finish" || event === "end") {
+                finishListeners.push({ fn: listener, once: true });
+                return res;
+            }
+            return raw.once.apply(raw, arguments);
+        },
+        emit(event, ...args) {
+            if (event === "finish" || event === "end") {
+                res.__efrEmitFinish?.();
+                return true;
+            }
+            return raw.emit.apply(raw, arguments);
+        },
+    });
+    // Emit 'finish' after send so morgan/on-finished run per-request. Use double setImmediate so
+    // Fastify's sync send (writeHead + end) has run and res._startAt/status/headers are set (no " - - ms - -").
+    // Skip async work when no one listens (hot path: res.json() with no res.on('finish')).
+    function afterSend() {
+        if (finishListeners.length === 0)
+            return;
+        setImmediate(() => setImmediate(() => emitFinishNextTick(res)));
+    }
+    function emitFinishNextTick(r) {
+        if (r.__efrEmitFinish)
+            r.__efrEmitFinish();
+    }
+    res.locals = res._locals;
+    Object.defineProperty(res, 'headersSent', {
+        get() {
+            return raw.headersSent;
+        },
+        configurable: true,
+        enumerable: true,
+    });
+    res.status = function (code) {
+        statusCode = code;
+        raw.statusCode = code;
+        return res;
+    };
+    res.sendStatus = function (code) {
+        raw.statusCode = code;
+        const body = STATUS_CODES[code] || String(code);
+        fastifyReply.type('text/plain').send(body);
+        afterSend();
+        return res;
+    };
+    res.send = function (body) {
+        if (body === undefined) {
+            raw.end();
+            afterSend();
+            return res;
+        }
+        if (typeof body === 'object' && body !== null && !Buffer.isBuffer(body)) {
+            fastifyReply.type('application/json').send(body);
+            afterSend();
+            return res;
+        }
+        // Express: string defaults to html when Content-Type not set (response.js send())
+        if (typeof body === 'string' && !raw.getHeader('Content-Type')) {
+            fastifyReply.type('text/html').send(body);
+            afterSend();
+            return res;
+        }
+        fastifyReply.send(body);
+        afterSend();
+        return res;
+    };
+    res.json = function (body) {
+        fastifyReply.type('application/json').send(body);
+        afterSend();
+        return res;
+    };
+    res.jsonp = function (body) {
+        fastifyReply.type('application/json').send(body);
+        afterSend();
+        return res;
+    };
+    res.set = res.header = function (field, value) {
+        if (typeof field === 'string') {
+            raw.setHeader(field, normalizeHeaderValue(value));
+        }
+        else {
+            for (const [k, v] of Object.entries(field))
+                raw.setHeader(k, v);
+        }
+        return res;
+    };
+    res.setHeader = function (name, value) {
+        raw.setHeader(name, value);
+        return res;
+    };
+    res.removeHeader = function (name) {
+        raw.removeHeader(name);
+        return res;
+    };
+    res.append = function (field, value) {
+        const prev = raw.getHeader(field);
+        const next = prev === undefined
+            ? normalizeHeaderValue(value)
+            : [prev, value].flat().join(', ');
+        raw.setHeader(field, next);
+        return res;
+    };
+    res.get = function (field) {
+        const v = raw.getHeader(field);
+        return v === undefined ? undefined : (Array.isArray(v) ? v.join(', ') : String(v));
+    };
+    res.getHeader = function (name) {
+        return raw.getHeader(name);
+    };
+    res.type = res.contentType = function (type) {
+        if (!type.includes('/')) {
+            const mime = {
+                json: 'application/json',
+                html: 'text/html',
+                text: 'text/plain',
+                xml: 'application/xml',
+            };
+            fastifyReply.type(mime[type] || type);
+        }
+        else {
+            raw.setHeader('Content-Type', type);
+        }
+        return res;
+    };
+    res.links = function (links) {
+        const link = Object.entries(links)
+            .map(([rel, url]) => `<${url}>; rel="${rel}"`)
+            .join(', ');
+        raw.setHeader('Link', link);
+        return res;
+    };
+    res.attachment = function (filename) {
+        if (filename) {
+            raw.setHeader('Content-Disposition', `attachment; filename="${filename.replace(/"/g, '\\"')}"`);
+        }
+        else {
+            raw.setHeader('Content-Disposition', 'attachment');
+        }
+        return res;
+    };
+    res.location = function (url) {
+        if (url === 'back') {
+            const ref = _fastifyReq?.raw?.headers?.referrer ||
+                _fastifyReq?.raw?.headers?.referer;
+            url = ref || '/';
+        }
+        raw.setHeader('Location', (0, encodeurl_1.default)(url));
+        return res;
+    };
+    res.redirect = function (urlOrStatus, url) {
+        let status = 302;
+        let target;
+        if (typeof urlOrStatus === 'number') {
+            status = urlOrStatus;
+            target = url;
+        }
+        else {
+            target = urlOrStatus;
+        }
+        raw.statusCode = status;
+        raw.setHeader('Location', target);
+        fastifyReply.send();
+        return res;
+    };
+    res.vary = function (field) {
+        const v = raw.getHeader('Vary');
+        const next = v ? `${v}, ${field}` : field;
+        raw.setHeader('Vary', next);
+        return res;
+    };
+    res.cookie = function (name, val, options) {
+        const value = typeof val === 'object' ? 'j:' + JSON.stringify(val) : encodeURIComponent(String(val));
+        const parts = [`${name}=${value}`];
+        if (options) {
+            if (options.maxAge != null)
+                parts.push(`Max-Age=${options.maxAge}`);
+            if (options.path)
+                parts.push(`Path=${options.path}`);
+            if (options.domain)
+                parts.push(`Domain=${options.domain}`);
+            if (options.expires)
+                parts.push(`Expires=${options.expires.toUTCString()}`);
+            if (options.httpOnly)
+                parts.push('HttpOnly');
+            if (options.secure)
+                parts.push('Secure');
+            if (options.sameSite)
+                parts.push(`SameSite=${options.sameSite}`);
+        }
+        const setCookie = raw.getHeader('Set-Cookie');
+        const prev = setCookie
+            ? (Array.isArray(setCookie) ? setCookie.map(String) : [String(setCookie)])
+            : [];
+        raw.setHeader('Set-Cookie', [...prev, parts.join('; ')]);
+        return res;
+    };
+    res.clearCookie = function (name, options) {
+        const opts = { ...options, expires: new Date(0), maxAge: 0 };
+        res.cookie(name, '', opts);
+        return res;
+    };
+    res.end = function (chunkOrCb, encodingOrCb, cb) {
+        if (typeof chunkOrCb === 'function') {
+            raw.end(chunkOrCb);
+        }
+        else if (chunkOrCb !== undefined && chunkOrCb !== null) {
+            const enc = typeof encodingOrCb === 'string' ? encodingOrCb : undefined;
+            const done = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
+            if (enc !== undefined) {
+                raw.end(chunkOrCb, enc, done);
+            }
+            else {
+                raw.end(chunkOrCb, done);
+            }
+        }
+        else {
+            raw.end();
+        }
+        return res;
+    };
+    const RES_RENDER_HINT = 'res.render is not implemented on the Fastify lane. Wrap this handler with expressLane() so the route runs on the Express lane. See docs/FAST_PRODUCTION_CHECKLIST.md';
+    res.render = function (_view, _locals, _callback) {
+        if (process.env.NODE_ENV !== 'production') {
+            console.warn(`[express-fastify-runtime] ${RES_RENDER_HINT}`);
+        }
+        if (!raw.headersSent) {
+            fastifyReply.status(501).type('application/json').send({
+                error: 'res.render is not implemented on the Fastify lane',
+                hint: 'Wrap this handler with expressLane() so the route runs on the Express lane.',
+                docs: 'docs/FAST_PRODUCTION_CHECKLIST.md',
+            });
+        }
+        return res;
+    };
+    return responseProxy(res, raw);
+}
+/** Tell the middleware/route chain that this response has ended (so it stops waiting on next()). */
+function signalEnd(self) {
+    if (self._onEnd)
+        self._onEnd();
+}
+/**
+ * Take over the response so we can write to the raw Node stream directly (streaming/SSE,
+ * res.write/res.writeHead/res.end). reply.hijack() tells Fastify NOT to send its own response,
+ * so the handler returning undefined won't trigger a double-send. Idempotent.
+ */
+function ensureHijacked(self) {
+    if (self._hijacked)
+        return;
+    self._hijacked = true;
+    self._reply.hijack();
+}
+/**
+ * Shared response prototype: all methods/getters defined ONCE. Per-request state
+ * (_reply, _locals) lives on each instance and is read via `this`, so concurrent
+ * requests never share mutable state. This is the correctness-critical difference
+ * from the old single-shared-object adapter.
+ *
+ * Lifecycle events (finish/end/close/error) are delegated to the REAL Node response
+ * (reply.raw). This is how morgan/on-finished behave on plain Express (where res IS the
+ * ServerResponse): they fire on the actual response 'finish', so status, headers,
+ * content-length and res._startAt are all set when the log line is written. We do NOT
+ * synthesize 'finish' (the old setImmediate approach raced ahead of the real flush under
+ * concurrency, producing "- - ms - -" log lines).
+ */
+const responseProto = {
+    get locals() {
+        const self = this;
+        return self._locals ?? (self._locals = {});
+    },
+    set locals(v) {
+        this._locals = v;
+    },
+    get headersSent() {
+        return this._reply?.raw.headersSent ?? false;
+    },
+    get statusCode() {
+        return this._reply?.raw.statusCode ?? 200;
+    },
+    set statusCode(code) {
+        this._reply.raw.statusCode = code;
+    },
+    // Native response fields on-finished/morgan inspect — delegate to the real response.
+    get socket() {
+        return this._reply?.raw.socket ?? null;
+    },
+    get connection() {
+        return this._reply?.raw.socket ?? null;
+    },
+    get finished() {
+        return this._reply?.raw.writableEnded ?? false;
+    },
+    get writableEnded() {
+        return this._reply?.raw.writableEnded ?? false;
+    },
+    get writableFinished() {
+        return this._reply?.raw.writableFinished ?? false;
+    },
+    on(event, listener) {
+        this._reply.raw.on(event, listener);
+        return this;
+    },
+    addListener(event, listener) {
+        this._reply.raw.on(event, listener);
+        return this;
+    },
+    once(event, listener) {
+        this._reply.raw.once(event, listener);
+        return this;
+    },
+    prependListener(event, listener) {
+        this._reply.raw.prependListener(event, listener);
+        return this;
+    },
+    removeListener(event, listener) {
+        this._reply.raw.removeListener(event, listener);
+        return this;
+    },
+    emit(event, ...args) {
+        return this._reply.raw.emit(event, ...args);
+    },
+    status(code) {
+        this._reply.raw.statusCode = code;
+        return this;
+    },
+    sendStatus(code) {
+        const r = this._reply;
+        r.raw.statusCode = code;
+        const body = STATUS_CODES[code] || String(code);
+        recordStartAt(this);
+        r.type('text/plain').send(body);
+        signalEnd(this);
+        return this;
+    },
+    send(body) {
+        const r = this._reply;
+        const raw = r.raw;
+        recordStartAt(this);
+        if (body === undefined) {
+            raw.end();
+        }
+        else if (typeof body === 'object' && body !== null && !Buffer.isBuffer(body)) {
+            r.type('application/json').send(body);
+        }
+        else if (typeof body === 'string' && !raw.getHeader('Content-Type')) {
+            r.type('text/html').send(body);
+        }
+        else {
+            r.send(body);
+        }
+        signalEnd(this);
+        return this;
+    },
+    json(body) {
+        recordStartAt(this);
+        this._reply.type('application/json').send(body);
+        signalEnd(this);
+        return this;
+    },
+    jsonp(body) {
+        recordStartAt(this);
+        this._reply.type('application/json').send(body);
+        signalEnd(this);
+        return this;
+    },
+    set(field, value) {
+        const raw = this._reply.raw;
+        if (typeof field === 'string') {
+            raw.setHeader(field, normalizeHeaderValue(value));
+        }
+        else {
+            for (const [k, v] of Object.entries(field))
+                raw.setHeader(k, v);
+        }
+        return this;
+    },
+    header(field, value) {
+        return this.set(field, value);
+    },
+    setHeader(name, value) {
+        this._reply.raw.setHeader(name, value);
+        return this;
+    },
+    removeHeader(name) {
+        this._reply.raw.removeHeader(name);
+        return this;
+    },
+    append(field, value) {
+        const raw = this._reply.raw;
+        const prev = raw.getHeader(field);
+        const next = prev === undefined
+            ? normalizeHeaderValue(value)
+            : [prev, value].flat().join(', ');
+        raw.setHeader(field, next);
+        return this;
+    },
+    get(field) {
+        const v = this._reply.raw.getHeader(field);
+        return v === undefined ? undefined : (Array.isArray(v) ? v.join(', ') : String(v));
+    },
+    getHeader(name) {
+        return this._reply.raw.getHeader(name);
+    },
+    type(type) {
+        if (!type.includes('/')) {
+            const mime = {
+                json: 'application/json',
+                html: 'text/html',
+                text: 'text/plain',
+                xml: 'application/xml',
+            };
+            this._reply.type(mime[type] || type);
+        }
+        else {
+            this._reply.raw.setHeader('Content-Type', type);
+        }
+        return this;
+    },
+    contentType(type) {
+        return this.type(type);
+    },
+    links(links) {
+        const link = Object.entries(links)
+            .map(([rel, url]) => `<${url}>; rel="${rel}"`)
+            .join(', ');
+        this._reply.raw.setHeader('Link', link);
+        return this;
+    },
+    attachment(filename) {
+        const raw = this._reply.raw;
+        if (filename) {
+            raw.setHeader('Content-Disposition', `attachment; filename="${filename.replace(/"/g, '\\"')}"`);
+        }
+        else {
+            raw.setHeader('Content-Disposition', 'attachment');
+        }
+        return this;
+    },
+    location(url) {
+        if (url === 'back') {
+            const req = this._req;
+            const ref = req?.raw?.headers?.referrer || req?.raw?.headers?.referer;
+            url = ref || '/';
+        }
+        this._reply.raw.setHeader('Location', (0, encodeurl_1.default)(url));
+        return this;
+    },
+    redirect(urlOrStatus, url) {
+        const r = this._reply;
+        let status = 302;
+        let target;
+        if (typeof urlOrStatus === 'number') {
+            status = urlOrStatus;
+            target = url;
+        }
+        else {
+            target = urlOrStatus;
+        }
+        recordStartAt(this);
+        r.raw.statusCode = status;
+        r.raw.setHeader('Location', target);
+        r.send();
+        signalEnd(this);
+        return this;
+    },
+    vary(field) {
+        const raw = this._reply.raw;
+        const v = raw.getHeader('Vary');
+        const next = v ? `${v}, ${field}` : field;
+        raw.setHeader('Vary', next);
+        return this;
+    },
+    cookie(name, val, options) {
+        const value = typeof val === 'object' ? 'j:' + JSON.stringify(val) : encodeURIComponent(String(val));
+        const parts = [`${name}=${value}`];
+        if (options) {
+            if (options.maxAge != null)
+                parts.push(`Max-Age=${options.maxAge}`);
+            if (options.path)
+                parts.push(`Path=${options.path}`);
+            if (options.domain)
+                parts.push(`Domain=${options.domain}`);
+            if (options.expires)
+                parts.push(`Expires=${options.expires.toUTCString()}`);
+            if (options.httpOnly)
+                parts.push('HttpOnly');
+            if (options.secure)
+                parts.push('Secure');
+            if (options.sameSite)
+                parts.push(`SameSite=${options.sameSite}`);
+        }
+        const raw = this._reply.raw;
+        const setCookie = raw.getHeader('Set-Cookie');
+        const prev = setCookie
+            ? (Array.isArray(setCookie) ? setCookie.map(String) : [String(setCookie)])
+            : [];
+        raw.setHeader('Set-Cookie', [...prev, parts.join('; ')]);
+        return this;
+    },
+    clearCookie(name, options) {
+        const opts = { ...options, expires: new Date(0), maxAge: 0 };
+        this.cookie(name, '', opts);
+        return this;
+    },
+    // Streaming / SSE: write directly to the raw Node response. First write hijacks the reply so
+    // Fastify doesn't also try to send. Mirrors Express where res IS the ServerResponse.
+    write(chunk, encoding, cb) {
+        ensureHijacked(this);
+        return this._reply.raw.write(chunk, encoding, cb);
+    },
+    writeHead(statusCode, ...rest) {
+        ensureHijacked(this);
+        this._reply.raw.writeHead(statusCode, ...rest);
+        return this;
+    },
+    flushHeaders() {
+        ensureHijacked(this);
+        this._reply.raw.flushHeaders();
+        return this;
+    },
+    end(chunkOrCb, encodingOrCb, cb) {
+        ensureHijacked(this);
+        const raw = this._reply.raw;
+        if (typeof chunkOrCb === 'function') {
+            raw.end(chunkOrCb);
+        }
+        else if (chunkOrCb !== undefined && chunkOrCb !== null) {
+            const enc = typeof encodingOrCb === 'string' ? encodingOrCb : undefined;
+            const done = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
+            if (enc !== undefined) {
+                raw.end(chunkOrCb, enc, done);
+            }
+            else {
+                raw.end(chunkOrCb, done);
+            }
+        }
+        else {
+            raw.end();
+        }
+        signalEnd(this);
+        return this;
+    },
+    render(_view, _locals, _callback) {
+        const RES_RENDER_HINT = 'res.render is not implemented on the Fastify lane. Wrap this handler with expressLane() so the route runs on the Express lane. See docs/FAST_PRODUCTION_CHECKLIST.md';
+        if (process.env.NODE_ENV !== 'production') {
+            console.warn(`[express-fastify-runtime] ${RES_RENDER_HINT}`);
+        }
+        const r = this._reply;
+        if (!r.raw.headersSent) {
+            r.status(501).type('application/json').send({
+                error: 'res.render is not implemented on the Fastify lane',
+                hint: 'Wrap this handler with expressLane() so the route runs on the Express lane.',
+                docs: 'docs/FAST_PRODUCTION_CHECKLIST.md',
+            });
+        }
+        return this;
+    },
+};
+/**
+ * Returns a response adapter that builds a FRESH Express-like res per request.
+ *
+ * CRITICAL: a new instance is created per request (methods shared via prototype,
+ * state per instance). A single shared/mutated res object corrupts concurrent async
+ * requests — a later request would overwrite _reply while an earlier request (or its
+ * deferred morgan finish listener) is still using it.
+ */
+function createResponseAdapter() {
+    return (fastifyReply, fastifyReq) => {
+        const res = Object.create(responseProto);
+        res._reply = fastifyReply;
+        res._req = fastifyReq;
+        res._locals = null; // lazily created on first res.locals access
+        return res;
+    };
+}
+//# sourceMappingURL=response.js.map