@valon-technologies/gestalt 0.0.1-alpha.11 → 0.0.1-alpha.13

package/src/s3.ts

@@ -7,6 +7,7 @@ import {
   ConnectError,
   createClient,
   type Client,
+  type Interceptor,
   type ServiceImpl,
 } from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
@@ -19,12 +20,19 @@ import {
   PresignObjectResponseSchema,
   ReadObjectChunkSchema,
   S3 as S3Service,
+  type ByteRange as ProtoByteRange,
+  type ReadObjectRequest as ProtoReadObjectRequest,
+  type S3ObjectMeta as ProtoS3ObjectMeta,
+  type S3ObjectRef as ProtoS3ObjectRef,
   WriteObjectResponseSchema,
 } from "../gen/v1/s3_pb.ts";
 import { errorMessage, type MaybePromise } from "./api.ts";
 import { RuntimeProvider, type RuntimeProviderOptions } from "./provider.ts";
 
-const ENV_S3_SOCKET = "GESTALT_S3_SOCKET";
+export const ENV_S3_SOCKET = "GESTALT_S3_SOCKET";
+const S3_SOCKET_TOKEN_SUFFIX = "_TOKEN";
+const S3_RELAY_TOKEN_HEADER = "x-gestalt-host-service-relay-token";
+export const ENV_S3_SOCKET_TOKEN = `${ENV_S3_SOCKET}${S3_SOCKET_TOKEN_SUFFIX}`;
 const WRITE_CHUNK_SIZE = 64 * 1024;
 const textEncoder = new TextEncoder();
 
@@ -37,6 +45,13 @@ export function s3SocketEnv(name?: string): string {
   return `${ENV_S3_SOCKET}_${trimmed.replace(/[^A-Za-z0-9]/g, "_").toUpperCase()}`;
 }
 
+/**
+ * Returns the environment variable name used to discover an S3 relay token.
+ */
+export function s3SocketTokenEnv(name?: string): string {
+  return `${s3SocketEnv(name)}${S3_SOCKET_TOKEN_SUFFIX}`;
+}
+
 /**
  * Error returned when an object reference does not exist.
  */
@@ -498,15 +513,30 @@ export class S3 {
 
   constructor(name?: string) {
     const envName = s3SocketEnv(name);
-    const socketPath = process.env[envName];
-    if (!socketPath) {
+    const target = process.env[envName];
+    if (!target) {
       throw new Error(`${envName} is not set`);
     }
+    const relayToken = process.env[s3SocketTokenEnv(name)]?.trim() ?? "";
+    const transportOptions = s3TransportOptions(target);
+    const interceptors: Interceptor[] = relayToken
+      ? [
+          (next) => async (req) => {
+            req.header.set(S3_RELAY_TOKEN_HEADER, relayToken);
+            return await next(req);
+          },
+        ]
+      : [];
     const transport = createGrpcTransport({
-      baseUrl: "http://localhost",
-      nodeOptions: {
-        createConnection: () => connect(socketPath),
-      },
+      ...transportOptions,
+      ...(transportOptions.nodeOptions
+        ? {
+            nodeOptions: {
+              createConnection: () => connect(transportOptions.nodeOptions!.path),
+            },
+          }
+        : {}),
+      interceptors,
     });
     this.client = createClient(S3Service, transport);
   }
@@ -740,6 +770,48 @@ export class S3Object {
   }
 }
 
+function s3TransportOptions(rawTarget: string): {
+  baseUrl: string;
+  nodeOptions?: { path: string };
+} {
+  const target = rawTarget.trim();
+  if (!target) {
+    throw new Error("s3 transport target is required");
+  }
+  if (target.startsWith("tcp://")) {
+    const address = target.slice("tcp://".length).trim();
+    if (!address) {
+      throw new Error(`s3 tcp target ${JSON.stringify(rawTarget)} is missing host:port`);
+    }
+    return { baseUrl: `http://${address}` };
+  }
+  if (target.startsWith("tls://")) {
+    const address = target.slice("tls://".length).trim();
+    if (!address) {
+      throw new Error(`s3 tls target ${JSON.stringify(rawTarget)} is missing host:port`);
+    }
+    return { baseUrl: `https://${address}` };
+  }
+  if (target.startsWith("unix://")) {
+    const socketPath = target.slice("unix://".length).trim();
+    if (!socketPath) {
+      throw new Error(`s3 unix target ${JSON.stringify(rawTarget)} is missing a socket path`);
+    }
+    return {
+      baseUrl: "http://localhost",
+      nodeOptions: { path: socketPath },
+    };
+  }
+  if (target.includes("://")) {
+    const parsed = new URL(target);
+    throw new Error(`Unsupported s3 target scheme ${JSON.stringify(parsed.protocol.replace(/:$/, ""))}`);
+  }
+  return {
+    baseUrl: "http://localhost",
+    nodeOptions: { path: target },
+  };
+}
+
 async function invokeS3Provider<T>(label: string, fn: () => Promise<T>): Promise<T> {
   try {
     return await fn();
@@ -967,7 +1039,7 @@ function toProtoObjectRef(ref: ObjectRef) {
   };
 }
 
-function fromProtoObjectRef(ref: { bucket?: string; key?: string; versionId?: string } | undefined): ObjectRef {
+function fromProtoObjectRef(ref: ProtoS3ObjectRef | undefined): ObjectRef {
   const value: ObjectRef = {
     bucket: ref?.bucket ?? "",
     key: ref?.key ?? "",
@@ -1001,15 +1073,7 @@ function toProtoObjectMeta(meta: ObjectMeta) {
   return value;
 }
 
-function fromProtoObjectMeta(meta: {
-  ref?: { bucket?: string; key?: string; versionId?: string };
-  etag?: string;
-  size?: bigint;
-  contentType?: string;
-  lastModified?: { seconds?: bigint; nanos?: number };
-  metadata?: Record<string, string>;
-  storageClass?: string;
-} | undefined): ObjectMeta {
+function fromProtoObjectMeta(meta: ProtoS3ObjectMeta | undefined): ObjectMeta {
   const value: ObjectMeta = {
     ref: fromProtoObjectRef(meta?.ref),
     etag: meta?.etag ?? "",
@@ -1041,27 +1105,21 @@ function toProtoReadOptions(options?: ReadOptions) {
   return proto;
 }
 
-function fromProtoReadOptions(request: {
-  range?: { start?: bigint; end?: bigint };
-  ifMatch?: string;
-  ifNoneMatch?: string;
-  ifModifiedSince?: { seconds?: bigint; nanos?: number };
-  ifUnmodifiedSince?: { seconds?: bigint; nanos?: number };
-}): ReadOptions {
+function fromProtoReadOptions(request: ProtoReadObjectRequest | undefined): ReadOptions {
   const options: ReadOptions = {};
-  if (request.range) {
+  if (request?.range) {
     options.range = fromProtoByteRange(request.range);
   }
-  if (request.ifMatch) {
+  if (request?.ifMatch) {
     options.ifMatch = request.ifMatch;
   }
-  if (request.ifNoneMatch) {
+  if (request?.ifNoneMatch) {
     options.ifNoneMatch = request.ifNoneMatch;
   }
-  if (request.ifModifiedSince) {
+  if (request?.ifModifiedSince) {
     options.ifModifiedSince = fromProtoTimestamp(request.ifModifiedSince);
   }
-  if (request.ifUnmodifiedSince) {
+  if (request?.ifUnmodifiedSince) {
     options.ifUnmodifiedSince = fromProtoTimestamp(request.ifUnmodifiedSince);
   }
   return options;
@@ -1116,12 +1174,12 @@ function toProtoByteRange(range: ByteRange) {
   return proto;
 }
 
-function fromProtoByteRange(range: { start?: bigint; end?: bigint }): ByteRange {
+function fromProtoByteRange(range: ProtoByteRange | undefined): ByteRange {
   const value: ByteRange = {};
-  if (range.start !== undefined) {
+  if (range?.start !== undefined) {
     value.start = range.start;
   }
-  if (range.end !== undefined) {
+  if (range?.end !== undefined) {
     value.end = range.end;
   }
   return value;

package/src/workflow-manager.ts

@@ -1,42 +1,79 @@
-import { connect } from "node:net";
-
 import type { MessageInitShape } from "@bufbuild/protobuf";
-import { createClient, type Client } from "@connectrpc/connect";
+import {
+  createClient,
+  type Client,
+  type Interceptor,
+} from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
 
 import {
   WorkflowManagerCreateScheduleRequestSchema,
+  WorkflowManagerCreateEventTriggerRequestSchema,
   WorkflowManagerDeleteScheduleRequestSchema,
+  WorkflowManagerDeleteEventTriggerRequestSchema,
   WorkflowManagerGetScheduleRequestSchema,
+  WorkflowManagerGetEventTriggerRequestSchema,
   WorkflowManagerHost as WorkflowManagerHostService,
   WorkflowManagerPauseScheduleRequestSchema,
+  WorkflowManagerPauseEventTriggerRequestSchema,
+  WorkflowManagerPublishEventRequestSchema,
   WorkflowManagerResumeScheduleRequestSchema,
+  WorkflowManagerResumeEventTriggerRequestSchema,
   WorkflowManagerUpdateScheduleRequestSchema,
+  WorkflowManagerUpdateEventTriggerRequestSchema,
   type ManagedWorkflowSchedule,
+  type ManagedWorkflowEventTrigger,
+  type WorkflowEvent,
 } from "../gen/v1/workflow_pb.ts";
 import type { Request } from "./api.ts";
 
 export const ENV_WORKFLOW_MANAGER_SOCKET = "GESTALT_WORKFLOW_MANAGER_SOCKET";
+export const ENV_WORKFLOW_MANAGER_SOCKET_TOKEN = `${ENV_WORKFLOW_MANAGER_SOCKET}_TOKEN`;
+const WORKFLOW_MANAGER_RELAY_TOKEN_HEADER =
+  "x-gestalt-host-service-relay-token";
 
 export type ManagedWorkflowScheduleMessage = ManagedWorkflowSchedule;
+export type ManagedWorkflowEventTriggerMessage = ManagedWorkflowEventTrigger;
+export type WorkflowEventMessage = WorkflowEvent;
 export type WorkflowManagerCreateScheduleInput = MessageInitShape<
   typeof WorkflowManagerCreateScheduleRequestSchema
 >;
+export type WorkflowManagerCreateTriggerInput = MessageInitShape<
+  typeof WorkflowManagerCreateEventTriggerRequestSchema
+>;
 export type WorkflowManagerGetScheduleInput = MessageInitShape<
   typeof WorkflowManagerGetScheduleRequestSchema
 >;
+export type WorkflowManagerGetTriggerInput = MessageInitShape<
+  typeof WorkflowManagerGetEventTriggerRequestSchema
+>;
 export type WorkflowManagerUpdateScheduleInput = MessageInitShape<
   typeof WorkflowManagerUpdateScheduleRequestSchema
 >;
+export type WorkflowManagerUpdateTriggerInput = MessageInitShape<
+  typeof WorkflowManagerUpdateEventTriggerRequestSchema
+>;
 export type WorkflowManagerDeleteScheduleInput = MessageInitShape<
   typeof WorkflowManagerDeleteScheduleRequestSchema
 >;
+export type WorkflowManagerDeleteTriggerInput = MessageInitShape<
+  typeof WorkflowManagerDeleteEventTriggerRequestSchema
+>;
 export type WorkflowManagerPauseScheduleInput = MessageInitShape<
   typeof WorkflowManagerPauseScheduleRequestSchema
 >;
+export type WorkflowManagerPauseTriggerInput = MessageInitShape<
+  typeof WorkflowManagerPauseEventTriggerRequestSchema
+>;
 export type WorkflowManagerResumeScheduleInput = MessageInitShape<
   typeof WorkflowManagerResumeScheduleRequestSchema
 >;
+export type WorkflowManagerResumeTriggerInput = MessageInitShape<
+  typeof WorkflowManagerResumeEventTriggerRequestSchema
+>;
+export type WorkflowManagerPublishEventInput = MessageInitShape<
+  typeof WorkflowManagerPublishEventRequestSchema
+>;
 
 export class WorkflowManager {
   private readonly client: Client<typeof WorkflowManagerHostService>;
@@ -47,18 +84,20 @@ export class WorkflowManager {
   constructor(requestOrToken: Request | string) {
     this.invocationToken = normalizeInvocationToken(requestOrToken);
 
-    const socketPath = process.env[ENV_WORKFLOW_MANAGER_SOCKET];
-    if (!socketPath) {
+    const target = process.env[ENV_WORKFLOW_MANAGER_SOCKET];
+    if (!target) {
       throw new Error(
         `workflow manager: ${ENV_WORKFLOW_MANAGER_SOCKET} is not set`,
       );
     }
+    const relayToken =
+      process.env[ENV_WORKFLOW_MANAGER_SOCKET_TOKEN]?.trim() ?? "";
 
     const transport = createGrpcTransport({
-      baseUrl: "http://localhost",
-      nodeOptions: {
-        createConnection: () => connect(socketPath),
-      },
+      ...workflowManagerTransportOptions(target),
+      interceptors: relayToken
+        ? [workflowManagerRelayTokenInterceptor(relayToken)]
+        : [],
     });
     this.client = createClient(WorkflowManagerHostService, transport);
   }
@@ -116,6 +155,69 @@ export class WorkflowManager {
       invocationToken: this.invocationToken,
     });
   }
+
+  async createTrigger(
+    request: WorkflowManagerCreateTriggerInput,
+  ): Promise<ManagedWorkflowEventTriggerMessage> {
+    return await this.client.createEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async getTrigger(
+    request: WorkflowManagerGetTriggerInput,
+  ): Promise<ManagedWorkflowEventTriggerMessage> {
+    return await this.client.getEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async updateTrigger(
+    request: WorkflowManagerUpdateTriggerInput,
+  ): Promise<ManagedWorkflowEventTriggerMessage> {
+    return await this.client.updateEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async deleteTrigger(
+    request: WorkflowManagerDeleteTriggerInput,
+  ): Promise<void> {
+    await this.client.deleteEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async pauseTrigger(
+    request: WorkflowManagerPauseTriggerInput,
+  ): Promise<ManagedWorkflowEventTriggerMessage> {
+    return await this.client.pauseEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async resumeTrigger(
+    request: WorkflowManagerResumeTriggerInput,
+  ): Promise<ManagedWorkflowEventTriggerMessage> {
+    return await this.client.resumeEventTrigger({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async publishEvent(
+    request: WorkflowManagerPublishEventInput,
+  ): Promise<WorkflowEventMessage> {
+    return await this.client.publishEvent({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
 }
 
 function normalizeInvocationToken(requestOrToken: Request | string): string {
@@ -129,3 +231,54 @@ function normalizeInvocationToken(requestOrToken: Request | string): string {
   }
   return trimmed;
 }
+
+function workflowManagerTransportOptions(rawTarget: string): {
+  baseUrl: string;
+  nodeOptions?: { path: string };
+} {
+  const target = rawTarget.trim();
+  if (!target) {
+    throw new Error("workflow manager: transport target is required");
+  }
+  if (target.startsWith("tcp://")) {
+    const address = target.slice("tcp://".length).trim();
+    if (!address) {
+      throw new Error(
+        `workflow manager: tcp target ${JSON.stringify(rawTarget)} is missing host:port`,
+      );
+    }
+    return { baseUrl: `http://${address}` };
+  }
+  if (target.startsWith("tls://")) {
+    const address = target.slice("tls://".length).trim();
+    if (!address) {
+      throw new Error(
+        `workflow manager: tls target ${JSON.stringify(rawTarget)} is missing host:port`,
+      );
+    }
+    return { baseUrl: `https://${address}` };
+  }
+  if (target.startsWith("unix://")) {
+    const socketPath = target.slice("unix://".length).trim();
+    if (!socketPath) {
+      throw new Error(
+        `workflow manager: unix target ${JSON.stringify(rawTarget)} is missing a socket path`,
+      );
+    }
+    return { baseUrl: "http://localhost", nodeOptions: { path: socketPath } };
+  }
+  if (target.includes("://")) {
+    const parsed = new URL(target);
+    throw new Error(
+      `workflow manager: unsupported target scheme ${JSON.stringify(parsed.protocol.replace(/:$/, ""))}`,
+    );
+  }
+  return { baseUrl: "http://localhost", nodeOptions: { path: target } };
+}
+
+function workflowManagerRelayTokenInterceptor(token: string): Interceptor {
+  return (next) => async (req) => {
+    req.header.set(WORKFLOW_MANAGER_RELAY_TOKEN_HEADER, token);
+    return next(req);
+  };
+}