@alienplatform/bindings 1.0.0 → 2.0.0

package/src/bindings/function.ts

@@ -1,164 +0,0 @@
-/**
- * Function binding implementation.
- *
- * Provides direct function-to-function invocation.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  FunctionServiceDefinition,
-  type FunctionServiceClient as GeneratedClient,
-} from "../generated/function.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { FunctionInvokeRequest, FunctionInvokeResponse } from "../types.js"
-
-/**
- * Function binding for direct function invocation.
- *
- * @example
- * ```typescript
- * import { func } from "@alienplatform/bindings"
- *
- * const processor = func("image-processor")
- *
- * // Invoke with JSON body
- * const response = await processor.invokeJson("resize-image", {
- *   imageUrl: "https://...",
- *   width: 800,
- *   height: 600,
- * })
- *
- * // Get function URL
- * const url = await processor.getUrl()
- * ```
- */
-export class FunctionBinding {
-  private readonly client: GeneratedClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(FunctionServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Invoke a function with raw request data.
-   *
-   * @param request - Invocation request
-   * @returns Function response
-   */
-  async invoke(request: FunctionInvokeRequest): Promise<FunctionInvokeResponse> {
-    return await wrapGrpcCall(
-      "FunctionService",
-      "Invoke",
-      async () => {
-        const response = await this.client.invoke({
-          bindingName: this.bindingName,
-          targetFunction: request.targetFunction,
-          method: request.method,
-          path: request.path,
-          headers: request.headers ?? {},
-          body: request.body ?? new Uint8Array(),
-          timeoutSeconds: request.timeoutMs ? Math.floor(request.timeoutMs / 1000) : undefined,
-        })
-        return {
-          status: response.status,
-          headers: response.headers,
-          body: response.body,
-        }
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Invoke a function with a JSON body.
-   *
-   * @param targetFunction - Target function identifier
-   * @param body - JSON body
-   * @param options - Optional request options
-   * @returns Parsed JSON response
-   */
-  async invokeJson<TRequest, TResponse = unknown>(
-    targetFunction: string,
-    body: TRequest,
-    options?: {
-      method?: string
-      path?: string
-      headers?: Record<string, string>
-      timeoutMs?: number
-    },
-  ): Promise<TResponse> {
-    const response = await this.invoke({
-      targetFunction,
-      method: options?.method ?? "POST",
-      path: options?.path ?? "/",
-      headers: {
-        "content-type": "application/json",
-        ...options?.headers,
-      },
-      body: new TextEncoder().encode(JSON.stringify(body)),
-      timeoutMs: options?.timeoutMs,
-    })
-
-    if (response.status >= 400) {
-      const errorText = new TextDecoder().decode(response.body)
-      throw new Error(`Function invocation failed with status ${response.status}: ${errorText}`)
-    }
-
-    const responseText = new TextDecoder().decode(response.body)
-    return JSON.parse(responseText) as TResponse
-  }
-
-  /**
-   * Invoke a function with GET request.
-   *
-   * @param targetFunction - Target function identifier
-   * @param path - Request path
-   * @param options - Optional request options
-   * @returns Parsed JSON response
-   */
-  async get<TResponse = unknown>(
-    targetFunction: string,
-    path = "/",
-    options?: {
-      headers?: Record<string, string>
-      timeoutMs?: number
-    },
-  ): Promise<TResponse> {
-    const response = await this.invoke({
-      targetFunction,
-      method: "GET",
-      path,
-      headers: options?.headers,
-      timeoutMs: options?.timeoutMs,
-    })
-
-    if (response.status >= 400) {
-      const errorText = new TextDecoder().decode(response.body)
-      throw new Error(`Function GET failed with status ${response.status}: ${errorText}`)
-    }
-
-    const responseText = new TextDecoder().decode(response.body)
-    return JSON.parse(responseText) as TResponse
-  }
-
-  /**
-   * Get the public URL of the function.
-   *
-   * @returns Function URL if available
-   */
-  async getUrl(): Promise<string | undefined> {
-    return await wrapGrpcCall(
-      "FunctionService",
-      "GetFunctionUrl",
-      async () => {
-        const response = await this.client.getFunctionUrl({
-          bindingName: this.bindingName,
-        })
-        return response.url
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-}

package/src/bindings/index.ts

@@ -1,12 +0,0 @@
-/**
- * Binding exports.
- */
-
-export { Storage } from "./storage.js"
-export { Kv } from "./kv.js"
-export { Queue } from "./queue.js"
-export { Vault } from "./vault.js"
-export { Build } from "./build.js"
-export { ArtifactRegistry } from "./artifact-registry.js"
-export { FunctionBinding } from "./function.js"
-export { ServiceAccount } from "./service-account.js"

package/src/bindings/kv.ts

@@ -1,240 +0,0 @@
-/**
- * KV binding implementation.
- *
- * Provides key-value storage operations with TTL support.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  type KvServiceClient as GeneratedKvServiceClient,
-  KvServiceDefinition,
-} from "../generated/kv.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { KvPutOptions, KvScanResult } from "../types.js"
-
-/**
- * KV binding for key-value storage operations.
- *
- * @example
- * ```typescript
- * import { kv } from "@alienplatform/bindings"
- *
- * const cache = kv("my-cache")
- *
- * // Set a value
- * await cache.set("user:123", { name: "John", email: "john@example.com" })
- *
- * // Get a value
- * const user = await cache.getJson<User>("user:123")
- *
- * // Set with TTL (expires in 1 hour)
- * await cache.set("session:abc", sessionData, { ttlMs: 60 * 60 * 1000 })
- *
- * // Delete
- * await cache.delete("user:123")
- *
- * // Scan by prefix
- * for await (const { key, value } of cache.scan("user:")) {
- *   console.log(key, value)
- * }
- * ```
- */
-export class Kv {
-  private readonly client: GeneratedKvServiceClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(KvServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Get a value by key.
-   *
-   * @param key - Key to retrieve
-   * @returns Value as Uint8Array, or undefined if not found
-   */
-  async get(key: string): Promise<Uint8Array | undefined> {
-    return await wrapGrpcCall(
-      "KvService",
-      "Get",
-      async () => {
-        const response = await this.client.get({
-          bindingName: this.bindingName,
-          key,
-        })
-        return response.value
-      },
-      { bindingName: this.bindingName, key },
-    )
-  }
-
-  /**
-   * Get a value as a UTF-8 string.
-   *
-   * @param key - Key to retrieve
-   * @returns Value as string, or undefined if not found
-   */
-  async getText(key: string): Promise<string | undefined> {
-    const value = await this.get(key)
-    return value ? new TextDecoder().decode(value) : undefined
-  }
-
-  /**
-   * Get a value and parse as JSON.
-   *
-   * @param key - Key to retrieve
-   * @returns Parsed JSON value, or undefined if not found
-   */
-  async getJson<T = unknown>(key: string): Promise<T | undefined> {
-    const text = await this.getText(key)
-    return text ? (JSON.parse(text) as T) : undefined
-  }
-
-  /**
-   * Set a value.
-   *
-   * @param key - Key to store
-   * @param value - Value to store (string, Uint8Array, or object for JSON)
-   * @param options - Optional put options (TTL, ifNotExists)
-   * @returns True if stored, false if ifNotExists was true and key already exists
-   */
-  async set(
-    key: string,
-    value: string | Uint8Array | object,
-    options?: KvPutOptions,
-  ): Promise<boolean> {
-    let bytes: Uint8Array
-
-    if (typeof value === "string") {
-      bytes = new TextEncoder().encode(value)
-    } else if (value instanceof Uint8Array) {
-      bytes = value
-    } else {
-      bytes = new TextEncoder().encode(JSON.stringify(value))
-    }
-
-    return await wrapGrpcCall(
-      "KvService",
-      "Put",
-      async () => {
-        const response = await this.client.put({
-          bindingName: this.bindingName,
-          key,
-          value: bytes,
-          options: options
-            ? {
-                ttlSeconds: options.ttlMs ? Math.floor(options.ttlMs / 1000) : undefined,
-                ifNotExists: options.ifNotExists ?? false,
-              }
-            : undefined,
-        })
-        return response.success
-      },
-      { bindingName: this.bindingName, key },
-    )
-  }
-
-  /**
-   * Delete a key.
-   *
-   * @param key - Key to delete
-   */
-  async delete(key: string): Promise<void> {
-    await wrapGrpcCall(
-      "KvService",
-      "Delete",
-      async () => {
-        await this.client.delete({
-          bindingName: this.bindingName,
-          key,
-        })
-      },
-      { bindingName: this.bindingName, key },
-    )
-  }
-
-  /**
-   * Check if a key exists.
-   *
-   * @param key - Key to check
-   * @returns True if the key exists
-   */
-  async exists(key: string): Promise<boolean> {
-    return await wrapGrpcCall(
-      "KvService",
-      "Exists",
-      async () => {
-        const response = await this.client.exists({
-          bindingName: this.bindingName,
-          key,
-        })
-        return response.exists
-      },
-      { bindingName: this.bindingName, key },
-    )
-  }
-
-  /**
-   * Scan keys with a prefix.
-   *
-   * @param prefix - Prefix to scan for
-   * @param options - Optional scan options (limit)
-   * @returns Async iterable of key-value pairs
-   *
-   * @example
-   * ```typescript
-   * // Scan all users
-   * for await (const { key, value } of cache.scan("user:")) {
-   *   console.log(key, new TextDecoder().decode(value))
-   * }
-   * ```
-   */
-  async *scan(
-    prefix: string,
-    options?: { limit?: number },
-  ): AsyncIterable<{ key: string; value: Uint8Array }> {
-    let cursor: string | undefined
-
-    do {
-      const result = await this.scanPage(prefix, options?.limit, cursor)
-
-      for (const item of result.items) {
-        yield item
-      }
-
-      cursor = result.nextCursor
-    } while (cursor)
-  }
-
-  /**
-   * Scan a single page of results.
-   *
-   * @param prefix - Prefix to scan for
-   * @param limit - Maximum items to return
-   * @param cursor - Pagination cursor
-   * @returns Scan result with items and next cursor
-   */
-  async scanPage(prefix: string, limit?: number, cursor?: string): Promise<KvScanResult> {
-    return await wrapGrpcCall(
-      "KvService",
-      "ScanPrefix",
-      async () => {
-        const response = await this.client.scanPrefix({
-          bindingName: this.bindingName,
-          prefix,
-          limit,
-          cursor,
-        })
-        return {
-          items: response.items.map(item => ({
-            key: item.key,
-            value: item.value,
-          })),
-          nextCursor: response.nextCursor,
-        }
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-}

package/src/bindings/queue.ts

@@ -1,191 +0,0 @@
-/**
- * Queue binding implementation.
- *
- * Provides message queue operations for async task processing.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  type QueueServiceClient as GeneratedQueueServiceClient,
-  type MessagePayload,
-  type QueueMessage as QueueMessageProto,
-  QueueServiceDefinition,
-} from "../generated/queue.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { ReceivedQueueMessage } from "../types.js"
-
-/**
- * Queue binding for message queue operations.
- *
- * @example
- * ```typescript
- * import { queue } from "@alienplatform/bindings"
- *
- * const tasks = queue("task-queue")
- *
- * // Send a message (JSON)
- * await tasks.send("process-image", { imageId: "123", format: "webp" })
- *
- * // Receive messages
- * const messages = await tasks.receive("process-image", 10)
- * for (const msg of messages) {
- *   await processImage(msg.payload)
- *   await tasks.ack("process-image", msg.receiptHandle)
- * }
- * ```
- */
-export class Queue {
-  private readonly client: GeneratedQueueServiceClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(QueueServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Send a message to a queue.
-   *
-   * @param queueName - Name of the queue
-   * @param payload - Message payload (object for JSON, string for text)
-   */
-  async send(queueName: string, payload: unknown): Promise<void> {
-    const message = this.toProtoPayload(payload)
-
-    await wrapGrpcCall(
-      "QueueService",
-      "Send",
-      async () => {
-        await this.client.send({
-          bindingName: this.bindingName,
-          queue: queueName,
-          message,
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Send a text message to a queue.
-   *
-   * @param queueName - Name of the queue
-   * @param text - Text message
-   */
-  async sendText(queueName: string, text: string): Promise<void> {
-    await wrapGrpcCall(
-      "QueueService",
-      "Send",
-      async () => {
-        await this.client.send({
-          bindingName: this.bindingName,
-          queue: queueName,
-          message: { text },
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Receive messages from a queue.
-   *
-   * @param queueName - Name of the queue
-   * @param maxMessages - Maximum number of messages to receive (1-10)
-   * @returns Array of messages with receipt handles
-   */
-  async receive<T = unknown>(
-    queueName: string,
-    maxMessages = 1,
-  ): Promise<ReceivedQueueMessage<T>[]> {
-    return await wrapGrpcCall(
-      "QueueService",
-      "Receive",
-      async () => {
-        const response = await this.client.receive({
-          bindingName: this.bindingName,
-          queue: queueName,
-          maxMessages: Math.min(Math.max(1, maxMessages), 10),
-        })
-        return response.messages.map(msg => this.fromProtoMessage<T>(msg))
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Acknowledge a message (remove it from the queue).
-   *
-   * @param queueName - Name of the queue
-   * @param receiptHandle - Receipt handle from the received message
-   */
-  async ack(queueName: string, receiptHandle: string): Promise<void> {
-    await wrapGrpcCall(
-      "QueueService",
-      "Ack",
-      async () => {
-        await this.client.ack({
-          bindingName: this.bindingName,
-          queue: queueName,
-          receiptHandle,
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Process messages from a queue with automatic acknowledgment.
-   *
-   * @param queueName - Name of the queue
-   * @param handler - Handler function for each message
-   * @param options - Processing options
-   *
-   * @example
-   * ```typescript
-   * await tasks.process("image-tasks", async (payload) => {
-   *   await processImage(payload.imageId)
-   * })
-   * ```
-   */
-  async process<T = unknown>(
-    queueName: string,
-    handler: (payload: T) => Promise<void>,
-    options?: { maxMessages?: number },
-  ): Promise<void> {
-    const maxMessages = options?.maxMessages ?? 10
-
-    const messages = await this.receive<T>(queueName, maxMessages)
-
-    for (const message of messages) {
-      await handler(message.payload)
-      await this.ack(queueName, message.receiptHandle)
-    }
-  }
-
-  // Private helpers
-
-  private toProtoPayload(payload: unknown): MessagePayload {
-    if (typeof payload === "string") {
-      return { text: payload }
-    }
-    return { json: JSON.stringify(payload) }
-  }
-
-  private fromProtoMessage<T>(proto: QueueMessageProto): ReceivedQueueMessage<T> {
-    let payload: unknown
-
-    if (proto.payload?.json) {
-      payload = JSON.parse(proto.payload.json)
-    } else if (proto.payload?.text) {
-      payload = proto.payload.text
-    } else {
-      payload = null
-    }
-
-    return {
-      payload: payload as T,
-      receiptHandle: proto.receiptHandle,
-    }
-  }
-}

package/src/bindings/service-account.ts

@@ -1,113 +0,0 @@
-/**
- * ServiceAccount binding implementation.
- *
- * Provides identity and impersonation capabilities.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  type ServiceAccountServiceClient as GeneratedClient,
-  type ServiceAccountInfo as ServiceAccountInfoProto,
-  ServiceAccountServiceDefinition,
-} from "../generated/service_account.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { ImpersonationRequest, ServiceAccountInfo } from "../types.js"
-
-/**
- * ServiceAccount binding for identity and impersonation.
- *
- * @example
- * ```typescript
- * import { serviceAccount } from "@alienplatform/bindings"
- *
- * const sa = serviceAccount("deployment-account")
- *
- * // Get account info
- * const info = await sa.getInfo()
- * if (info.platform === "aws") {
- *   console.log("Role ARN:", info.roleArn)
- * }
- *
- * // Impersonate the service account
- * const config = await sa.impersonate({ durationSeconds: 3600 })
- * ```
- */
-export class ServiceAccount {
-  private readonly client: GeneratedClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(ServiceAccountServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Get information about the service account.
-   *
-   * @returns Platform-specific service account information
-   */
-  async getInfo(): Promise<ServiceAccountInfo> {
-    return await wrapGrpcCall(
-      "ServiceAccountService",
-      "GetInfo",
-      async () => {
-        const response = await this.client.getInfo({
-          bindingName: this.bindingName,
-        })
-        return this.fromProtoInfo(response.info!)
-      },
-      { bindingName: this.bindingName, bindingType: "ServiceAccount" },
-    )
-  }
-
-  /**
-   * Impersonate the service account.
-   *
-   * @param request - Impersonation options
-   * @returns Client configuration for the impersonated identity
-   */
-  async impersonate(request?: ImpersonationRequest): Promise<unknown> {
-    return await wrapGrpcCall(
-      "ServiceAccountService",
-      "Impersonate",
-      async () => {
-        const response = await this.client.impersonate({
-          bindingName: this.bindingName,
-          sessionName: request?.sessionName,
-          durationSeconds: request?.durationSeconds,
-          scopes: request?.scopes ?? [],
-        })
-        return JSON.parse(response.clientConfigJson)
-      },
-      { bindingName: this.bindingName, bindingType: "ServiceAccount" },
-    )
-  }
-
-  // Private helpers
-
-  private fromProtoInfo(proto: ServiceAccountInfoProto): ServiceAccountInfo {
-    if (proto.aws) {
-      return {
-        platform: "aws",
-        roleName: proto.aws.roleName,
-        roleArn: proto.aws.roleArn,
-      }
-    }
-    if (proto.gcp) {
-      return {
-        platform: "gcp",
-        email: proto.gcp.email,
-        uniqueId: proto.gcp.uniqueId,
-      }
-    }
-    if (proto.azure) {
-      return {
-        platform: "azure",
-        clientId: proto.azure.clientId,
-        resourceId: proto.azure.resourceId,
-        principalId: proto.azure.principalId,
-      }
-    }
-    throw new Error("Unknown service account platform")
-  }
-}