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

main
ts 237 lines 10.2 KB
Raw
1 import {
2 GovernanceRoleSafetyError,
3 OrganizationMemberRole,
4 governanceRoleTransition,
5 organizationRoleTransition,
6 sameOrganizationRole,
7 requireGovernanceBaseline,
8 validateGovernanceActor,
9 validateGovernanceScope,
10 validateOrganizationRole,
11 type GovernanceRoleBaseline,
12 type OrganizationRole,
13 } from "@alchemy.run/neon/OrganizationMemberRole";
14 import { providers } from "@alchemy.run/neon/Providers";
15 import { expect, test as unit } from "@alchemy.run/test";
16 import * as Test from "@alchemy.run/test/Alchemy";
17 import * as SDK from "@distilled.cloud/neon";
18 import { adopt } from "alchemy/AdoptPolicy";
19 import * as Effect from "effect/Effect";
20
21 const baseline: GovernanceRoleBaseline<OrganizationRole> = {
22 fqn: "MemberRole",
23 instanceId: "generation-one",
24 userId: "authorized-user",
25 originalRole: "member",
26 managedRole: "viewer",
27 };
28
29 const refused = <A, R>(effect: Effect.Effect<A, GovernanceRoleSafetyError, R>) =>
30 effect.pipe(
31 Effect.as(false),
32 Effect.catchTag("NeonGovernanceRoleSafetyError", () => Effect.succeed(true)),
33 );
34
35 unit.effect(
36 "organization role validation rejects missing explicit scope and unknown roles",
37 () =>
38 Effect.gen(function* () {
39 expect(yield* refused(validateGovernanceScope(undefined))).toBe(true);
40 expect(yield* refused(validateGovernanceScope({ orgId: "", memberId: "member" }))).toBe(true);
41 expect(yield* refused(validateGovernanceScope({ orgId: "org", memberId: " " }))).toBe(true);
42 for (const role of ["admin", "member", "editor", "viewer", "collaborator"] as const) {
43 yield* validateOrganizationRole(role);
44 }
45 // @ts-expect-error Runtime validation protects JavaScript callers and persisted state.
46 expect(yield* refused(validateOrganizationRole("owner"))).toBe(true);
47 }),
48 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
49 );
50
51 unit.effect(
52 "organization baseline is mandatory and bound to the resource generation",
53 () =>
54 Effect.gen(function* () {
55 const owner = { fqn: baseline.fqn, instanceId: baseline.instanceId };
56 expect(yield* refused(requireGovernanceBaseline<OrganizationRole>(undefined, owner))).toBe(
57 true,
58 );
59 expect(yield* refused(requireGovernanceBaseline(baseline, { ...owner, fqn: "Other" }))).toBe(
60 true,
61 );
62 expect(
63 yield* refused(
64 requireGovernanceBaseline(baseline, { ...owner, instanceId: "replacement" }),
65 ),
66 ).toBe(true);
67 expect(yield* requireGovernanceBaseline(baseline, owner)).toEqual(baseline);
68 }),
69 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
70 );
71
72 unit.effect(
73 "organization role transitions preserve the original baseline and reject external edits",
74 () =>
75 Effect.gen(function* () {
76 expect(yield* governanceRoleTransition(baseline, "viewer", "editor")).toBe(true);
77 expect(yield* governanceRoleTransition(baseline, "viewer", "viewer")).toBe(false);
78 expect(yield* refused(governanceRoleTransition(baseline, "admin", "editor"))).toBe(true);
79 expect(yield* refused(governanceRoleTransition(baseline, "editor", "editor"))).toBe(true);
80 expect(baseline.originalRole).toBe("member");
81 }),
82 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
83 );
84
85 unit.effect(
86 "organization restoration is exact, idempotent and refuses out-of-band roles",
87 () =>
88 Effect.gen(function* () {
89 expect(yield* governanceRoleTransition(baseline, "viewer", "member", true)).toBe(true);
90 expect(yield* governanceRoleTransition(baseline, "member", "member", true)).toBe(false);
91 expect(yield* refused(governanceRoleTransition(baseline, "editor", "member", true))).toBe(
92 true,
93 );
94 }),
95 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
96 );
97
98 unit.effect(
99 "governance refuses changes to the current actor or an unknown identity",
100 () =>
101 Effect.gen(function* () {
102 expect(yield* refused(validateGovernanceActor("actor", "actor"))).toBe(true);
103 expect(yield* refused(validateGovernanceActor("", "actor"))).toBe(true);
104 expect(yield* refused(validateGovernanceActor("member", ""))).toBe(true);
105 yield* validateGovernanceActor("authorized-member", "administrator");
106 }),
107 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
108 );
109
110 unit.effect(
111 "organization roles accept Neon's legacy member/editor alias without changing permissions",
112 () =>
113 Effect.gen(function* () {
114 const legacy = { ...baseline, managedRole: "member" as const };
115 expect(sameOrganizationRole("member", "editor")).toBe(true);
116 expect(sameOrganizationRole("viewer", "editor")).toBe(false);
117 expect(yield* organizationRoleTransition(legacy, "editor", "member")).toBe(false);
118 expect(yield* organizationRoleTransition(legacy, "editor", "viewer")).toBe(true);
119 expect(yield* organizationRoleTransition(baseline, "editor", "member", true)).toBe(false);
120 expect(yield* refused(organizationRoleTransition(legacy, "admin", "editor"))).toBe(true);
121 expect(legacy.originalRole).toBe("member");
122 }),
123 { tags: ["unit", "provider:neon", "provider:neon:organizationmemberrole", "local"] },
124 );
125
126 const { test } = Test.make({ providers: providers() });
127
128 const context = {
129 id: "MemberRole",
130 fqn: baseline.fqn,
131 instanceId: baseline.instanceId,
132 oldBindings: [],
133 newBindings: [],
134 bindings: [],
135 session: { note: () => Effect.void },
136 };
137
138 const noCloudCredentials = Effect.die("Safety-only governance tests must not issue Neon requests");
139
140 test.provider(
141 "organization role identity changes are refused by diff before cloud I/O",
142 () =>
143 Effect.gen(function* () {
144 const provider = yield* OrganizationMemberRole.Provider;
145 const olds = { orgId: "org-original", memberId: "member-original", role: "viewer" as const };
146 const owned = { ...olds, baseline };
147 for (const output of [undefined, owned]) {
148 for (const news of [
149 { ...olds, orgId: "org-other" },
150 { ...olds, memberId: "member-other" },
151 ]) {
152 expect(yield* refused(provider.diff!({ ...context, olds, news, output }))).toBe(true);
153 }
154 expect(
155 yield* provider.diff!({ ...context, olds, news: { ...olds, role: "editor" }, output }),
156 ).toBeUndefined();
157 }
158 }).pipe(Effect.provideService(SDK.Credentials, noCloudCredentials)),
159 { tags: ["provider:neon", "provider:neon:organizationmemberrole", "live"], timeout: 120_000 },
160 );
161
162 test.provider(
163 "organization read reconcile and delete reject missing baselines before cloud I/O",
164 () =>
165 Effect.gen(function* () {
166 const provider = yield* OrganizationMemberRole.Provider;
167 const news = { orgId: "org-original", memberId: "member-original", role: "viewer" as const };
168 for (const olds of [undefined, news]) {
169 expect(
170 yield* refused(provider.reconcile({ ...context, news, olds, output: undefined })),
171 ).toBe(true);
172 }
173 const output = { ...news, baseline };
174 yield* Effect.sync(() => Reflect.deleteProperty(output, "baseline"));
175 expect(yield* refused(provider.read!({ ...context, olds: news, output }))).toBe(true);
176 expect(yield* refused(provider.reconcile({ ...context, news, olds: news, output }))).toBe(
177 true,
178 );
179 expect(yield* refused(provider.delete({ ...context, olds: news, output }))).toBe(true);
180 }).pipe(Effect.provideService(SDK.Credentials, noCloudCredentials)),
181 { tags: ["provider:neon", "provider:neon:organizationmemberrole", "live"], timeout: 120_000 },
182 );
183
184 const orgId = process.env.NEON_GOVERNANCE_TEST_ORG_ID;
185 const memberId = process.env.NEON_GOVERNANCE_TEST_MEMBER_ID;
186 // Opt in separately because an organization role affects access beyond test-owned projects.
187 const authorized = process.env.NEON_GOVERNANCE_TEST_ALLOW_ORG_ROLE_CHANGE === "1";
188
189 test.provider.skipIf(!orgId || !memberId || !authorized)(
190 "live organization role requires adoption and restores the authorized non-admin member exactly",
191 (stack) =>
192 Effect.gen(function* () {
193 yield* stack.destroy();
194 if (!orgId || !memberId || !authorized)
195 return yield* new GovernanceRoleSafetyError({
196 message: "Explicit governance fixture authorization is required",
197 });
198 const request = { org_id: orgId, member_id: memberId };
199 const original = yield* SDK.getOrganizationMember(request);
200 const actor = yield* SDK.getCurrentUserInfo({});
201 if (original.role === "admin" || !original.joined_at)
202 return yield* new GovernanceRoleSafetyError({
203 message: "Governance test fixture must be an active, non-admin member",
204 });
205 yield* validateGovernanceActor(original.user_id, actor.id);
206 const first: OrganizationRole = original.role === "viewer" ? "editor" : "viewer";
207 const second: OrganizationRole = first === "viewer" ? "editor" : "viewer";
208 const application = (role: OrganizationRole, takeOwnership: boolean) =>
209 Effect.gen(function* () {
210 const access = yield* OrganizationMemberRole("AuthorizedMemberRole", {
211 orgId,
212 memberId,
213 role,
214 }).pipe(adopt(takeOwnership));
215 return { access };
216 });
217 expect(
218 yield* stack.deploy(application(first, false)).pipe(
219 Effect.as(false),
220 Effect.catchTag("OwnedBySomeoneElse", () => Effect.succeed(true)),
221 ),
222 ).toBe(true);
223 const initial = yield* stack.deploy(application(first, true));
224 expect(initial.access.baseline.originalRole).toBe(original.role);
225 expect((yield* SDK.getOrganizationMember(request)).role).toBe(first);
226 const updated = yield* stack.deploy(application(second, false));
227 expect(updated.access.baseline.originalRole).toBe(original.role);
228 expect((yield* SDK.getOrganizationMember(request)).role).toBe(second);
229 yield* stack.destroy();
230 const restored = yield* SDK.getOrganizationMember(request);
231 expect(sameOrganizationRole(restored.role, original.role)).toBe(true);
232 expect(restored.id).toBe(original.id);
233 expect(restored.user_id).toBe(original.user_id);
234 yield* stack.destroy();
235 }),
236 { tags: ["provider:neon", "provider:neon:organizationmemberrole", "live"], timeout: 120_000 },
237 );