sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Neon/ StorageHttp.test.ts

import * as AWS from "@alchemy.run/aws";
import * as Cloudflare from "@alchemy.run/cloudflare";
import { bucketStorageClient, type BucketAttributes } from "@alchemy.run/neon/Bucket";
import { storageBodyBytes } from "@alchemy.run/neon/Object";
import { providers } from "@alchemy.run/neon/Providers";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as SDK from "@distilled.cloud/neon";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as Layer from "effect/Layer";
import * as Schedule from "effect/Schedule";
import StorageHttpLambda from "./fixtures/StorageHttpLambda.ts";
import StorageHttpWorker from "./fixtures/StorageHttpWorker.ts";
import { StorageBucket } from "./fixtures/StorageResources.ts";

const { test: workerTest } = Test.make({
  providers: Layer.mergeAll(providers(), Cloudflare.providers()),
});
const { test: lambdaTest } = Test.make({
  providers: Layer.mergeAll(providers(), AWS.providers()),
});

const verify = Effect.fn(function* (url: string, bucket: BucketAttributes) {
  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
  const response = yield* http
    .get(`${url}/write`)
    .pipe(Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 8 }));
  expect(response.status).toBe(200);
  expect(yield* (yield* http.get(url)).json).toEqual({
    size: 18,
    hasAccountKey: false,
  });
  const client = yield* bucketStorageClient(bucket);
  const bytes = yield* storageBodyBytes((yield* client.get("external.txt"))?.Body);
  expect(yield* Effect.sync(() => new TextDecoder().decode(bytes))).toBe("external roundtrip");
  const scope = { project_id: bucket.projectId, branch_id: bucket.branchId };
  const credentials = (yield* SDK.listCredentials(scope)).credentials.filter(
    (credential) => credential.branch_id === bucket.branchId && !credential.revoked_at,
  );
  expect(
    credentials.map((credential) => credential.scopes).sort((a, b) => a.length - b.length),
  ).toEqual([
    ["storage:read"],
    ["storage:read", "storage:write"],
    ["storage:read", "storage:write"],
  ]);
  return credentials
    .filter((credential) => credential.token_id !== bucket.credential.tokenId)
    .map((credential) => credential.token_id);
});

workerTest.provider(
  "Worker HTTP storage uses scoped credentials and revokes them when unbound",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const { worker, bucket } = yield* stack.deploy(
        Effect.gen(function* () {
          return {
            worker: yield* StorageHttpWorker,
            bucket: yield* StorageBucket,
          };
        }),
      );
      const tokens = yield* verify(worker.url!, bucket);
      yield* stack.deploy(StorageBucket);
      const remaining = (yield* SDK.listCredentials({
        project_id: bucket.projectId,
        branch_id: bucket.branchId,
      })).credentials;
      expect(
        remaining.some(
          (credential) => tokens.includes(credential.token_id) && !credential.revoked_at,
        ),
      ).toBe(false);
      yield* stack.destroy();
      yield* stack.destroy();
    }),
  {
    tags: [
      "provider:cloudflare",
      "provider:cloudflare:worker",
      "provider:neon",
      "provider:neon:branch",
      "provider:neon:bucket",
      "provider:neon:object",
      "provider:neon:project",
      "live",
    ],
    timeout: 120_000,
  },
);

lambdaTest.provider(
  "Lambda HTTP storage uses namespaced non-account secrets",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const { fn, bucket } = yield* stack.deploy(
        Effect.gen(function* () {
          return { fn: yield* StorageHttpLambda, bucket: yield* StorageBucket };
        }),
      );
      const tokens = yield* verify(fn.functionUrl!, bucket);
      yield* stack.deploy(StorageBucket);
      const remaining = (yield* SDK.listCredentials({
        project_id: bucket.projectId,
        branch_id: bucket.branchId,
      })).credentials;
      expect(
        remaining.some(
          (credential) => tokens.includes(credential.token_id) && !credential.revoked_at,
        ),
      ).toBe(false);
      yield* stack.destroy();
      yield* stack.destroy();
    }),
  {
    tags: [
      "provider:aws",
      "provider:aws:lambda",
      "provider:neon",
      "provider:neon:branch",
      "provider:neon:bucket",
      "provider:neon:object",
      "provider:neon:project",
      "live",
    ],
    timeout: 240_000,
  },
);