Resource APIs

import { storage } from "@alienplatform/sdk"

const store = storage("data")  // same name as in alien.ts
await store.put("reports/q1.json", Buffer.from(JSON.stringify(report)))

import { storage } from "@alienplatform/sdk"

const store = storage("files")

// Write (bytes)
await store.put("reports/q1.json", Buffer.from(JSON.stringify(report)))

// Read — get() returns data plus object metadata
const result = await store.get("reports/q1.json")
const content = result.data.toString("utf8")
console.log(result.meta.eTag, result.attributes.contentType)

// List — resolves to an array of object metadata
for (const entry of await store.list("reports/")) {
  console.log(entry.location, entry.size)
}

// Delete
await store.delete("reports/old.json")

// Presigned request for direct browser uploads/downloads
const req = await store.signedUrl({
  method: "GET",
  path: "reports/q1.json",
  expiresIn: 3600,
})

import { kv } from "@alienplatform/sdk"

const cache = kv("cache")

// Write (with optional TTL in seconds)
await cache.setJson("user:123", { name: "Alice" })
await cache.set("session:abc", token, { ttl: 3600 })

// Read — entries carry the value plus an opaque version for conditional writes
const user = await cache.getJson<{ name: string }>("user:123")
console.log(user?.value.name, user?.version)
const session = await cache.getText("session:abc")
console.log(session?.value)

// Scan by prefix — resolves to a page of items plus a cursor
const page = await cache.scan("user:")
for (const entry of page.items) {
  console.log(entry.key, entry.value.toString("utf8"))
}

// Delete
await cache.delete("user:123")

import { queue } from "@alienplatform/sdk"

const q = queue("tasks")  // bind the queue once by name
await q.send({ type: "process", id: "abc" })  // serialized as JSON
await q.sendText("raw text message")

import { vault } from "@alienplatform/sdk"

const secrets = vault("credentials")

// Read a secret (get() resolves to a string; getJson() parses it)
const config = await secrets.getJson<{ host: string; database: string; password: string }>("database")

// Connect to the customer's database using their own credentials
const pool = new Pool({
    host: config.host,
    database: config.database,
    password: config.password,  // read at runtime from the customer vault
})

import { container } from "@alienplatform/sdk"

const api = container("api")

const internalUrl = await api.getInternalUrl()  // reachable from the deployment's private network
const publicUrl = await api.getPublicUrl()      // null when the container has no public endpoint

import { kv, onQueueMessage } from "@alienplatform/sdk"

onQueueMessage("*", async (message) => {
  const store = kv("events")
  await store.setJson(`queue:${message.id}`, {
    source: message.source,
    payload: message.payload,
    processedAt: new Date().toISOString(),
  })
})

import { onStorageEvent } from "@alienplatform/sdk"

onStorageEvent("*", async (event) => {
  console.log(event.eventType, event.objectKey, event.size)
  // "created", "uploads/photo.jpg", 1048576
})

import { onCronEvent } from "@alienplatform/sdk"

onCronEvent("*", async (event) => {
  console.log(event.scheduleName, event.timestamp)
  // run cleanup, generate reports, sync data...
})

import { command, vault, kv } from "@alienplatform/sdk"
import { z } from "zod"

command(
  "query",
  z.object({ sql: z.string(), useCache: z.boolean() }),
  async ({ sql, useCache }) => {
    const secrets = vault("credentials")
    const cache = kv("cache")

    if (useCache) {
      const cached = await cache.getJson(`query:${hash(sql)}`)
      if (cached) return { ...cached, cached: true }
    }

    const config = await secrets.getJson<DbConfig>("database")
    const result = await runQuery(config, sql)

    if (useCache) {
      await cache.setJson(`query:${hash(sql)}`, result)
    }

    return { ...result, cached: false }
  },
)