@vectorx/functions-framework 0.1.0

package/types/middlewares/middle-apm-injection.d.ts

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

package/types/middlewares/middle-async-context.d.ts

@@ -0,0 +1,2 @@
+declare const asyncContextMiddleware: () => (ctx: any, next: any) => Promise<void>;
+export { asyncContextMiddleware };

package/types/middlewares/middle-common-logger.d.ts

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

package/types/middlewares/middle-context-injection.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Next } from "koa";
+import type { FrameworkOptions } from "../framework";
+import type { ProjectConfig } from "../function-loader";
+export declare function contextInjectionMiddleware(frameworkOptions: FrameworkOptions, projectConfig: ProjectConfig): (ctx: Context, next: Next) => Promise<void>;

package/types/middlewares/middle-event-id.d.ts

@@ -0,0 +1,2 @@
+declare const eventIdMiddleware: () => (ctx: any, next: any) => Promise<void>;
+export { eventIdMiddleware };

package/types/middlewares/middle-function-route.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Next } from "koa";
+import type { ProjectConfig } from "../function-loader";
+import { type Router } from "../router";
+export declare function functionRouteMiddleware(router: Router, projectConfig: ProjectConfig): (ctx: Context, next: Next) => Promise<any>;

package/types/middlewares/middle-logs-request.d.ts

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

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

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

package/types/request.d.ts

@@ -0,0 +1,46 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+export interface IRequestConfig {
+    timeout?: number;
+    timeoutMsg?: string;
+    restrictedMethods?: Array<IRequestMethod>;
+    defaultHeaders?: Record<string, string>;
+}
+export type IRequestMethod = "get" | "post" | "put" | "upload" | "download";
+export interface IRequestOptions {
+    url?: string;
+    headers?: Record<string, string>;
+    data?: any;
+    responseType?: string;
+    withCredentials?: boolean;
+    body?: any;
+    method?: string;
+    file?: File;
+    name?: string;
+}
+export interface IFetchOptions {
+    url: string;
+    headers?: HeadersInit;
+    body?: any;
+    method?: string;
+    enableAbort?: boolean;
+    stream?: boolean;
+}
+export interface ResponseObject<T = any> {
+    data?: T;
+    statusCode?: number;
+    [key: string]: any;
+}
+export declare class Request implements IAbstractRequest {
+    private readonly timeout;
+    private readonly timeoutMsg;
+    private readonly restrictedMethods;
+    private readonly defaultHeaders;
+    constructor(config?: IRequestConfig);
+    get<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    post<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    put<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    upload<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    download(options: IRequestOptions): Promise<unknown>;
+    protected request(options: IRequestOptions, enableAbort?: boolean): Promise<ResponseObject>;
+    fetch(options: IFetchOptions): Promise<ResponseObject>;
+}

package/types/router.d.ts

@@ -0,0 +1,15 @@
+import type { CloudFunctionConfig, RouteConfig } from "./function-loader";
+export declare class Router {
+    private routes;
+    private router;
+    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;
+};

package/types/server.d.ts

@@ -0,0 +1,32 @@
+import http from "http";
+import type { FrameworkOptions } from "./framework";
+import type { ProjectConfig } from "./function-loader";
+import type { functionsLogger } from "./logger";
+import type { Request } from "./request";
+import type { Router } from "./router";
+declare module "koa" {
+    interface DefaultState {
+        isTimeout?: boolean;
+    }
+    interface Application {
+        routers: Map<string, Router>;
+    }
+    interface Context {
+        rawBody?: any;
+        extendedContext?: any;
+        httpContext?: any;
+        sse?: () => any;
+    }
+}
+export interface RcbContext {
+    ctxId: string;
+    eventID: string;
+    eventType: string;
+    timestamp: number;
+    httpContext: any;
+    request: Request;
+    logger: typeof functionsLogger;
+    baseUrl: string;
+    sse: () => any;
+}
+export declare function createServer(options: FrameworkOptions, router: Router, projectConfig: ProjectConfig): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/types/sse.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from "events";
+import * as util from "util";
+import type { Context } from "koa";
+export interface SSEMessage {
+    id?: string;
+    event?: string;
+    data: any;
+    retry?: number;
+    comment?: string;
+}
+export declare class ServerSentEvent extends EventEmitter {
+    private ctx;
+    private stream;
+    private closed;
+    private encoder;
+    constructor(ctx: Context);
+    setEncoder(encoder: util.TextEncoder): void;
+    emitMessage(event: string, data: any): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    send(event: SSEMessage | SSEMessage[] | string | Buffer): boolean;
+    end(msg?: SSEMessage | SSEMessage[] | string | Buffer): void;
+    get isClosed(): boolean;
+}

package/types/types.d.ts

@@ -0,0 +1,18 @@
+export interface RcbContext {
+    httpContext?: {
+        url: string;
+    };
+    request: (options: {
+        method: string;
+        url: string;
+        headers?: Record<string, string>;
+        body?: string;
+        stream?: boolean;
+        timeout?: number;
+    }) => Promise<{
+        data: any;
+        header?: Headers;
+    }>;
+    getBaseUrl: () => string;
+    eventID: string;
+}

package/types/unified-responder.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "koa";
+import { type AppError } from "./error";
+export interface ResponseBody {
+    code: string;
+    message: string;
+    data?: any;
+    stack?: string;
+    requestId?: string;
+}
+export interface IntegrationResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: any;
+}
+export declare function sendResponse(ctx: Context, data?: any, error?: AppError, errStatusCode?: number, withStack?: boolean): void;

package/types/user-logger.d.ts

@@ -0,0 +1,5 @@
+declare function takeUserCodeLogs(): import("./logger").IUserCodeLogItem[];
+declare function pushUserCodeLogs(log: any): void;
+declare function addUserCodeLog(log: any): void;
+declare function getUserCodeLogs(): import("./logger").IUserCodeLogItem[];
+export { takeUserCodeLogs, pushUserCodeLogs, addUserCodeLog, getUserCodeLogs };

package/types/utils/apm.config.d.ts

@@ -0,0 +1,6 @@
+export declare const APM_MEASUREMENT_NAME = "vectorx_kit_agent_runtime";
+interface ApmReporterConfig {
+    endpoint: string;
+}
+export declare const defaultConfig: ApmReporterConfig;
+export {};

package/types/utils/apm.d.ts

@@ -0,0 +1,21 @@
+export interface IMeasurementItem {
+    measurement_name: string;
+    measurement_data: Record<string, any>;
+    sequence: Record<string, any>;
+}
+export declare class ApmReporter {
+    seq: number;
+    private apmContext;
+    private reportQueue;
+    private timer;
+    constructor();
+    getSequence(): {
+        context_sdkSeqId: number;
+        context_sdkSessionId: string;
+        context_pageSessionId: string;
+        clientTime: number;
+    };
+    report(measurement_name: string, measurement_data?: IMeasurementItem["measurement_data"]): void;
+    private batchReport;
+    private _request;
+}

package/types/utils/common.d.ts

@@ -0,0 +1,2 @@
+export declare const AGENT_HEALTH_REG: RegExp;
+export declare const LOGS_QUERY_REG: RegExp;

package/types/utils/console-intercept.d.ts

@@ -0,0 +1,6 @@
+declare class Interceptor {
+    constructor();
+    static intercept(): void;
+    static interceptConsole(): void;
+}
+export { Interceptor };

package/types/utils/error-stack.d.ts

@@ -0,0 +1,5 @@
+declare function getCaller(belowFn?: any, index?: number): string;
+declare function formatCallSite(stackTrace: any): string;
+declare function getStackTraces(belowFn?: any): any[];
+declare function truncateContent(content: any): any;
+export { getCaller, formatCallSite, getStackTraces, truncateContent };

package/types/utils/helper.d.ts

@@ -0,0 +1,7 @@
+export declare function deepFreeze<T>(obj: T): T;
+export declare function isPlainObject(obj: any): boolean;
+export declare function isFormData(val: any): boolean;
+export declare function toQueryString(data: Record<string, any>): string;
+export declare function obj2StrRecord(obj: object): Record<string, string>;
+export declare function formatUrl(PROTOCOL: string, url: string, query: Record<string, any>): string;
+export declare function getDependencyVersion(packageName: any, searchPath: any): any;

package/types/utils/machineId.d.ts

@@ -0,0 +1,2 @@
+export declare function machineIdSync(original: boolean): string;
+export declare function machineId(original: boolean): Promise<string>;