@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 146 lines 4.91 KB
Raw
1 import { RailwayAuth } from "@alchemy.run/railway/AuthProvider";
2 import { fromAuthProvider } from "@alchemy.run/railway/Credentials";
3 import { resolveWorkspace } from "@alchemy.run/railway/Environment";
4 import { createProject, type Project } from "@alchemy.run/railway/Project";
5 import { Environment } from "@alchemy.run/railway/ProjectEnvironment";
6 /**
7 * One Railway project for the live test process. Not a stack resource —
8 * tests pass it as `project:` so `stack.destroy()` cannot delete it.
9 *
10 * Named so `matchesAlchemyPhysicalName` still lists it (service `list()`
11 * walks owned projects) and `pnpm nuke` can reclaim it.
12 */
13 import { Query } from "@distilled.cloud/core/query";
14 import { GraphQLLive, Railway } from "@distilled.cloud/railway";
15 import * as Effect from "effect/Effect";
16 import * as Layer from "effect/Layer";
17 import * as Stream from "effect/Stream";
18 import { SUITE_PROJECT_NAME } from "./suiteProjectName.ts";
19
20 export { SUITE_PROJECT_NAME } from "./suiteProjectName.ts";
21
22 const toProject = (
23 project: {
24 id: string;
25 name?: string | null;
26 workspaceId?: string | null;
27 workspace?: { id: string } | null;
28 primaryEnvironmentId?: string | null;
29 baseEnvironmentId?: string | null;
30 baseEnvironment?: { id: string } | null;
31 deletedAt?: string | null;
32 },
33 workspaceId: string,
34 ): Project["Attributes"] => ({
35 projectId: project.id,
36 name: project.name || SUITE_PROJECT_NAME,
37 workspaceId: project.workspaceId ?? project.workspace?.id ?? workspaceId,
38 environmentId:
39 project.primaryEnvironmentId ?? project.baseEnvironmentId ?? project.baseEnvironment?.id ?? "",
40 url: `https://railway.com/project/${project.id}`,
41 });
42
43 const workspaceProjects = (workspaceId: string) =>
44 Query.items(
45 Railway.projects({ workspaceId, first: 50, includeDeleted: false }).pipe(
46 Query.map((project) => ({
47 id: project.id,
48 name: project.name,
49 workspaceId: project.workspaceId,
50 primaryEnvironmentId: project.primaryEnvironmentId,
51 baseEnvironmentId: project.baseEnvironmentId,
52 deletedAt: project.deletedAt,
53 })),
54 ),
55 );
56
57 const readProject = Query.fn((id: string) => {
58 const project = Railway.project({ id });
59 return {
60 id: project.id,
61 name: project.name,
62 workspaceId: project.workspaceId,
63 primaryEnvironmentId: project.primaryEnvironmentId,
64 baseEnvironmentId: project.baseEnvironmentId,
65 };
66 });
67
68 const projectEnvironments = (projectId: string) =>
69 Query.items(
70 Railway.environments({ projectId, first: 5 }).pipe(
71 Query.map((env) => ({ id: env.id, deletedAt: env.deletedAt })),
72 ),
73 );
74
75 const findByName = (workspaceId: string) =>
76 workspaceProjects(workspaceId).pipe(
77 Stream.filter((project) => project.deletedAt == null && project.name === SUITE_PROJECT_NAME),
78 Stream.take(1),
79 Stream.runHead,
80 Effect.map((option) => (option._tag === "Some" ? option.value : undefined)),
81 );
82
83 const acquire = Effect.gen(function* () {
84 const workspace = yield* resolveWorkspace();
85 const existing = yield* findByName(workspace.id);
86 const resolve = (project: Parameters<typeof toProject>[0]) =>
87 Effect.gen(function* () {
88 let attrs = toProject(project, workspace.id);
89 if (attrs.environmentId.length === 0) {
90 const fresh = yield* readProject(attrs.projectId);
91 attrs = toProject(fresh, workspace.id);
92 }
93 if (attrs.environmentId.length > 0) {
94 return attrs;
95 }
96 const env = yield* projectEnvironments(attrs.projectId).pipe(
97 Stream.filter((item) => item.deletedAt == null),
98 Stream.take(1),
99 Stream.runHead,
100 );
101 return env._tag === "Some" ? { ...attrs, environmentId: env.value.id } : attrs;
102 });
103
104 if (existing !== undefined) {
105 return yield* resolve(existing);
106 }
107
108 return yield* createProject({
109 name: SUITE_PROJECT_NAME,
110 workspaceId: workspace.id,
111 description: "alchemy railway live-test suite (shared)",
112 }).pipe(
113 Effect.flatMap((project) => resolve(project)),
114 Effect.catch((error) =>
115 findByName(workspace.id).pipe(
116 Effect.flatMap((found) => (found !== undefined ? resolve(found) : Effect.fail(error))),
117 ),
118 ),
119 );
120 }).pipe(
121 Effect.provide(Layer.mergeAll(GraphQLLive, fromAuthProvider().pipe(Layer.provide(RailwayAuth)))),
122 );
123
124 /**
125 * Process-cached create-or-get. Yield it inside a test or pass the
126 * Effect as `project:` (resource-valued props accept Effects).
127 */
128 export const suiteProject = Effect.runSync(
129 Effect.cached(
130 acquire.pipe(
131 Effect.map((attrs) => attrs as unknown as Project),
132 Effect.orDie,
133 ),
134 ),
135 );
136
137 /**
138 * Empty extra environment on {@link suiteProject}. Yield inside
139 * `stack.deploy` so destroy deletes the partition. Does not fork
140 * production (`sourceEnvironmentId` omitted).
141 */
142 export const suitePartition = Effect.gen(function* () {
143 const project = yield* suiteProject;
144 const environment = yield* Environment("Partition", { project });
145 return { project, environment };
146 });