import { PrismaAuth } from "@alchemy.run/prisma/AuthProvider";
import { PrismaEnvironment, fromProfile } from "@alchemy.run/prisma/PrismaEnvironment";
import { describe, expect, it } from "@alchemy.run/test";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { AuthProviders } from "alchemy/Auth/AuthProvider";
import { ProfileStore } from "alchemy/Auth/Profile";
import * as Interaction from "alchemy/Interaction";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import { makeFakeProfileStore } from "./fakes.ts";
const makeProfile = (serviceToken: string): ProfileStore["Service"] =>
makeFakeProfileStore({
loadProviderConfig: <Config extends { method: string }>() =>
Effect.succeed({ method: "stored", serviceToken } as unknown as Config),
});
const testLayer = (config: Record<string, string>, options: { storedToken?: string } = {}) => {
const authProviders: AuthProviders["Service"] = {};
return fromProfile().pipe(
Layer.provideMerge(PrismaAuth),
Layer.provideMerge(Layer.succeed(AuthProviders, authProviders)),
Layer.provideMerge(
Layer.succeed(ProfileStore, makeProfile(options.storedToken ?? "test-token")),
),
Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromUnknown(config))),
Layer.provideMerge(NodeServices.layer),
Layer.provideMerge(Interaction.layerNonInteractive()),
);
};
describe("PrismaEnvironment", { tags: ["unit", "provider:prisma", "local"] }, () => {
it.effect("resolves stored credentials and API base URL from config", () =>
Effect.gen(function* () {
const env = yield* PrismaEnvironment;
expect(env.type).toBe("serviceToken");
expect(env.source).toEqual({ type: "stored" });
expect(Redacted.value(env.serviceToken)).toBe("test-token");
expect(env.baseUrl).toBe("https://control-plane.prisma.test");
}).pipe(
Effect.provide(
testLayer(
{ PRISMA_API_URL: "https://control-plane.prisma.test" },
{ storedToken: "test-token" },
),
),
),
);
it.effect("prefers PRISMA_API_URL over PRISMA_MANAGEMENT_API_URL", () =>
Effect.gen(function* () {
const env = yield* PrismaEnvironment;
expect(env.baseUrl).toBe("https://api-url.prisma.test");
}).pipe(
Effect.provide(
testLayer(
{
PRISMA_API_URL: "https://api-url.prisma.test",
PRISMA_MANAGEMENT_API_URL: "https://management-url.prisma.test",
},
{ storedToken: "test-token" },
),
),
),
);
it.effect("resolves stored profile credentials", () =>
Effect.gen(function* () {
const env = yield* PrismaEnvironment;
expect(env.type).toBe("serviceToken");
expect(env.source).toEqual({ type: "stored" });
expect(Redacted.value(env.serviceToken)).toBe("stored-token");
expect(env.baseUrl).toBe("https://api.prisma.io");
}).pipe(Effect.provide(testLayer({}, { storedToken: "stored-token" }))),
);
it.effect("allows HTTP only for loopback Management API URLs", () =>
Effect.gen(function* () {
const env = yield* PrismaEnvironment;
expect(env.baseUrl).toBe("http://127.0.0.1:8787");
}).pipe(
Effect.provide(
testLayer({ PRISMA_API_URL: "http://127.0.0.1:8787/" }, { storedToken: "test-token" }),
),
),
);
it.effect("rejects insecure remote Management API URLs", () =>
Effect.gen(function* () {
const exit = yield* PrismaEnvironment.pipe(
Effect.provide(
testLayer(
{ PRISMA_API_URL: "http://management.prisma.test" },
{ storedToken: "test-token" },
),
),
Effect.exit,
);
expect(exit._tag).toBe("Failure");
if (exit._tag === "Failure") {
expect(String(exit.cause)).toContain("must use HTTPS");
}
}),
);
it.effect("rejects Management API URLs with credentials or path state", () =>
Effect.gen(function* () {
const credentialExit = yield* PrismaEnvironment.pipe(
Effect.provide(
testLayer(
{ PRISMA_API_URL: "https://token@api.prisma.test" },
{ storedToken: "test-token" },
),
),
Effect.exit,
);
expect(credentialExit._tag).toBe("Failure");
if (credentialExit._tag === "Failure") {
expect(String(credentialExit.cause)).toContain("must not contain credentials");
}
const pathExit = yield* PrismaEnvironment.pipe(
Effect.provide(
testLayer(
{ PRISMA_API_URL: "https://api.prisma.test/proxy" },
{ storedToken: "test-token" },
),
),
Effect.exit,
);
expect(pathExit._tag).toBe("Failure");
if (pathExit._tag === "Failure") {
expect(String(pathExit.cause)).toContain("must be an origin");
}
}),
);
});