@vectorx/functions-framework 0.0.0-beta-20260108133839 → 0.0.0-beta-20260320063305

package/types/function-registry.d.ts

@@ -1,4 +1,8 @@
 export declare function buildFnId(fnName: string, functionName: string): string;
 export declare function registerFunction(fnName: string, fn: Function): void;
 export declare function getRegisteredFunction(fnId: string): Function | undefined;
+export declare function getAllRegisteredFunctions(): Array<{
+    name: string;
+    userFunction: Function;
+}>;
 export declare function clearRegistry(): void;

package/types/index.d.ts

@@ -4,5 +4,6 @@ export * from "./function-loader";
 export * from "./function-registry";
 export * from "./sse";
 export * from "./server";
+export * from "./wss";
 export * from "./logger";
 export * from "./async-context";

package/types/middlewares/index.d.ts

@@ -1,5 +1,6 @@
 export { asyncContextMiddleware } from "./middle-async-context";
 export { contextInjectionMiddleware } from "./middle-context-injection";
+export { envVarsInjectionMiddleware } from "./middle-env-vars-injection";
 export { eventIdMiddleware } from "./middle-event-id";
 export { functionRouteMiddleware } from "./middle-function-route";
 export { loggerMiddleware } from "./middle-common-logger";

package/types/middlewares/middle-env-vars-injection.d.ts

@@ -0,0 +1,2 @@
+import type { Context, Next } from "koa";
+export declare function envVarsInjectionMiddleware(): (ctx: Context, next: Next) => Promise<void>;

package/types/middlewares/middle-open-gw-request.d.ts

@@ -1,2 +1,5 @@
 import type { Context, Next } from "koa";
-export declare function openGwRequestMiddleware(agentId: string): (ctx: Context, next: Next) => Promise<void>;
+export type OpenGwRequestMiddlewareOptions = {
+    mode?: "agent" | "fun";
+};
+export declare function openGwRequestMiddleware(agentId?: string, options?: OpenGwRequestMiddlewareOptions): (ctx: Context, next: Next) => Promise<void>;

package/types/router.d.ts

@@ -2,14 +2,14 @@ import type { CloudFunctionConfig, RouteConfig } from "./function-loader";
 export declare class Router {
     private routes;
     private router;
-    constructor(config: CloudFunctionConfig);
+    constructor(config?: CloudFunctionConfig);
     private addRoute;
     findRoute(path: string): RouteConfig | null;
 }
 export declare function routeFunction(router: Router | undefined, path: string): {
-    routeDefinition: RouteConfig;
-    handleFunction: Function;
-} | {
     routeDefinition?: undefined;
     handleFunction?: undefined;
+} | {
+    routeDefinition: RouteConfig;
+    handleFunction: Function;
 };

package/types/server.d.ts

@@ -4,6 +4,7 @@ import type { ProjectConfig } from "./function-loader";
 import type { functionsLogger } from "./logger";
 import type { Request } from "./request";
 import type { Router } from "./router";
+import type { VectorxWebSocket } from "./wss";
 declare module "koa" {
     interface DefaultState {
         isTimeout?: boolean;
@@ -24,10 +25,23 @@ export interface RcbContext {
     eventID: string;
     eventType: string;
     timestamp: number;
+    headers: Record<string, any>;
+    httpMethod: string;
+    path: string;
+    url: string;
+    query: Record<string, any>;
+    cookies: Record<string, string>;
+    trigger: "online" | "ide_debug" | "console_debug";
     httpContext: any;
     request: Request;
     logger: typeof functionsLogger;
     baseUrl: string;
+    set: (field: string, value: any) => void;
+    remove: (field: string) => void;
+    status: (code: number) => void;
+    setCookie: (name: string, value: string, options?: any) => void;
+    clearCookie: (name: string, options?: any) => void;
     sse: () => any;
+    ws?: VectorxWebSocket;
 }
 export declare function createServer(options: FrameworkOptions, router: Router, projectConfig: ProjectConfig): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/types/wss.d.ts

@@ -0,0 +1,56 @@
+import * as events from "events";
+import * as http from "http";
+import type Koa from "koa";
+import type { WebSocket as RawWebSocket } from "ws";
+import type { FrameworkOptions } from "./framework";
+import type { ProjectConfig } from "./function-loader";
+import type { Router } from "./router";
+export interface WsEventContext {
+    ctxId: string;
+}
+export interface WsOpenEvent {
+    ctx: WsEventContext;
+    type: string;
+}
+export interface WsErrorEvent {
+    ctx: WsEventContext;
+    type: string;
+    message: string;
+    error: any;
+}
+export interface WsCloseEvent {
+    ctx: WsEventContext;
+    type: string;
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+export interface WsMessageEvent {
+    ctx: WsEventContext;
+    type: string;
+    data: any;
+}
+export interface HandleUpgradeResult {
+    allowWebSocket: boolean;
+    statusCode?: number;
+    body?: string;
+    contentType?: string;
+}
+export interface WsUpgradeContext {
+    ctxId: string;
+    eventID: string;
+    eventType: "websocket.upgrade";
+    timestamp: string;
+    httpContext: {
+        url: string | undefined;
+        httpMethod: string | undefined;
+        headers: http.IncomingHttpHeaders;
+    };
+}
+export declare class VectorxWebSocket extends events.EventEmitter {
+    private ws;
+    constructor(ws: RawWebSocket, eventCtx: WsEventContext);
+    send(buf: any): void;
+    close(code?: number, reason?: string): void;
+}
+export declare function createWebSocketServer(httpServer: http.Server, koaApp: Koa, router: Router, options: FrameworkOptions, projectConfig: ProjectConfig): void;