sailfork / t3code-github / packages/ secret-provider-core/ src/ server/ SecretResolver.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import {
  SecretProviderId,
  SecretProviderKind,
  type SecretReference,
  type ServerSettings,
} from "@t3tools/contracts";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";

import { defineSecretProviderDriver } from "./driver.ts";
import * as SecretResolver from "./SecretResolver.ts";
import { defineSecretProvider } from "../shared/definition.ts";

const FAKE_KIND = SecretProviderKind.make("fake");
const FakeConfig = Schema.Struct({ account: Schema.String });

const personal = SecretProviderId.make("personal");
const work = SecretProviderId.make("work");
const fake = (account: string) => ({
  kind: FAKE_KIND,
  label: account,
  config: { account },
});
const ref = (reference: string, provider = personal): SecretReference => ({ provider, reference });

function fakeDriver(
  answer: (account: string, reference: string) => string | undefined,
  wait: (references: ReadonlyArray<string>) => Effect.Effect<void> = () => Effect.void,
) {
  const reads: Array<{ readonly account: string; readonly references: ReadonlyArray<string> }> = [];
  const driver = defineSecretProviderDriver({
    kind: FAKE_KIND,
    definition: defineSecretProvider({
      kind: FAKE_KIND,
      label: "Fake",
      configSchema: FakeConfig,
      isReference: (reference) => reference.startsWith("fake://"),
      referencePlaceholder: "fake://item",
      invalidReferenceMessage: "Use fake://item.",
    }),
    read: ({ account }, references) =>
      wait(references).pipe(
        Effect.andThen(
          Effect.sync(() => {
            reads.push({ account, references });
            return references.map((reference) => answer(account, reference));
          }),
        ),
      ),
  });
  return { driver, reads };
}

const resolverLayer = (
  driver: ReturnType<typeof fakeDriver>["driver"],
  secretProviders: () => ServerSettings["secretProviders"] = () => ({ [personal]: fake("a") }),
) =>
  SecretResolver.layer({
    drivers: [driver],
    secretProviders: Effect.sync(secretProviders),
  }).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));

describe("SecretResolver", () => {
  it.effect("reads a reference once and holds it", () => {
    const { driver, reads } = fakeDriver(() => "sk-live");
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;
      const token = ref("fake://openai");

      assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
      assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
      assert.deepStrictEqual(reads, [{ account: "a", references: ["fake://openai"] }]);
    }).pipe(Effect.provide(resolverLayer(driver)));
  });

  it.effect("holds a failed read until invalidated, then reads again", () => {
    let locked = true;
    const { driver, reads } = fakeDriver(() => (locked ? undefined : "sk-live"));
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;
      const token = ref("fake://openai");

      assert.deepStrictEqual(yield* resolver.read([token]), [undefined]);
      locked = false;
      assert.deepStrictEqual(yield* resolver.read([token]), [undefined]);
      assert.strictEqual(reads.length, 1);

      yield* resolver.invalidate([token]);
      assert.deepStrictEqual(yield* resolver.read([token]), ["sk-live"]);
      assert.strictEqual(reads.length, 2);
    }).pipe(Effect.provide(resolverLayer(driver)));
  });

  it.effect("answers a cached reference while another reference waits on its provider", () =>
    Effect.gen(function* () {
      const started = yield* Deferred.make<void>();
      const unlock = yield* Deferred.make<void>();
      const { driver } = fakeDriver(
        () => "sk-live",
        (references) =>
          references.includes("fake://slow")
            ? Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(unlock)))
            : Effect.void,
      );
      yield* Effect.gen(function* () {
        const resolver = yield* SecretResolver.SecretResolver;
        yield* resolver.read([ref("fake://cached")]);
        const slow = yield* Effect.forkChild(resolver.read([ref("fake://slow")]));
        yield* Deferred.await(started);

        assert.deepStrictEqual(yield* resolver.read([ref("fake://cached")]), ["sk-live"]);
        yield* Deferred.succeed(unlock, undefined);
        assert.deepStrictEqual(yield* Fiber.join(slow), ["sk-live"]);
      }).pipe(Effect.provide(resolverLayer(driver)));
    }),
  );

  it.effect("invalidates every reference when none are named", () => {
    const { driver, reads } = fakeDriver(() => "sk-live");
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;
      const token = ref("fake://openai");

      yield* resolver.read([token]);
      yield* resolver.invalidate();
      yield* resolver.read([token]);
      assert.strictEqual(reads.length, 2);
    }).pipe(Effect.provide(resolverLayer(driver)));
  });

  it.effect("reads each distinct reference of a provider in one call, in input order", () => {
    const { driver, reads } = fakeDriver((_, reference) => reference.toUpperCase());
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;

      const values = yield* resolver.read([ref("fake://a"), ref("fake://b"), ref("fake://a")]);

      assert.deepStrictEqual(values, ["FAKE://A", "FAKE://B", "FAKE://A"]);
      assert.deepStrictEqual(reads, [{ account: "a", references: ["fake://a", "fake://b"] }]);
    }).pipe(Effect.provide(resolverLayer(driver)));
  });

  it.effect("reads each provider separately", () => {
    const { driver, reads } = fakeDriver((account, reference) => `${account}:${reference}`);
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;

      const values = yield* resolver.read([ref("fake://a"), ref("fake://a", work)]);

      assert.deepStrictEqual(values, ["a:fake://a", "b:fake://a"]);
      assert.strictEqual(reads.length, 2);
    }).pipe(
      Effect.provide(resolverLayer(driver, () => ({ [personal]: fake("a"), [work]: fake("b") }))),
    );
  });

  it.effect("reads again when the provider's config changes", () => {
    let account = "a";
    const { driver, reads } = fakeDriver((account, reference) => `${account}:${reference}`);
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;
      const token = ref("fake://openai");

      assert.deepStrictEqual(yield* resolver.read([token]), ["a:fake://openai"]);
      account = "b";
      assert.deepStrictEqual(yield* resolver.read([token]), ["b:fake://openai"]);
      assert.deepStrictEqual(
        reads.map((read) => read.account),
        ["a", "b"],
      );
    }).pipe(Effect.provide(resolverLayer(driver, () => ({ [personal]: fake(account) }))));
  });

  it.effect("does not call a driver for what it cannot read, and reads it later", () => {
    const { driver, reads } = fakeDriver(() => "sk-live");
    const providers: ServerSettings["secretProviders"] = {
      [personal]: fake("a"),
      [SecretProviderId.make("vault")]: {
        kind: SecretProviderKind.make("openbao"),
        label: "Vault",
      },
      [SecretProviderId.make("broken")]: { kind: FAKE_KIND, label: "Broken", config: {} },
    };
    return Effect.gen(function* () {
      const resolver = yield* SecretResolver.SecretResolver;

      const values = yield* resolver.read([
        ref("fake://openai", SecretProviderId.make("missing")),
        ref("fake://openai", SecretProviderId.make("vault")),
        ref("fake://openai", SecretProviderId.make("broken")),
        ref("openai"),
      ]);

      assert.deepStrictEqual(values, [undefined, undefined, undefined, undefined]);
      assert.strictEqual(reads.length, 0);
    }).pipe(Effect.provide(resolverLayer(driver, () => providers)));
  });
});