The best way to control Claude Code, Codex and more from any computer or phone
| 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 | ); |