The best way to control Claude Code, Codex and more from any computer or phone

main
ts 125 lines 4.52 KB
Raw
1 import {
2 PRISMA_AUTH_PROVIDER_NAME,
3 PrismaAuth,
4 type PrismaAuthConfig,
5 type PrismaResolvedCredentials,
6 } from "@alchemy.run/prisma/AuthProvider";
7 import { describe, expect, it } from "@alchemy.run/test";
8 import * as NodeServices from "@effect/platform-node/NodeServices";
9 import { AuthProviders, getAuthProvider } from "alchemy/Auth/AuthProvider";
10 import { ProfileStore } from "alchemy/Auth/Profile";
11 import * as Interaction from "alchemy/Interaction";
12 import * as ConfigProvider from "effect/ConfigProvider";
13 import * as Effect from "effect/Effect";
14 import * as Layer from "effect/Layer";
15 import * as Redacted from "effect/Redacted";
16 import { makeFakeProfileStore } from "./fakes.ts";
17
18 const fakeProfile = makeFakeProfileStore();
19
20 const testLayer = (config: Record<string, string> = {}) => {
21 const authProviders: AuthProviders["Service"] = {};
22 const authRegistry = Layer.succeed(AuthProviders, authProviders);
23 const base = Layer.mergeAll(
24 NodeServices.layer,
25 authRegistry,
26 Layer.succeed(ProfileStore, fakeProfile),
27 ConfigProvider.layer(ConfigProvider.fromUnknown(config)),
28 Interaction.layerNonInteractive(),
29 );
30 return PrismaAuth.pipe(Layer.provideMerge(base));
31 };
32
33 const prismaAuthProvider = getAuthProvider<PrismaAuthConfig, PrismaResolvedCredentials>(
34 PRISMA_AUTH_PROVIDER_NAME,
35 );
36
37 const readStoredCredentials = Effect.gen(function* () {
38 const auth = yield* prismaAuthProvider;
39 return yield* auth.read(
40 "default",
41 Effect.succeed({ method: "stored" as const, serviceToken: "stored-token" }),
42 );
43 });
44
45 const readEnvironmentCredentials = Effect.gen(function* () {
46 const auth = yield* prismaAuthProvider;
47 if (auth.readEnvironment === undefined) {
48 return yield* Effect.die("Prisma does not expose CI environment credentials");
49 }
50 return yield* auth.readEnvironment;
51 });
52
53 describe("Prisma auth provider", { tags: ["unit", "provider:prisma", "local"] }, () => {
54 it.effect("reads PRISMA_SERVICE_TOKEN for CI", () =>
55 Effect.gen(function* () {
56 const credentials = yield* readEnvironmentCredentials;
57 expect(credentials.source).toEqual({ type: "env", details: "PRISMA_SERVICE_TOKEN" });
58 expect(Redacted.value(credentials.serviceToken)).toBe("service-token");
59 }).pipe(Effect.provide(testLayer({ PRISMA_SERVICE_TOKEN: "service-token" }))),
60 );
61
62 it.effect("falls back to PRISMA_API_TOKEN for CI", () =>
63 Effect.gen(function* () {
64 const credentials = yield* readEnvironmentCredentials;
65 expect(credentials.source).toEqual({ type: "env", details: "PRISMA_API_TOKEN" });
66 expect(Redacted.value(credentials.serviceToken)).toBe("api-token");
67 }).pipe(Effect.provide(testLayer({ PRISMA_API_TOKEN: "api-token" }))),
68 );
69
70 it.effect("reads inline stored Prisma service tokens", () =>
71 Effect.gen(function* () {
72 const credentials = yield* readStoredCredentials;
73
74 expect(credentials.type).toBe("serviceToken");
75 expect(credentials.source).toEqual({ type: "stored" });
76 expect(Redacted.value(credentials.serviceToken)).toBe("stored-token");
77 }).pipe(Effect.provide(testLayer())),
78 );
79
80 it.effect("returns redacted details for stored credentials", () =>
81 Effect.gen(function* () {
82 const auth = yield* prismaAuthProvider;
83 const details = yield* auth.details(
84 "default",
85 Effect.succeed({ method: "stored" as const, serviceToken: "stored-token" }),
86 );
87
88 expect(details.lines).toEqual([{ key: "serviceToken", value: "stor****" }]);
89 }).pipe(Effect.provide(testLayer())),
90 );
91
92 it.effect("rejects whitespace-only service tokens in configureWith", () =>
93 Effect.gen(function* () {
94 const auth = yield* prismaAuthProvider;
95 if (auth.configureWith === undefined) {
96 return yield* Effect.die("Prisma does not expose flag-driven configuration");
97 }
98 const error = yield* auth
99 .configureWith("default", { method: "stored", values: { serviceToken: " " } })
100 .pipe(Effect.flip);
101
102 expect(error._tag).toBe("AuthError");
103 expect(error.message).toContain("invalid 'serviceToken'");
104 }).pipe(Effect.provide(testLayer())),
105 );
106
107 it.effect("declares the stored configure method", () =>
108 Effect.gen(function* () {
109 const auth = yield* prismaAuthProvider;
110
111 expect(auth.configureMethods).toEqual([
112 {
113 method: "stored",
114 fields: [
115 expect.objectContaining({
116 name: "serviceToken",
117 label: "Prisma Service Token",
118 secret: true,
119 }),
120 ],
121 },
122 ]);
123 }).pipe(Effect.provide(testLayer())),
124 );
125 });