@pristine-ts/gcp-functions 2.0.16

package/dist/types/mappers/base-gcp-http-event.mapper.d.ts

@@ -0,0 +1,37 @@
+import { HttpMethod, Request } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { EventResponse } from "@pristine-ts/core";
+import { GcpFunctionsHttpEventResponsePayload } from "../event-response-payloads/gcp-functions-http.event-response-payload";
+/**
+ * Shared base for the three GCP-Functions HTTP mappers. Mirrors
+ * `BaseApiEventMapper` in `@pristine-ts/aws-api-gateway`.
+ */
+export declare class BaseGcpHttpEventMapper {
+    protected mapHttpMethod(method: string): HttpMethod;
+    /**
+     * Extracts the URL path from a raw URL (which may include query string).
+     */
+    protected extractPath(url: string): string;
+    /**
+     * Converts a Pristine `Response` (or arbitrary handler return value) into the
+     * `GcpFunctionsHttpEventResponsePayload` shape that the entry-point shim returns to
+     * Cloud Functions / Cloud Run.
+     */
+    protected toResponsePayload(eventResponse: EventResponse<any, any>, logHandler: LogHandlerInterface): GcpFunctionsHttpEventResponsePayload;
+    /**
+     * Hydrates a Pristine `Request` from raw HTTP fields. Shared by the Gen 1 and
+     * Cloud Run mappers (both deliver raw HTTP).
+     */
+    protected toPristineRequest(method: string, url: string, headers: {
+        [k: string]: string | string[];
+    } | undefined, body: any, eventId: string): Request;
+    /**
+     * Lowercases keys and collapses single-element arrays so downstream code can read
+     * headers consistently as `string`.
+     */
+    protected flattenHeaders(headers: {
+        [k: string]: string | string[];
+    }): {
+        [k: string]: string;
+    };
+}

package/dist/types/mappers/cloud-function-gen-1-http-event.mapper.d.ts

@@ -0,0 +1,26 @@
+import { Request, Response } from "@pristine-ts/common";
+import { EventIdManager, EventMapperInterface, EventResponse, EventsExecutionOptionsInterface, ExecutionContextInterface } from "@pristine-ts/core";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { GcpFunctionsEventsHandlingStrategyEnum } from "../enums/gcp-functions-events-handling-strategy.enum";
+import { CloudFunctionGen1HttpEventPayload } from "../event-payloads/cloud-function-gen-1-http.event-payload";
+import { GcpFunctionsHttpEventResponsePayload } from "../event-response-payloads/gcp-functions-http.event-response-payload";
+import { BaseGcpHttpEventMapper } from "./base-gcp-http-event.mapper";
+/**
+ * Maps a Gen 1 HTTP-triggered Cloud Function request into Pristine. Gen 1 HTTP
+ * functions receive an Express-style `(req, res)` pair; the entry-point shim
+ * normalizes that into a plain object before calling `kernel.handle(...)` with the
+ * `GcpCloudFunction` execution context.
+ *
+ * Dual-mode strategy: `Request` exposes a Pristine `Request` for controller routing;
+ * `Event` exposes the raw event payload for handler-based processing.
+ */
+export declare class CloudFunctionGen1HttpEventMapper extends BaseGcpHttpEventMapper implements EventMapperInterface<CloudFunctionGen1HttpEventPayload | Request, GcpFunctionsHttpEventResponsePayload | Response> {
+    private readonly logHandler;
+    private readonly handlingStrategy;
+    private readonly eventIdManager;
+    constructor(logHandler: LogHandlerInterface, handlingStrategy: GcpFunctionsEventsHandlingStrategyEnum, eventIdManager: EventIdManager);
+    supportsMapping(rawEvent: any, executionContext: ExecutionContextInterface<any>): boolean;
+    map(rawEvent: any, executionContext: ExecutionContextInterface<any>): EventsExecutionOptionsInterface<CloudFunctionGen1HttpEventPayload | Request>;
+    supportsReverseMapping(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): boolean;
+    reverseMap(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): GcpFunctionsHttpEventResponsePayload;
+}

package/dist/types/mappers/cloud-function-gen-2-http-event.mapper.d.ts

@@ -0,0 +1,27 @@
+import { Request, Response } from "@pristine-ts/common";
+import { EventIdManager, EventMapperInterface, EventResponse, EventsExecutionOptionsInterface, ExecutionContextInterface } from "@pristine-ts/core";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { GcpFunctionsEventsHandlingStrategyEnum } from "../enums/gcp-functions-events-handling-strategy.enum";
+import { CloudFunctionGen2HttpEventPayload } from "../event-payloads/cloud-function-gen-2-http.event-payload";
+import { GcpFunctionsHttpEventResponsePayload } from "../event-response-payloads/gcp-functions-http.event-response-payload";
+import { BaseGcpHttpEventMapper } from "./base-gcp-http-event.mapper";
+/**
+ * Maps a Gen 2 Cloud Function CloudEvent (delivered over HTTP) into Pristine.
+ *
+ * Gen 2 functions receive CloudEvents in one of two transport modes:
+ *   - **Binary** — CloudEvent attributes in `ce-*` headers, `data` in the body.
+ *   - **Structured** — A JSON object in the body with `{specversion, id, type, source, data, ...}`.
+ *
+ * This mapper handles both. Detection: `ExecutionContextKeynameEnum.GcpCloudFunction`
+ * + either `ce-*` headers OR a body with `specversion`.
+ */
+export declare class CloudFunctionGen2HttpEventMapper extends BaseGcpHttpEventMapper implements EventMapperInterface<CloudFunctionGen2HttpEventPayload | Request, GcpFunctionsHttpEventResponsePayload | Response> {
+    private readonly logHandler;
+    private readonly handlingStrategy;
+    private readonly eventIdManager;
+    constructor(logHandler: LogHandlerInterface, handlingStrategy: GcpFunctionsEventsHandlingStrategyEnum, eventIdManager: EventIdManager);
+    supportsMapping(rawEvent: any, executionContext: ExecutionContextInterface<any>): boolean;
+    map(rawEvent: any, executionContext: ExecutionContextInterface<any>): EventsExecutionOptionsInterface<CloudFunctionGen2HttpEventPayload | Request>;
+    supportsReverseMapping(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): boolean;
+    reverseMap(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): GcpFunctionsHttpEventResponsePayload;
+}

package/dist/types/mappers/cloud-run-http-event.mapper.d.ts

@@ -0,0 +1,23 @@
+import { Request, Response } from "@pristine-ts/common";
+import { EventIdManager, EventMapperInterface, EventResponse, EventsExecutionOptionsInterface, ExecutionContextInterface } from "@pristine-ts/core";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { GcpFunctionsEventsHandlingStrategyEnum } from "../enums/gcp-functions-events-handling-strategy.enum";
+import { CloudRunHttpEventPayload } from "../event-payloads/cloud-run-http.event-payload";
+import { GcpFunctionsHttpEventResponsePayload } from "../event-response-payloads/gcp-functions-http.event-response-payload";
+import { BaseGcpHttpEventMapper } from "./base-gcp-http-event.mapper";
+/**
+ * Maps a Cloud Run HTTP request into Pristine. Cloud Run delivers raw HTTP (the
+ * container hosts a normal `http.Server`); the entry-point shim normalizes the Node
+ * `IncomingMessage` into a plain object before invoking `kernel.handle(...)` with
+ * the `GcpCloudRun` execution context.
+ */
+export declare class CloudRunHttpEventMapper extends BaseGcpHttpEventMapper implements EventMapperInterface<CloudRunHttpEventPayload | Request, GcpFunctionsHttpEventResponsePayload | Response> {
+    private readonly logHandler;
+    private readonly handlingStrategy;
+    private readonly eventIdManager;
+    constructor(logHandler: LogHandlerInterface, handlingStrategy: GcpFunctionsEventsHandlingStrategyEnum, eventIdManager: EventIdManager);
+    supportsMapping(rawEvent: any, executionContext: ExecutionContextInterface<any>): boolean;
+    map(rawEvent: any, executionContext: ExecutionContextInterface<any>): EventsExecutionOptionsInterface<CloudRunHttpEventPayload | Request>;
+    supportsReverseMapping(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): boolean;
+    reverseMap(eventResponse: EventResponse<any, any>, response: any, executionContext: ExecutionContextInterface<any>): GcpFunctionsHttpEventResponsePayload;
+}

package/dist/types/mappers/mappers.d.ts

@@ -0,0 +1,4 @@
+export * from "./base-gcp-http-event.mapper";
+export * from "./cloud-function-gen-1-http-event.mapper";
+export * from "./cloud-function-gen-2-http-event.mapper";
+export * from "./cloud-run-http-event.mapper";

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pristine-ts/gcp-functions",
+  "version": "2.0.16",
+  "description": "",
+  "module": "dist/lib/esm/gcp-functions.module.js",
+  "main": "dist/lib/cjs/gcp-functions.module.js",
+  "types": "dist/types/gcp-functions.module.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "prepublish": "npm run build",
+    "test": "jest",
+    "test:cov": "jest --coverage"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pristine-ts/common": "^2.0.16",
+    "@pristine-ts/core": "^2.0.16",
+    "@pristine-ts/networking": "^2.0.16"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": {
+          "strictNullChecks": false
+        }
+      }
+    },
+    "testEnvironment": "node",
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 90,
+        "functions": 95,
+        "lines": 95,
+        "statements": 95
+      }
+    },
+    "collectCoverageFrom": [
+      "src/*.{js,ts}"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magieno/pristine-ts.git",
+    "directory": "packages/gcp-functions"
+  },
+  "gitHead": "a55d7d59862672a8cbbca4088fed090779b37705"
+}

package/readme.md

@@ -0,0 +1,6 @@
+# @pristine-ts/gcp-functions
+
+HTTP entry mappers for GCP Cloud Functions (Gen 1 + Gen 2) and Cloud Run. Mirror of
+`@pristine-ts/aws-api-gateway`: each mapper supports a dual-mode strategy where
+incoming requests are exposed either as a Pristine `Request` (for controller routing)
+or as a typed event payload (for handler-based processing).