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

package/src/s3.ts

@@ -1,3 +1,5 @@
+import { connect } from "node:net";
+
 import { create } from "@bufbuild/protobuf";
 import { EmptySchema } from "@bufbuild/protobuf/wkt";
 import {
@@ -5,6 +7,7 @@ import {
   ConnectError,
   createClient,
   type Client,
+  type Interceptor,
   type ServiceImpl,
 } from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
@@ -17,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();
 
@@ -35,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.
  */
@@ -496,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: unixSocketBaseUrl(socketPath),
-      nodeOptions: {
-        path: socketPath,
-      },
+      ...transportOptions,
+      ...(transportOptions.nodeOptions
+        ? {
+            nodeOptions: {
+              createConnection: () => connect(transportOptions.nodeOptions!.path),
+            },
+          }
+        : {}),
+      interceptors,
     });
     this.client = createClient(S3Service, transport);
   }
@@ -738,13 +770,46 @@ export class S3Object {
   }
 }
 
-function unixSocketBaseUrl(socketPath: string): string {
-  let hash = 0x811c9dc5;
-  for (const char of socketPath) {
-    hash ^= char.charCodeAt(0);
-    hash = Math.imul(hash, 0x01000193);
+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 },
+    };
   }
-  return `http://unix-${(hash >>> 0).toString(16)}.local`;
+  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> {
@@ -974,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 ?? "",
@@ -1008,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 ?? "",
@@ -1048,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;
@@ -1123,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,7 +1,9 @@
-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 {
@@ -26,6 +28,9 @@ import {
 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;
@@ -79,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);
   }
@@ -224,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);
+  };
+}