@koralabs/kora-labs-common 6.6.3 → 6.7.0

package/fn/index.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+/// <reference types="node" />
+interface AlbEvent {
+    requestContext: {
+        elb: {
+            targetGroupArn: string;
+        };
+    };
+    httpMethod: string;
+    path: string;
+    queryStringParameters: Record<string, string> | null;
+    multiValueQueryStringParameters?: Record<string, string[]> | null;
+    headers: Record<string, string>;
+    body: string | null;
+    isBase64Encoded: boolean;
+}
+interface AlbResult {
+    statusCode?: number;
+    statusDescription?: string;
+    headers?: Record<string, string | number | boolean>;
+    multiValueHeaders?: Record<string, Array<string | number | boolean>>;
+    body?: string;
+    isBase64Encoded?: boolean;
+}
+export type AlbHandler = (event: AlbEvent, context: Record<string, unknown>) => Promise<AlbResult> | AlbResult;
+export interface FnHttpGateway {
+    requestURL: string;
+    method: string;
+    headers: Record<string, string | string[]>;
+    statusCode: number;
+    setResponseHeader(key: string, ...values: string[]): void;
+    addResponseHeader(key: string, ...values: string[]): void;
+}
+export interface FnContext {
+    httpGateway?: FnHttpGateway;
+}
+/**
+ * Drive an app's ALB (serverless-express) handler from an Fn HTTP invocation.
+ * @param albHandler the app's existing @vendia/serverless-express handler
+ * @param ctx        the Fn FDK context (must be HTTP-triggered → ctx.httpGateway present)
+ * @param input      the request body (Buffer, with fdk inputMode 'buffer')
+ * @returns the response body (Buffer or string); status + headers are set on ctx.httpGateway
+ */
+export declare const invokeExpressViaAlb: (albHandler: AlbHandler, ctx: FnContext, input?: Buffer | Uint8Array | string) => Promise<Buffer | string>;
+export {};

package/fn/index.js

@@ -0,0 +1,77 @@
+"use strict";
+// Fn <-> Express bridge for the self-hosted runtime (MIGRATION-PLAN §4).
+//
+// Each app already exposes an @vendia/serverless-express ALB handler (e.g.
+// lambdas/api.app.ts `handler(event, ctx)`), which is how it ran on Lambda/ALB. Rather
+// than invent a new req/res bridge, `invokeExpressViaAlb` adapts an Fn HTTP-trigger
+// invocation INTO an ALB event, calls that existing handler, and maps the ALB response
+// back to Fn. So the Fn function reuses the exact Express request handling the app already
+// has, and apps need only a tiny func.js entrypoint:
+//
+//   const fdk = require('@fnproject/fdk');
+//   const { handler } = require('./dist/lambdas/api.app');           // the app's ALB handler
+//   const { invokeExpressViaAlb } = require('@koralabs/kora-labs-common');
+//   fdk.handle((input, ctx) => invokeExpressViaAlb(handler, ctx, input), { inputMode: 'buffer' });
+//
+// Typed loosely (no @types/aws-lambda / @fnproject/fdk dependency here) — the shapes below
+// match the ALB event/result and the Fn HTTPGatewayContext.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeExpressViaAlb = void 0;
+const flattenHeaders = (h) => {
+    const out = {};
+    for (const [k, v] of Object.entries(h || {})) {
+        out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
+    }
+    return out;
+};
+/**
+ * Drive an app's ALB (serverless-express) handler from an Fn HTTP invocation.
+ * @param albHandler the app's existing @vendia/serverless-express handler
+ * @param ctx        the Fn FDK context (must be HTTP-triggered → ctx.httpGateway present)
+ * @param input      the request body (Buffer, with fdk inputMode 'buffer')
+ * @returns the response body (Buffer or string); status + headers are set on ctx.httpGateway
+ */
+const invokeExpressViaAlb = async (albHandler, ctx, input) => {
+    var _a;
+    const h = ctx.httpGateway;
+    if (!h)
+        throw new Error('invokeExpressViaAlb: ctx.httpGateway missing (the function must be HTTP-triggered)');
+    // requestURL may be a bare path (`/handles?x=1`) or absolute; URL() needs a base.
+    const url = new URL(h.requestURL, 'http://kora.local');
+    const qs = {};
+    const mqs = {};
+    for (const key of new Set(url.searchParams.keys())) {
+        const all = url.searchParams.getAll(key);
+        qs[key] = all[all.length - 1];
+        mqs[key] = all;
+    }
+    const bodyBuf = input == null
+        ? Buffer.alloc(0)
+        : Buffer.isBuffer(input) ? input : Buffer.from(input);
+    const event = {
+        requestContext: { elb: { targetGroupArn: 'arn:kora:fn' } },
+        httpMethod: h.method,
+        path: url.pathname,
+        queryStringParameters: Object.keys(qs).length ? qs : null,
+        multiValueQueryStringParameters: Object.keys(mqs).length ? mqs : null,
+        headers: flattenHeaders(h.headers),
+        body: bodyBuf.length ? bodyBuf.toString('base64') : null,
+        isBase64Encoded: true
+    };
+    const res = (await albHandler(event, {})) || {};
+    h.statusCode = (_a = res.statusCode) !== null && _a !== void 0 ? _a : 200;
+    if (res.headers) {
+        for (const [k, v] of Object.entries(res.headers))
+            h.setResponseHeader(k, String(v));
+    }
+    if (res.multiValueHeaders) {
+        for (const [k, arr] of Object.entries(res.multiValueHeaders)) {
+            for (const v of arr)
+                h.addResponseHeader(k, String(v));
+        }
+    }
+    if (res.body == null)
+        return '';
+    return res.isBase64Encoded ? Buffer.from(res.body, 'base64') : res.body;
+};
+exports.invokeExpressViaAlb = invokeExpressViaAlb;

package/index.d.ts

@@ -2,6 +2,7 @@ export * from './constants';
 export * from './aws';
 export { ComputeEnvironment, Environment } from './environment';
 export * from './errors';
+export * from './fn';
 export * from './handles';
 export * from './http';
 export { LogCategory, Logger } from './logger';

package/index.js

@@ -21,6 +21,7 @@ var environment_1 = require("./environment");
 Object.defineProperty(exports, "ComputeEnvironment", { enumerable: true, get: function () { return environment_1.ComputeEnvironment; } });
 Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_1.Environment; } });
 __exportStar(require("./errors"), exports);
+__exportStar(require("./fn"), exports);
 __exportStar(require("./handles"), exports);
 __exportStar(require("./http"), exports);
 var logger_1 = require("./logger");

package/logger/index.d.ts

@@ -37,4 +37,5 @@ export declare class Logger {
     } | string): void;
     private static log_entry;
     private static colorize;
+    private static escapeJsonStringContent;
 }

package/logger/index.js

@@ -102,11 +102,11 @@ class Logger {
     }
     static log_entry(category, message, event, milliseconds, count, dimensions, context) {
         const now = new Date().toISOString();
-        message = message.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); // escape double quotes and already escaped escapes
+        message = Logger.escapeJsonStringContent(message);
         const logCategory = category !== null && category !== void 0 ? category : LogCategory.INFO;
         const logCategoryColor = constants_1.IS_LOCAL ? LOCAL_CATEGORY_COLORS[logCategory] : undefined;
         const displayCategory = logCategoryColor ? this.colorize(logCategory, logCategoryColor) : logCategory;
-        const log_event = event ? `, "event": "${event}"` : '';
+        const log_event = event ? `, "event": "${Logger.escapeJsonStringContent(event)}"` : '';
         const log_milliseconds = milliseconds != undefined && milliseconds != null ? `, "milliseconds": ${milliseconds}` : '';
         const log_count = count != undefined && count != null ? `, "count": ${count}` : '';
         const log_dimensions = dimensions && Object.keys(dimensions).length ? `, "dimensions": ${JSON.stringify(dimensions)}` : '';
@@ -132,6 +132,54 @@ class Logger {
     static colorize(value, ansiColor) {
         return `${ansiColor}${value}${ANSI_RESET}`;
     }
+    // Escape characters that JSON forbids inside a string value: backslash,
+    // double quote, and control chars 0x00-0x1F. ESC (0x1B) is left alone so
+    // ANSI color sequences from `colorize`/`Logger.local` keep rendering on
+    // developer terminals; in production no ANSI is ever introduced, so the
+    // emitted line is valid JSON. Newlines/tabs in error stacks would otherwise
+    // produce invalid JSON that downstream consumers (CloudWatch subscribers,
+    // app-alerts ingestion) can't peel — the previous regex only handled \\ and
+    // \", letting stack traces through unescaped.
+    static escapeJsonStringContent(s) {
+        let out = '';
+        for (let i = 0; i < s.length; i++) {
+            const ch = s.charCodeAt(i);
+            if (ch === 0x5c) {
+                out += '\\\\';
+                continue;
+            }
+            if (ch === 0x22) {
+                out += '\\"';
+                continue;
+            }
+            if (ch === 0x08) {
+                out += '\\b';
+                continue;
+            }
+            if (ch === 0x09) {
+                out += '\\t';
+                continue;
+            }
+            if (ch === 0x0a) {
+                out += '\\n';
+                continue;
+            }
+            if (ch === 0x0c) {
+                out += '\\f';
+                continue;
+            }
+            if (ch === 0x0d) {
+                out += '\\r';
+                continue;
+            }
+            if (ch < 0x20 && ch !== 0x1b) {
+                out += '\\u' + ch.toString(16).padStart(4, '0');
+                continue;
+            }
+            out += s[i];
+        }
+        return out;
+    }
 }
 exports.Logger = Logger;
 Logger.isInitialized = false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@koralabs/kora-labs-common",
-    "version": "6.6.3",
+    "version": "6.7.0",
     "description": "Kora Labs Common Utilities",
     "main": "index.js",
     "types": "index.d.ts",