@alienplatform/sdk 1.14.1 → 2.0.1

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/sdk"
- *
- * 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/sdk"
- *
- * 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")
-  }
-}