@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 145 lines 5.09 KB
Raw
1 import * as Railway from "@alchemy.run/railway";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import { Query } from "@distilled.cloud/core/query";
5 import { Railway as RailwaySdk } from "@distilled.cloud/railway";
6 import * as Effect from "effect/Effect";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Schedule from "effect/Schedule";
9 import { suitePartition } from "./suiteProject.ts";
10
11 const { test } = Test.make({ providers: Railway.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 const asVariableMap = (value: unknown): Record<string, string> => {
16 if (value === null || typeof value !== "object" || Array.isArray(value)) {
17 return {};
18 }
19 const out: Record<string, string> = {};
20 for (const [key, item] of Object.entries(value)) {
21 if (typeof item === "string") {
22 out[key] = item;
23 }
24 }
25 return out;
26 };
27
28 const queryVariables = Query.fn((projectId: string, environmentId: string, serviceId?: string) =>
29 RailwaySdk.variables({
30 projectId,
31 environmentId,
32 ...(serviceId !== undefined ? { serviceId } : {}),
33 unrendered: true,
34 }),
35 );
36
37 const readVariables = (projectId: string, environmentId: string, serviceId?: string) =>
38 queryVariables(projectId, environmentId, serviceId).pipe(
39 Effect.map(asVariableMap),
40 Effect.catchTag("RailwayNotFound", () => Effect.succeed({} as Record<string, string>)),
41 );
42
43 const waitUntilVariableGone = (
44 projectId: string,
45 environmentId: string,
46 name: string,
47 serviceId?: string,
48 ) =>
49 readVariables(projectId, environmentId, serviceId).pipe(
50 Effect.map((vars) => (Object.hasOwn(vars, name) ? ("found" as const) : ("gone" as const))),
51 Effect.repeat({
52 schedule: Schedule.spaced("1 second"),
53 until: (status) => status === "gone",
54 times: 10,
55 }),
56 );
57
58 const isPostgresUri = (value: string | undefined) =>
59 value !== undefined && (value.startsWith("postgres://") || value.startsWith("postgresql://"));
60
61 test.provider(
62 "upserting DATABASE_URL: Railway.ref(Db, DATABASE_URL) stores the template, not a resolved URI",
63 (stack) =>
64 Effect.gen(function* () {
65 expect(Railway.ref({ LogicalId: "Db" }, "DATABASE_URL")).toEqual("${{Db.DATABASE_URL}}");
66 expect(Railway.ref("shared", "SENTRY_DSN")).toEqual("${{shared.SENTRY_DSN}}");
67
68 yield* stack.destroy();
69
70 const created = yield* stack.deploy(
71 Effect.gen(function* () {
72 const { project, environment } = yield* suitePartition;
73 const db = yield* Railway.Postgres("Db", { project, environment, public: false });
74 const template = Railway.ref(db, "DATABASE_URL");
75 const databaseUrl = yield* Railway.Variable("DatabaseUrl", {
76 project,
77 environment,
78 name: "DATABASE_URL",
79 value: template,
80 });
81 const sentry = yield* Railway.Variable("SentryDsn", {
82 project,
83 environment,
84 name: "SENTRY_DSN",
85 value: "https://example.ingest.sentry.io/1",
86 });
87 const sentryRef = yield* Railway.Variable("SentryDsnRef", {
88 project,
89 environment,
90 service: db,
91 name: "SENTRY_DSN",
92 value: Railway.ref("shared", "SENTRY_DSN"),
93 });
94 return { project, environment, db, databaseUrl, sentry, sentryRef, template };
95 }),
96 );
97
98 expect(created.template).toEqual("${{Db.DATABASE_URL}}");
99 expect(isPostgresUri(created.template)).toBe(false);
100
101 expect(created.databaseUrl.name).toEqual("DATABASE_URL");
102 expect(created.databaseUrl.serviceId).toBeUndefined();
103 expect(Object.hasOwn(created.databaseUrl, "value")).toBe(false);
104
105 const shared = yield* readVariables(
106 created.databaseUrl.projectId,
107 created.databaseUrl.environmentId,
108 );
109 expect(shared.DATABASE_URL).toEqual(created.template);
110 expect(shared.DATABASE_URL).toEqual("${{Db.DATABASE_URL}}");
111 expect(shared.DATABASE_URL).not.toEqual(created.db.connectionUri);
112 expect(isPostgresUri(shared.DATABASE_URL)).toBe(false);
113 expect(shared.SENTRY_DSN).toEqual("https://example.ingest.sentry.io/1");
114
115 const onDb = yield* readVariables(
116 created.db.projectId,
117 created.db.environmentId,
118 created.db.serviceId,
119 );
120 expect(onDb.SENTRY_DSN).toEqual(Railway.ref("shared", "SENTRY_DSN"));
121 expect(onDb.SENTRY_DSN).toEqual("${{shared.SENTRY_DSN}}");
122 expect(onDb.DATABASE_URL).not.toEqual(created.template);
123 expect((onDb.DATABASE_URL ?? "").includes("${{")).toBe(true);
124
125 yield* stack.destroy();
126
127 const variableGone = yield* waitUntilVariableGone(
128 created.databaseUrl.projectId,
129 created.databaseUrl.environmentId,
130 created.databaseUrl.name,
131 );
132 expect(variableGone).toEqual("gone");
133 }).pipe(logLevel),
134 {
135 tags: [
136 "provider:railway",
137 "provider:railway:postgres",
138 "provider:railway:project",
139 "provider:railway:projectenvironment",
140 "provider:railway:variable",
141 "live",
142 ],
143 timeout: 120_000,
144 },
145 );