@crewhaus/cloud-adapter-railway 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/cloud-adapter-railway",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "One-click deploy adapter for Railway — generates a railway.json + Dockerfile and wraps the Railway GraphQL API for daemon target shapes (Section 44)",
   "main": "src/index.ts",
@@ -12,14 +12,14 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/docker-images": "0.1.1",
-    "@crewhaus/errors": "0.1.1"
+    "@crewhaus/docker-images": "0.1.3",
+    "@crewhaus/errors": "0.1.3"
   },
   "license": "Apache-2.0",
   "author": {
     "name": "Max Meier",
-    "email": "max@studiomax.io",
-    "url": "https://studiomax.io"
+    "email": "max@crewhaus.ai",
+    "url": "https://crewhaus.ai"
   },
   "repository": {
     "type": "git",
@@ -31,12 +31,7 @@
     "url": "https://github.com/crewhaus/factory/issues"
   },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE",
-    "NOTICE"
-  ]
+  "files": ["src", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -71,6 +71,31 @@ describe("railwayConfigFor", () => {
   test("rejects unknown shapes", () => {
     expect(() => railwayConfigFor({ target: "mystery" as never })).toThrow(RailwayAdapterError);
   });
+
+  test("honors healthcheck overrides on web shapes", () => {
+    const parsed = JSON.parse(
+      railwayConfigFor({
+        target: "voice",
+        healthcheckPath: "/ready",
+        healthcheckTimeoutSec: 42,
+      }),
+    );
+    expect(parsed.deploy.healthcheckPath).toBe("/ready");
+    expect(parsed.deploy.healthcheckTimeout).toBe(42);
+  });
+
+  test("worker shape still carries restart defaults", () => {
+    const parsed = JSON.parse(railwayConfigFor({ target: "batch" }));
+    expect(parsed.deploy.restartPolicyType).toBe("ON_FAILURE");
+    expect(parsed.deploy.restartPolicyMaxRetries).toBe(10);
+    expect(parsed.build.dockerfilePath).toBe("Dockerfile.railway");
+  });
+
+  test("emits a stable schema url and trailing newline", () => {
+    const json = railwayConfigFor({ target: "channel" });
+    expect(json.endsWith("\n")).toBe(true);
+    expect(JSON.parse(json).$schema).toBe("https://railway.app/railway.schema.json");
+  });
 });
 
 describe("railwayDockerfileFor", () => {
@@ -90,6 +115,28 @@ describe("railwayDockerfileFor", () => {
       RailwayAdapterError,
     );
   });
+
+  test("rejects unknown shapes", () => {
+    expect(() => railwayDockerfileFor({ target: "mystery" as never, baseImage: "x" })).toThrow(
+      RailwayAdapterError,
+    );
+  });
+
+  test("pins PORT and a trailing newline for every shape", () => {
+    const df = railwayDockerfileFor({ target: "batch", baseImage: "crewhaus/batch:0.1.0" });
+    expect(df).toContain("ENV PORT=8080");
+    expect(df.endsWith("\n")).toBe(true);
+    expect(df).toContain("# Railway-tuned wrapper around crewhaus/batch:0.1.0");
+  });
+});
+
+describe("RailwayAdapterError", () => {
+  test("carries the config error code", () => {
+    const err = new RailwayAdapterError("boom");
+    expect(err.name).toBe("RailwayAdapterError");
+    expect(err.code).toBe("config");
+    expect(err).toBeInstanceOf(Error);
+  });
 });
 
 describe("scrubApiToken", () => {
@@ -206,4 +253,192 @@ describe("deployToRailway", () => {
     expect(caught).toBeInstanceOf(RailwayAdapterError);
     expect(called).toBe(false);
   });
+
+  test("wraps and scrubs network/transport failures", async () => {
+    const fetchImpl = (async () => {
+      throw new Error("connect ECONNREFUSED via proxy auth rw_leakingtoken_full");
+    }) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_leakingtoken_full",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("Railway GraphQL request failed");
+    expect(caught?.message).toContain("ECONNREFUSED");
+    expect(caught?.message).not.toContain("rw_leakingtoken_full");
+    expect(caught?.message).toContain("[REDACTED:RAILWAY_API_TOKEN]");
+    expect((caught as RailwayAdapterError).cause).toBeInstanceOf(Error);
+  });
+
+  test("stringifies non-Error transport rejections", async () => {
+    const fetchImpl = (async () => {
+      throw "boom-string-reject";
+    }) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_testtoken_abc",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("boom-string-reject");
+  });
+
+  test("rejects and scrubs a non-JSON 200 body", async () => {
+    const fetchImpl = (async () =>
+      new Response("<html>gateway error rw_leakingtoken_full</html>", {
+        status: 200,
+      })) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_leakingtoken_full",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("non-JSON body");
+    expect(caught?.message).not.toContain("rw_leakingtoken_full");
+    expect(caught?.message).toContain("[REDACTED:RAILWAY_API_TOKEN]");
+  });
+
+  test("rejects and scrubs when serviceCreate.id is missing", async () => {
+    const fetchImpl = (async () =>
+      new Response(
+        JSON.stringify({
+          data: { serviceCreate: { name: "my-bot" } },
+          meta: "trace rw_leakingtoken_full",
+        }),
+        { status: 200 },
+      )) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_leakingtoken_full",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("missing serviceCreate.id");
+    expect(caught?.message).not.toContain("rw_leakingtoken_full");
+    expect(caught?.message).toContain("[REDACTED:RAILWAY_API_TOKEN]");
+  });
+
+  test("surfaces HTTP status errors with status line", async () => {
+    const fetchImpl = (async () =>
+      new Response("internal error", {
+        status: 500,
+        statusText: "Internal Server Error",
+      })) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_testtoken_abc",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("500");
+    expect(caught?.message).toContain("Internal Server Error");
+  });
+
+  test("falls back to the requested service name when the API omits it", async () => {
+    const fetchImpl = (async () =>
+      new Response(JSON.stringify({ data: { serviceCreate: { id: "svc-xyz" } } }), {
+        status: 200,
+      })) as unknown as typeof fetch;
+    const record = await deployToRailway({
+      projectId: "p-789",
+      serviceName: "named-bot",
+      apiToken: "rw_testtoken_abc",
+      fetchImpl,
+    });
+    expect(record.serviceId).toBe("svc-xyz");
+    expect(record.serviceName).toBe("named-bot");
+    expect(record.projectId).toBe("p-789");
+  });
+
+  test("reads RAILWAY_API_TOKEN from the environment when apiToken is omitted", async () => {
+    process.env[API_TOKEN_ENV] = "rw_env_token_value";
+    let observedAuth: string | undefined;
+    const fetchImpl = (async (_url: string | URL, init?: RequestInit) => {
+      const headers = new Headers(init?.headers);
+      observedAuth = headers.get("Authorization") ?? undefined;
+      return new Response(
+        JSON.stringify({ data: { serviceCreate: { id: "svc-env", name: "n" } } }),
+        {
+          status: 200,
+        },
+      );
+    }) as unknown as typeof fetch;
+    const record = await deployToRailway({
+      projectId: "p",
+      serviceName: "my-bot",
+      fetchImpl,
+    });
+    expect(record.serviceId).toBe("svc-env");
+    expect(observedAuth).toBe("Bearer rw_env_token_value");
+  });
+
+  test("honors an explicit apiBaseUrl override", async () => {
+    let observedUrl: string | undefined;
+    const fetchImpl = (async (url: string | URL) => {
+      observedUrl = String(url);
+      return new Response(JSON.stringify({ data: { serviceCreate: { id: "svc-1", name: "n" } } }), {
+        status: 200,
+      });
+    }) as unknown as typeof fetch;
+    await deployToRailway({
+      projectId: "p",
+      serviceName: "my-bot",
+      apiToken: "rw_testtoken_abc",
+      apiBaseUrl: "https://example.test/graphql",
+      fetchImpl,
+    });
+    expect(observedUrl).toBe("https://example.test/graphql");
+  });
+
+  test("surfaces a generic message when a GraphQL error lacks a message field", async () => {
+    const fetchImpl = (async () =>
+      new Response(JSON.stringify({ errors: [{}] }), {
+        status: 200,
+      })) as unknown as typeof fetch;
+    let caught: Error | undefined;
+    try {
+      await deployToRailway({
+        projectId: "p",
+        serviceName: "my-bot",
+        apiToken: "rw_testtoken_abc",
+        fetchImpl,
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).toBeInstanceOf(RailwayAdapterError);
+    expect(caught?.message).toContain("(no message)");
+  });
 });