@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 241 lines 9.04 KB
Raw
1 import * as Stripe from "@alchemy.run/stripe";
2 import { isMissingStripeResource } from "@alchemy.run/stripe/missing";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import { DeleteAccount, GetAccountPerson, CreateAccount } from "@distilled.cloud/stripe/stripe";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Result from "effect/Result";
10 import * as Schedule from "effect/Schedule";
11
12 const { test } = Test.make({ providers: Stripe.providers() });
13
14 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
15
16 const CONNECT_ENABLED = process.env.STRIPE_TEST_CONNECT === "1";
17
18 const isMissing = isMissingStripeResource;
19
20 const waitUntilGone = (account: string, person: string) =>
21 GetAccountPerson({ account, person }).pipe(
22 Effect.as("found" as const),
23 Effect.catchIf(isMissing, () => Effect.succeed("gone" as const)),
24 Effect.repeat({
25 schedule: Schedule.spaced("1 second"),
26 until: (status) => status === "gone",
27 times: 10,
28 }),
29 );
30
31 const probeConnectAccount = CreateAccount({
32 type: "custom",
33 country: "US",
34 email: "alchemy.account.person.probe@example.com",
35 business_type: "company",
36 company: { name: "Alchemy Account Person Probe" },
37 capabilities: {
38 card_payments: { requested: true },
39 transfers: { requested: true },
40 },
41 });
42
43 test.provider(
44 "connect accounts entitlement probe",
45 (stack) =>
46 Effect.gen(function* () {
47 yield* stack.destroy();
48
49 const probe = yield* probeConnectAccount.pipe(Effect.result);
50 if (Result.isFailure(probe)) {
51 expect(probe.failure._tag).not.toEqual("UnknownStripeError");
52 expect(probe.failure._tag).toEqual("InvalidRequestError");
53 if (probe.failure._tag === "InvalidRequestError") {
54 expect(probe.failure.message ?? "").toContain("signed up for Connect");
55 }
56 yield* stack.destroy();
57 return;
58 }
59
60 yield* DeleteAccount({ account: probe.success.id }).pipe(
61 Effect.catchIf(isMissing, () => Effect.void),
62 );
63 yield* stack.destroy();
64 }).pipe(logLevel),
65 {
66 tags: ["provider:stripe", "provider:stripe:account", "provider:stripe:accountperson", "live"],
67 timeout: 60_000,
68 },
69 );
70
71 test.provider.skipIf(!CONNECT_ENABLED)(
72 "create, update, and delete an account person",
73 (stack) =>
74 Effect.gen(function* () {
75 yield* stack.destroy();
76
77 const created = yield* stack.deploy(
78 Effect.gen(function* () {
79 const account = yield* Stripe.Account("PersonLifecycleAccount", {
80 type: "custom",
81 country: "US",
82 email: "alchemy.account.person.lifecycle@example.com",
83 businessType: "company",
84 company: { name: "Alchemy Account Person Co" },
85 capabilities: {
86 card_payments: { requested: true },
87 transfers: { requested: true },
88 },
89 });
90 const person = yield* Stripe.AccountPerson("CatalogPerson", {
91 account: account.id,
92 firstName: "Jane",
93 lastName: "Diaz",
94 email: "jane.diaz@example.com",
95 phone: "+15555550100",
96 relationship: { director: true, title: "CFO" },
97 metadata: { role: "finance" },
98 });
99 return { account, person };
100 }),
101 );
102
103 expect(created.person.id).toMatch(/^person_/);
104 expect(created.person.account).toEqual(created.account.id);
105 expect(created.person.firstName).toEqual("Jane");
106 expect(created.person.lastName).toEqual("Diaz");
107 expect(created.person.email).toEqual("jane.diaz@example.com");
108 expect(created.person.phone).toEqual("+15555550100");
109 expect(created.person.relationship?.director).toEqual(true);
110 expect(created.person.relationship?.title).toEqual("CFO");
111 expect(created.person.metadata).toMatchObject({ role: "finance" });
112 expect(created.person.created).toEqual(expect.any(Number));
113
114 const fetched = yield* GetAccountPerson({
115 account: created.account.id,
116 person: created.person.id,
117 });
118 expect(fetched.id).toEqual(created.person.id);
119 expect(fetched.first_name).toEqual("Jane");
120 expect(fetched.last_name).toEqual("Diaz");
121 expect(fetched.email).toEqual("jane.diaz@example.com");
122 expect(fetched.phone).toEqual("+15555550100");
123 expect(fetched.relationship?.director).toEqual(true);
124 expect(fetched.relationship?.title).toEqual("CFO");
125 expect(fetched.metadata?.role).toEqual("finance");
126 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.stack]).toBeDefined();
127 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.stage]).toBeDefined();
128 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.id]).toBeDefined();
129
130 const updated = yield* stack.deploy(
131 Effect.gen(function* () {
132 const account = yield* Stripe.Account("PersonLifecycleAccount", {
133 type: "custom",
134 country: "US",
135 email: "alchemy.account.person.lifecycle@example.com",
136 businessType: "company",
137 company: { name: "Alchemy Account Person Co" },
138 capabilities: {
139 card_payments: { requested: true },
140 transfers: { requested: true },
141 },
142 });
143 const person = yield* Stripe.AccountPerson("CatalogPerson", {
144 account: account.id,
145 firstName: "Janet",
146 lastName: "Diaz-Kim",
147 email: "janet.diaz@example.com",
148 phone: "+15555550199",
149 relationship: { director: true, title: "COO" },
150 metadata: { role: "ops", sku: "exec-1" },
151 });
152 return { account, person };
153 }),
154 );
155
156 expect(updated.person.id).toEqual(created.person.id);
157 expect(updated.person.account).toEqual(created.account.id);
158 expect(updated.person.firstName).toEqual("Janet");
159 expect(updated.person.lastName).toEqual("Diaz-Kim");
160 expect(updated.person.email).toEqual("janet.diaz@example.com");
161 expect(updated.person.phone).toEqual("+15555550199");
162 expect(updated.person.relationship?.title).toEqual("COO");
163 expect(updated.person.metadata).toEqual({ role: "ops", sku: "exec-1" });
164
165 const refetched = yield* GetAccountPerson({
166 account: updated.account.id,
167 person: updated.person.id,
168 });
169 expect(refetched.first_name).toEqual("Janet");
170 expect(refetched.last_name).toEqual("Diaz-Kim");
171 expect(refetched.email).toEqual("janet.diaz@example.com");
172 expect(refetched.phone).toEqual("+15555550199");
173 expect(refetched.relationship?.title).toEqual("COO");
174 expect(refetched.metadata?.role).toEqual("ops");
175 expect(refetched.metadata?.sku).toEqual("exec-1");
176 expect(refetched.metadata?.[Stripe.alchemyMetadataKeys.id]).toBeDefined();
177
178 yield* stack.destroy();
179
180 const gone = yield* waitUntilGone(created.account.id, created.person.id);
181 expect(gone).toEqual("gone");
182 }).pipe(logLevel),
183 {
184 tags: ["provider:stripe", "provider:stripe:account", "provider:stripe:accountperson", "live"],
185 timeout: 120_000,
186 },
187 );
188
189 test.provider.skipIf(!CONNECT_ENABLED)(
190 "list enumerates the deployed account person",
191 (stack) =>
192 Effect.gen(function* () {
193 yield* stack.destroy();
194
195 const deployed = yield* stack.deploy(
196 Effect.gen(function* () {
197 const account = yield* Stripe.Account("PersonListAccount", {
198 type: "custom",
199 country: "US",
200 email: "alchemy.account.person.list@example.com",
201 businessType: "company",
202 company: { name: "Alchemy Account Person List Co" },
203 capabilities: {
204 card_payments: { requested: true },
205 transfers: { requested: true },
206 },
207 });
208 const person = yield* Stripe.AccountPerson("ListPerson", {
209 account: account.id,
210 firstName: "Lee",
211 lastName: "Park",
212 email: "lee.park@example.com",
213 relationship: { director: true },
214 metadata: { kind: "list" },
215 });
216 return { account, person };
217 }),
218 );
219
220 const provider = yield* Provider.findProvider(Stripe.AccountPerson);
221 const all = yield* provider.list();
222 const found = all.find((person) => person.id === deployed.person.id);
223 expect(found).toBeDefined();
224 expect(found?.account).toEqual(deployed.account.id);
225 expect(found?.firstName).toEqual("Lee");
226 expect(found?.lastName).toEqual("Park");
227 expect(found?.metadata).toMatchObject({ kind: "list" });
228
229 yield* stack.destroy();
230
231 const gone = yield* waitUntilGone(deployed.account.id, deployed.person.id);
232 expect(gone).toEqual("gone");
233
234 const after = yield* provider.list();
235 expect(after.find((person) => person.id === deployed.person.id)).toBeUndefined();
236 }).pipe(logLevel),
237 {
238 tags: ["provider:stripe", "provider:stripe:account", "provider:stripe:accountperson", "live"],
239 timeout: 120_000,
240 },
241 );