@walkeros/server-source-gcp 4.0.0 → 4.0.1-next-1778183328892

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { Source, WalkerOS, Flow, Trigger } from '@walkeros/core';
+import { Source, WalkerOS, Flow, Trigger, SetupFn as SetupFn$1 } from '@walkeros/core';
 import * as _walkeros_core_dev from '@walkeros/core/dev';
 import { z } from '@walkeros/core/dev';
+import { PubSub, Subscription } from '@google-cloud/pubsub';
 
 /**
  * HTTP methods enum
@@ -64,7 +65,7 @@ declare const SettingsSchema: z.ZodObject<{
     }, z.core.$strip>]>>;
     timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type Settings$1 = z.infer<typeof SettingsSchema>;
+type Settings$3 = z.infer<typeof SettingsSchema>;
 
 declare const settings: _walkeros_core_dev.JSONSchema;
 
@@ -74,7 +75,7 @@ declare const index$1_HttpMethod: typeof HttpMethod;
 declare const index$1_SettingsSchema: typeof SettingsSchema;
 declare const index$1_settings: typeof settings;
 declare namespace index$1 {
-  export { type CorsOptions$1 as CorsOptions, index$1_CorsOptionsSchema as CorsOptionsSchema, index$1_CorsOrigin as CorsOrigin, index$1_HttpMethod as HttpMethod, type Settings$1 as Settings, index$1_SettingsSchema as SettingsSchema, index$1_settings as settings };
+  export { type CorsOptions$1 as CorsOptions, index$1_CorsOptionsSchema as CorsOptionsSchema, index$1_CorsOrigin as CorsOrigin, index$1_HttpMethod as HttpMethod, type Settings$3 as Settings, index$1_SettingsSchema as SettingsSchema, index$1_settings as settings };
 }
 
 declare module '@walkeros/core' {
@@ -85,34 +86,34 @@ declare module '@walkeros/core' {
         };
     }
 }
-interface Request {
+interface Request$1 {
     method: string;
     body?: unknown;
     headers: Record<string, string | string[]>;
     get(name: string): string | undefined;
 }
-interface Response {
-    status(code: number): Response;
-    json(body: unknown): Response;
-    send(body?: unknown): Response;
-    set(key: string, value: string): Response;
+interface Response$1 {
+    status(code: number): Response$1;
+    json(body: unknown): Response$1;
+    send(body?: unknown): Response$1;
+    set(key: string, value: string): Response$1;
 }
-type Settings = z.infer<typeof SettingsSchema>;
+type Settings$2 = z.infer<typeof SettingsSchema>;
 type CorsOptions = z.infer<typeof CorsOptionsSchema>;
-type InitSettings = Partial<Settings>;
-interface Mapping {
+type InitSettings$2 = Partial<Settings$2>;
+interface Mapping$2 {
 }
-type Push = (req: Request, res: Response) => Promise<void>;
-interface Env extends Source.Env {
-    req?: Request;
-    res?: Response;
+type Push$2 = (req: Request$1, res: Response$1) => Promise<void>;
+interface Env$2 extends Source.Env {
+    req?: Request$1;
+    res?: Response$1;
 }
-type Types = Source.Types<Settings, Mapping, Push, Env, InitSettings>;
-interface CloudFunctionSource extends Omit<Source.Instance<Types>, 'push'> {
-    push: Push;
+type Types$2 = Source.Types<Settings$2, Mapping$2, Push$2, Env$2, InitSettings$2>;
+interface CloudFunctionSource extends Omit<Source.Instance<Types$2>, 'push'> {
+    push: Push$2;
 }
-type Config = Source.Config<Types>;
-type PartialConfig = Source.PartialConfig<Types>;
+type Config$2 = Source.Config<Types$2>;
+type PartialConfig$2 = Source.PartialConfig<Types$2>;
 interface EventRequest {
     event: string;
     data?: WalkerOS.AnyObject;
@@ -129,24 +130,14 @@ interface EventResponse {
 type RequestBody = EventRequest;
 type ResponseBody = EventResponse;
 
-type types_CloudFunctionSource = CloudFunctionSource;
-type types_Config = Config;
-type types_CorsOptions = CorsOptions;
-type types_Env = Env;
-type types_EventRequest = EventRequest;
-type types_EventResponse = EventResponse;
-type types_InitSettings = InitSettings;
-type types_Mapping = Mapping;
-type types_PartialConfig = PartialConfig;
-type types_Push = Push;
-type types_Request = Request;
-type types_RequestBody = RequestBody;
-type types_Response = Response;
-type types_ResponseBody = ResponseBody;
-type types_Settings = Settings;
-type types_Types = Types;
-declare namespace types {
-  export type { types_CloudFunctionSource as CloudFunctionSource, types_Config as Config, types_CorsOptions as CorsOptions, types_Env as Env, types_EventRequest as EventRequest, types_EventResponse as EventResponse, types_InitSettings as InitSettings, types_Mapping as Mapping, types_PartialConfig as PartialConfig, types_Push as Push, types_Request as Request, types_RequestBody as RequestBody, types_Response as Response, types_ResponseBody as ResponseBody, types_Settings as Settings, types_Types as Types };
+type types$2_CloudFunctionSource = CloudFunctionSource;
+type types$2_CorsOptions = CorsOptions;
+type types$2_EventRequest = EventRequest;
+type types$2_EventResponse = EventResponse;
+type types$2_RequestBody = RequestBody;
+type types$2_ResponseBody = ResponseBody;
+declare namespace types$2 {
+  export type { types$2_CloudFunctionSource as CloudFunctionSource, Config$2 as Config, types$2_CorsOptions as CorsOptions, Env$2 as Env, types$2_EventRequest as EventRequest, types$2_EventResponse as EventResponse, InitSettings$2 as InitSettings, Mapping$2 as Mapping, PartialConfig$2 as PartialConfig, Push$2 as Push, Request$1 as Request, types$2_RequestBody as RequestBody, Response$1 as Response, types$2_ResponseBody as ResponseBody, Settings$2 as Settings, Types$2 as Types };
 }
 
 /**
@@ -155,7 +146,7 @@ declare namespace types {
  * Use this for testing HTTP event ingestion and request/response handling
  * without requiring a real GCP Cloud Function environment.
  */
-declare const push: Env;
+declare const push: Env$2;
 
 declare const env_push: typeof push;
 declare namespace env {
@@ -197,6 +188,265 @@ declare namespace index {
   export { index_createTrigger as createTrigger, index_env as env, index_step as step };
 }
 
-declare const sourceCloudFunction: Source.Init<Types>;
+declare const sourceCloudFunction: Source.Init<Types$2>;
+
+/**
+ * Shared types for the Pub/Sub source (pull and push).
+ *
+ * The source uses real `@google-cloud/pubsub` SDK types directly (`PubSub`,
+ * `Subscription`, `Topic`, `Message`, `SubscriptionMetadata`, etc.) rather
+ * than hand-rolled narrow surrogates. This keeps the runtime contract
+ * honest: if the SDK changes a signature, the source surfaces the break
+ * at compile time instead of papering over it with a permissive interface.
+ *
+ * Only domain types that have no SDK equivalent live here.
+ */
+/**
+ * Service account credentials. Mirrors the destination shape in
+ * `@walkeros/server-destination-gcp`.
+ */
+interface ServiceAccountCredentials {
+    client_email: string;
+    private_key: string;
+    project_id?: string;
+}
+/**
+ * Decoder mode for the message data payload.
+ *
+ * - `json`: JSON.parse(data.toString('utf8')). Default.
+ * - `text`: data.toString('utf8'). The text becomes the event payload.
+ * - `raw`: the raw Buffer is forwarded as-is.
+ */
+type Decoder = 'json' | 'text' | 'raw';
+
+declare module '@walkeros/core' {
+    interface SourceMap {
+        'pubsub-pull': {
+            type: 'pubsub-pull';
+            platform: 'server';
+        };
+    }
+}
+interface Settings$1 {
+    client: PubSub;
+    projectId: string;
+    subscription: string;
+    topic?: string;
+    credentials?: string | ServiceAccountCredentials;
+    apiEndpoint?: string;
+    decoder?: Decoder;
+    flowControl?: {
+        maxMessages?: number;
+        maxBytes?: number;
+    };
+    ackDeadline?: number;
+    shutdownTimeoutMs?: number;
+    onPushError?: 'nack' | 'ack';
+    subscriptionHandle?: Subscription;
+}
+interface InitSettings$1 {
+    projectId: string;
+    subscription: string;
+    topic?: string;
+    client?: PubSub;
+    credentials?: string | ServiceAccountCredentials;
+    apiEndpoint?: string;
+    decoder?: Decoder;
+    flowControl?: {
+        maxMessages?: number;
+        maxBytes?: number;
+    };
+    ackDeadline?: number;
+    shutdownTimeoutMs?: number;
+    onPushError?: 'nack' | 'ack';
+}
+interface Mapping$1 {
+}
+/**
+ * Synthetic message input. Used by tests / triggers to dispatch a message
+ * through the same handler the SDK subscriber callback uses, without
+ * involving real Pub/Sub infrastructure.
+ *
+ * In production, `push()` is invoked without arguments and is a no-op:
+ * Pub/Sub is event-driven, the SDK's subscription emitter is the canonical
+ * delivery path. Tests pass a synthetic input to dispatch directly.
+ */
+interface SyntheticMessage {
+    id: string;
+    data: Buffer;
+    attributes?: Record<string, string>;
+    orderingKey?: string;
+}
+interface SyntheticPushResult {
+    acked: boolean;
+    nacked: boolean;
+}
+type Push$1 = (content?: SyntheticMessage) => Promise<SyntheticPushResult | void>;
+interface Env$1 extends Source.Env {
+    PubSub?: typeof PubSub;
+}
+/**
+ * Provisioning options for `walkeros setup source.<id>`.
+ *
+ * Triggered only by the explicit CLI command. Idempotent. Never auto-run.
+ */
+interface Setup {
+    /** Optional: create the topic if it does not exist. Default: false (require pre-existing topic). */
+    createTopic?: boolean;
+    /** Subscription ack deadline in seconds. Default: 60. */
+    ackDeadlineSeconds?: number;
+    /** Subscription message retention. Default: undefined (project default). */
+    messageRetentionDuration?: {
+        seconds: number;
+    };
+    /** Filter expression. Optional. */
+    filter?: string;
+    /** Dead-letter policy. Optional but strongly recommended. */
+    deadLetterPolicy?: {
+        deadLetterTopic: string;
+        maxDeliveryAttempts: number;
+        /** Auto-create the dead-letter topic if it does not exist. Default: false. */
+        createDeadLetterTopic?: boolean;
+    };
+    /** Retry policy. Optional. */
+    retryPolicy?: {
+        minimumBackoff: {
+            seconds: number;
+        };
+        maximumBackoff: {
+            seconds: number;
+        };
+    };
+    /** Enable message ordering on the subscription. Default: false. */
+    enableMessageOrdering?: boolean;
+    /** Subscription labels. Optional. */
+    labels?: Record<string, string>;
+    /** Subscription expiration policy. `null` means never expire. */
+    expirationPolicy?: {
+        ttl?: {
+            seconds: number;
+        } | null;
+    };
+}
+type Types$1 = Source.Types<Settings$1, Mapping$1, Push$1, Env$1, InitSettings$1, Setup>;
+type Config$1 = Source.Config<Types$1>;
+type PartialConfig$1 = Source.PartialConfig<Types$1>;
+type SetupFn = SetupFn$1<Config$1, Env$1>;
+
+type types$1_Decoder = Decoder;
+declare const types$1_PubSub: typeof PubSub;
+type types$1_ServiceAccountCredentials = ServiceAccountCredentials;
+type types$1_Setup = Setup;
+type types$1_SetupFn = SetupFn;
+declare const types$1_Subscription: typeof Subscription;
+type types$1_SyntheticMessage = SyntheticMessage;
+type types$1_SyntheticPushResult = SyntheticPushResult;
+declare namespace types$1 {
+  export { type Config$1 as Config, type types$1_Decoder as Decoder, type Env$1 as Env, type InitSettings$1 as InitSettings, type Mapping$1 as Mapping, type PartialConfig$1 as PartialConfig, types$1_PubSub as PubSub, type Push$1 as Push, type types$1_ServiceAccountCredentials as ServiceAccountCredentials, type Settings$1 as Settings, type types$1_Setup as Setup, type types$1_SetupFn as SetupFn, types$1_Subscription as Subscription, type types$1_SyntheticMessage as SyntheticMessage, type types$1_SyntheticPushResult as SyntheticPushResult, type Types$1 as Types };
+}
+
+/**
+ * Google Cloud Pub/Sub pull source.
+ *
+ * Long-running streaming subscriber. `init()` opens the subscription stream
+ * and forwards each message to the collector via `env.push`. The source's
+ * `push` accepts an optional synthetic message (used by tests / triggers)
+ * and dispatches it through the same pipeline; called without arguments
+ * (production) it is a no-op since Pub/Sub is event-driven.
+ *
+ * `destroy()` closes the subscriber gracefully, honoring `shutdownTimeoutMs`.
+ */
+declare const sourcePubSubPull: Source.Init<Types$1>;
+
+declare module '@walkeros/core' {
+    interface SourceMap {
+        'pubsub-push': {
+            type: 'pubsub-push';
+            platform: 'server';
+        };
+    }
+}
+/**
+ * Minimal request shape for the push handler. Mirrors the cloudfunction
+ * source so operators can wire `sourcePubSubPush` into express, lambda,
+ * or any framework that delivers a similar contract.
+ */
+interface Request {
+    method: string;
+    body?: unknown;
+    headers: Record<string, string | string[]>;
+    get(name: string): string | undefined;
+}
+interface Response {
+    status(code: number): Response;
+    json(body: unknown): Response;
+    send(body?: unknown): Response;
+    set(key: string, value: string): Response;
+}
+interface Settings {
+    /** GCP project id. Optional; informational, used in error messages. */
+    projectId?: string;
+    /** Decoder for the message data field. Default: 'json'. */
+    decoder?: Decoder;
+    /** Verify the OIDC bearer token Pub/Sub attaches to push requests. Default: false. */
+    verifyOidc?: boolean;
+    /** OIDC audience (your endpoint URL or a custom audience). Required if verifyOidc is true. */
+    audience?: string;
+}
+type InitSettings = Partial<Settings>;
+interface Mapping {
+}
+type Push = (req: Request, res: Response) => Promise<void>;
+interface Env extends Source.Env {
+    req?: Request;
+    res?: Response;
+    /** Optional override for OIDC verification. Tests can inject a stub. */
+    verifyOidcToken?: (token: string, audience: string) => Promise<{
+        sub?: string;
+        email?: string;
+    }>;
+}
+type Types = Source.Types<Settings, Mapping, Push, Env, InitSettings>;
+type Config = Source.Config<Types>;
+type PartialConfig = Source.PartialConfig<Types>;
+/**
+ * Pub/Sub push envelope shape. Pub/Sub POSTs each message in this format
+ * to the configured push endpoint. `data` is base64-encoded.
+ */
+interface PushEnvelope {
+    message: {
+        data?: string;
+        attributes?: Record<string, string>;
+        messageId: string;
+        publishTime?: string;
+        orderingKey?: string;
+    };
+    subscription: string;
+}
+
+type types_Config = Config;
+type types_Env = Env;
+type types_InitSettings = InitSettings;
+type types_Mapping = Mapping;
+type types_PartialConfig = PartialConfig;
+type types_Push = Push;
+type types_PushEnvelope = PushEnvelope;
+type types_Request = Request;
+type types_Response = Response;
+type types_Settings = Settings;
+type types_Types = Types;
+declare namespace types {
+  export type { types_Config as Config, types_Env as Env, types_InitSettings as InitSettings, types_Mapping as Mapping, types_PartialConfig as PartialConfig, types_Push as Push, types_PushEnvelope as PushEnvelope, types_Request as Request, types_Response as Response, types_Settings as Settings, types_Types as Types };
+}
+
+/**
+ * Google Cloud Pub/Sub push source.
+ *
+ * HTTP request handler. Pub/Sub POSTs each message envelope to the operator's
+ * endpoint; this source decodes the envelope, base64-decodes the data field,
+ * runs the configured decoder, and forwards the decoded value to the
+ * collector via env.push.
+ */
+declare const sourcePubSubPush: Source.Init<Types>;
 
-export { types as SourceCloudFunction, index as examples, index$1 as schemas, sourceCloudFunction };
+export { types$2 as SourceCloudFunction, types$1 as SourcePubSubPull, types as SourcePubSubPush, index as examples, index$1 as schemas, sourceCloudFunction, sourcePubSubPull, sourcePubSubPush };