alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/Railway/Usage.ts

@@ -420,7 +420,7 @@ const setLimit = (input: {
   softLimitDollars: number;
   hardLimitDollars?: number | null;
 }) =>
-  railway.usageLimitSet({
+  railway.setUsageLimit({
     input: {
       customerId: input.customerId,
       softLimitDollars: input.softLimitDollars,
@@ -558,7 +558,7 @@ export const UsageLimitProvider = () =>
       const workspaceId = output.workspaceId;
       if (customerId.length === 0) return;
       yield* railway
-        .usageLimitRemove({ input: { customerId } })
+        .removeUsageLimit({ input: { customerId } })
         .pipe(
           Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void),
         );

package/src/Railway/Variable.ts

@@ -403,7 +403,7 @@ const upsertVariable = (input: {
   value: string;
   serviceId?: string;
 }) =>
-  railway.variableUpsert({
+  railway.upsertVariable({
     input: {
       projectId: input.projectId,
       environmentId: input.environmentId,
@@ -635,7 +635,7 @@ export const VariableProvider = () =>
         return;
       }
       yield* railway
-        .variableDelete({
+        .deleteVariable({
           input: {
             projectId: output.projectId,
             environmentId: output.environmentId,

package/src/Railway/Volume.ts

@@ -597,7 +597,7 @@ const waitUntilGone = (input: {
 };
 
 const stampName = (volumeId: string, name: string) =>
-  railway.volumeUpdate({
+  railway.updateVolume({
     volumeId,
     input: { name },
   });
@@ -762,7 +762,7 @@ export const VolumeProvider = () =>
 
           if (current === undefined) {
             const created = yield* railway
-              .volumeCreate({
+              .createVolume({
                 input: {
                   projectId,
                   environmentId,
@@ -830,7 +830,7 @@ export const VolumeProvider = () =>
             desiredServiceId !== undefined &&
             desiredServiceId !== observedServiceId;
           if (mountChanged || serviceChanged) {
-            yield* railway.volumeInstanceUpdate({
+            yield* railway.updateVolumeInstance({
               volumeId: current.volumeId,
               environmentId,
               input: {
@@ -860,7 +860,7 @@ export const VolumeProvider = () =>
       const volumeId = output.volumeId;
       if (volumeId.length === 0) return;
       yield* railway
-        .volumeDelete({ volumeId })
+        .deleteVolume({ volumeId })
         .pipe(
           Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void),
         );

package/src/Railway/VolumeBackup.ts

@@ -1,6 +1,6 @@
 import type {
   EnvironmentResponseVolumeInstancesEdgesItemNode,
-  VolumeInstanceBackupListResultItem,
+  ListVolumeInstanceBackupResultItem,
   VolumeInstanceBackupScheduleKind,
   VolumeInstanceResponse,
   VolumeState,
@@ -289,7 +289,7 @@ class VolumeBackupPending extends Data.TaggedError(
   state: string;
 }> {}
 
-type CloudBackup = VolumeInstanceBackupListResultItem;
+type CloudBackup = ListVolumeInstanceBackupResultItem;
 type CloudInstance =
   | EnvironmentResponseVolumeInstancesEdgesItemNode
   | VolumeInstanceResponse;
@@ -366,15 +366,15 @@ const resolveName = (id: string, existing?: string) =>
 
 const listBackups = (volumeInstanceId: string) =>
   railway
-    .volumeInstanceBackupList({ volumeInstanceId })
+    .listVolumeInstanceBackup({ volumeInstanceId })
     .pipe(
       Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
-        Effect.succeed([] as VolumeInstanceBackupListResultItem[]),
+        Effect.succeed([] as ListVolumeInstanceBackupResultItem[]),
       ),
     );
 
 const listSchedules = (volumeInstanceId: string) =>
-  railway.volumeInstanceBackupScheduleList({ volumeInstanceId }).pipe(
+  railway.listVolumeInstanceBackupSchedule({ volumeInstanceId }).pipe(
     Effect.map((items) => uniqueKinds(items.map((item) => item.kind))),
     Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
       Effect.succeed([] as VolumeBackupScheduleKind[]),
@@ -625,7 +625,7 @@ export const restoreVolumeBackup = Effect.fn(function* (input: {
   volumeInstanceId: string;
   volumeInstanceBackupId: string;
 }) {
-  const result = yield* railway.volumeInstanceBackupRestore({
+  const result = yield* railway.restoreVolumeInstanceBackup({
     volumeInstanceBackupId: input.volumeInstanceBackupId,
     volumeInstanceId: input.volumeInstanceId,
   });
@@ -646,7 +646,7 @@ export const restoreVolumePITR = Effect.fn(function* (input: {
   newServiceName?: string;
   sourceRepoPath?: string;
 }) {
-  const result = yield* railway.volumeInstancePITRRestore({
+  const result = yield* railway.restoreVolumeInstancePITR({
     volumeInstanceId: input.volumeInstanceId,
     targetTimestamp: input.targetTimestamp,
     ...(input.newServiceName !== undefined
@@ -839,7 +839,7 @@ export const VolumeBackupProvider = () =>
           });
         }
         const previousIds = new Set(existing.map((backup) => backup.id));
-        const created = yield* railway.volumeInstanceBackupCreate({
+        const created = yield* railway.createVolumeInstanceBackup({
           volumeInstanceId,
           name,
         });
@@ -865,7 +865,7 @@ export const VolumeBackupProvider = () =>
       }
 
       if (props.lock === true && current.expiresAt != null) {
-        yield* railway.volumeInstanceBackupLock({
+        yield* railway.lockVolumeInstanceBackup({
           volumeInstanceBackupId: current.id,
           volumeInstanceId,
         });
@@ -881,7 +881,7 @@ export const VolumeBackupProvider = () =>
       if (props.schedules !== undefined) {
         const desired = uniqueKinds(props.schedules);
         if (kindsKey(desired) !== kindsKey(schedules)) {
-          yield* railway.volumeInstanceBackupScheduleUpdate({
+          yield* railway.updateVolumeInstanceBackupSchedule({
             volumeInstanceId,
             kinds: desired,
           });
@@ -908,7 +908,7 @@ export const VolumeBackupProvider = () =>
         return;
       }
       const deleted = yield* railway
-        .volumeInstanceBackupDelete({
+        .deleteVolumeInstanceBackup({
           volumeInstanceBackupId,
           volumeInstanceId,
         })

package/src/Railway/local-context.ts

@@ -0,0 +1,333 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import {
+  hashDockerBuildInputs,
+  selectDockerBuildContext,
+} from "../Docker/BuildHash.ts";
+import { initialCwd } from "../Util/Node.ts";
+import { sha256Object } from "../Util/sha256.ts";
+import { tarGzipDirectory } from "../Util/tarGzip.ts";
+
+const DEFAULT_DOCKERFILE = "Dockerfile";
+const RAILWAY_BUILD_PLATFORM = "linux/amd64";
+const MAX_CONTEXT_BYTES = 32 * 1024 * 1024;
+const MAX_CONTEXT_ENTRIES = 10_000;
+const TAR_BLOCK_BYTES = 512;
+
+export interface RailwayLocalContextSource {
+  readonly context: string;
+  readonly dockerfilePath?: string;
+}
+
+export class ServiceImageOrMainRequired extends Data.TaggedError(
+  "Railway.ServiceImageOrMainRequired",
+)<{ message: string }> {}
+
+export class ServiceSourceInvalid extends Data.TaggedError(
+  "Railway.ServiceSourceInvalid",
+)<{ message: string }> {}
+
+export class ServiceDockerfilePathInvalid extends Data.TaggedError(
+  "Railway.ServiceDockerfilePathInvalid",
+)<{ dockerfilePath: string; message: string }> {}
+
+export class ServiceContextPathInvalid extends Data.TaggedError(
+  "Railway.ServiceContextPathInvalid",
+)<{ path: string; expected: "directory" | "file" }> {
+  override get message() {
+    return `Railway.Service expected ${this.path} to be an existing ${this.expected}`;
+  }
+}
+
+export class ServiceDockerfileOutsideContext extends Data.TaggedError(
+  "Railway.ServiceDockerfileOutsideContext",
+)<{ context: string; dockerfile: string }> {}
+
+export class ServiceContextSymlinkUnsupported extends Data.TaggedError(
+  "Railway.ServiceContextSymlinkUnsupported",
+)<{ path: string }> {}
+
+export class ServiceContextPathUnsupported extends Data.TaggedError(
+  "Railway.ServiceContextPathUnsupported",
+)<{ path: string }> {}
+
+export class ServiceContextTooLarge extends Data.TaggedError(
+  "Railway.ServiceContextTooLarge",
+)<{ limit: number; size: number }> {}
+
+export type RailwayServiceSource =
+  | { readonly mode: "main"; readonly main: string }
+  | {
+      readonly mode: "context";
+      readonly context: string;
+      readonly dockerfilePath: string | undefined;
+    }
+  | { readonly mode: "image"; readonly image: string }
+  | { readonly mode: "repo"; readonly repo: string };
+
+const nonEmpty = (value: string | undefined): value is string =>
+  value !== undefined && value.length > 0;
+
+export const resolveRailwayServiceSource = Effect.fn(function* (props: {
+  readonly main?: string;
+  readonly context?: string;
+  readonly image?: string;
+  readonly repo?: string;
+  readonly dockerfilePath?: string;
+}) {
+  const main = nonEmpty(props.main) ? props.main : undefined;
+  const context = nonEmpty(props.context) ? props.context : undefined;
+  const image = nonEmpty(props.image) ? props.image : undefined;
+  const repo = nonEmpty(props.repo) ? props.repo : undefined;
+  const modes = [
+    main === undefined ? undefined : "main",
+    context === undefined ? undefined : "context",
+    repo === undefined ? undefined : "repo",
+    main === undefined && image !== undefined ? "image" : undefined,
+  ].filter((mode): mode is RailwayServiceSource["mode"] => mode !== undefined);
+
+  if (modes.length === 0) {
+    return yield* new ServiceImageOrMainRequired({
+      message:
+        "Railway.Service requires `image`, `main`, `context`, or `repo`.",
+    });
+  }
+  if (modes.length !== 1) {
+    return yield* new ServiceSourceInvalid({
+      message:
+        "Railway.Service requires exactly one source: `main`, `context`, `image`, or `repo` (`image` may configure the base image for `main`).",
+    });
+  }
+  switch (modes[0]) {
+    case "main":
+      return { mode: "main", main: main! } as const;
+    case "context":
+      return {
+        mode: "context",
+        context: context!,
+        dockerfilePath: props.dockerfilePath,
+      } as const;
+    case "image":
+      return { mode: "image", image: image! } as const;
+    case "repo":
+      return { mode: "repo", repo: repo! } as const;
+    default:
+      return yield* new ServiceSourceInvalid({
+        message: "Railway.Service source could not be resolved",
+      });
+  }
+});
+
+const resolveBuild = Effect.fn(function* (source: RailwayLocalContextSource) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const context = path.resolve(initialCwd, source.context);
+  const dockerfilePath = source.dockerfilePath ?? DEFAULT_DOCKERFILE;
+  if (dockerfilePath.length === 0 || path.isAbsolute(dockerfilePath)) {
+    return yield* new ServiceDockerfilePathInvalid({
+      dockerfilePath,
+      message:
+        "Railway.Service `dockerfilePath` must be a non-empty path relative to `context`",
+    });
+  }
+  if (!(yield* fs.exists(context))) {
+    return yield* new ServiceContextPathInvalid({
+      path: context,
+      expected: "directory",
+    });
+  }
+  if (Result.isSuccess(yield* Effect.result(fs.readLink(context)))) {
+    return yield* new ServiceContextSymlinkUnsupported({ path: context });
+  }
+  const contextInfo = yield* fs.stat(context);
+  if (contextInfo.type !== "Directory") {
+    return yield* new ServiceContextPathInvalid({
+      path: context,
+      expected: "directory",
+    });
+  }
+  const dockerfile = path.resolve(context, dockerfilePath);
+  if (!(yield* fs.exists(dockerfile))) {
+    return yield* new ServiceContextPathInvalid({
+      path: dockerfile,
+      expected: "file",
+    });
+  }
+  const selected = yield* selectDockerBuildContext({ context, dockerfile });
+  if (selected.dockerfilePath === undefined) {
+    return yield* new ServiceDockerfileOutsideContext({
+      context,
+      dockerfile,
+    });
+  }
+  const parts = selected.dockerfilePath.split("/");
+  let current = context;
+  for (const part of parts) {
+    current = path.join(current, part);
+    if (Result.isSuccess(yield* Effect.result(fs.readLink(current)))) {
+      return yield* new ServiceContextSymlinkUnsupported({ path: current });
+    }
+  }
+  const dockerfileInfo = yield* fs.stat(dockerfile);
+  if (dockerfileInfo.type !== "File") {
+    return yield* new ServiceContextPathInvalid({
+      path: dockerfile,
+      expected: "file",
+    });
+  }
+  return {
+    build: {
+      context,
+      dockerfile,
+      platform: RAILWAY_BUILD_PLATFORM,
+    },
+    selected,
+  };
+});
+
+const paddedTarBytes = (size: number) =>
+  Math.ceil(size / TAR_BLOCK_BYTES) * TAR_BLOCK_BYTES;
+
+const fitsUstarPath = (relativePath: string) => {
+  if (relativePath.length <= 100) return true;
+  for (let index = relativePath.length - 101; index >= 1; index--) {
+    if (relativePath[index] !== "/") continue;
+    const nameLength = relativePath.length - index - 1;
+    if (index <= 155 && nameLength > 0 && nameLength <= 100) return true;
+  }
+  return false;
+};
+
+const tarEntryBytes = (
+  relativePath: string,
+  type: "Directory" | "File",
+  size: number,
+) => {
+  const tarPath = type === "Directory" ? `${relativePath}/` : relativePath;
+  const longNameBytes = fitsUstarPath(tarPath)
+    ? 0
+    : TAR_BLOCK_BYTES + paddedTarBytes(tarPath.length + 1);
+  return (
+    longNameBytes +
+    TAR_BLOCK_BYTES +
+    (type === "File" ? paddedTarBytes(size) : 0)
+  );
+};
+
+const checkContextLimit = (size: number, entries: number) =>
+  size > MAX_CONTEXT_BYTES || entries > MAX_CONTEXT_ENTRIES
+    ? Effect.fail(
+        new ServiceContextTooLarge({
+          limit: MAX_CONTEXT_BYTES,
+          size,
+        }),
+      )
+    : Effect.void;
+
+const selectedEntries = Effect.fn(function* (selected: {
+  context: string;
+  includes: (relativePath: string) => boolean;
+}) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const entries: Array<{
+    entry: string;
+    sourcePath: string;
+    type: "Directory" | "File";
+    mode: number;
+  }> = [];
+  let size = 2 * TAR_BLOCK_BYTES;
+  let entryCount = 0;
+  for (const entry of (yield* fs.readDirectory(selected.context, {
+    recursive: true,
+  })).sort()) {
+    const relative = entry.replaceAll("\\", "/");
+    if (!selected.includes(relative)) continue;
+    const sourcePath = path.join(selected.context, entry);
+    if (/[^\x20-\x7e]/.test(relative)) {
+      return yield* new ServiceContextPathUnsupported({ path: sourcePath });
+    }
+    if (Result.isSuccess(yield* Effect.result(fs.readLink(sourcePath)))) {
+      return yield* new ServiceContextSymlinkUnsupported({ path: sourcePath });
+    }
+    const info = yield* fs.stat(sourcePath);
+    if (info.type !== "Directory" && info.type !== "File") continue;
+    entryCount += 1;
+    size += tarEntryBytes(relative, info.type, Number(info.size));
+    yield* checkContextLimit(size, entryCount);
+    entries.push({
+      entry,
+      sourcePath,
+      type: info.type,
+      mode: info.mode & 0o7777,
+    });
+  }
+  return entries;
+});
+
+const codeHash = Effect.fn(function* (input: {
+  context: string;
+  dockerfilePath: string;
+}) {
+  const contextHash = yield* hashDockerBuildInputs(
+    {
+      context: input.context,
+      dockerfile: input.dockerfilePath,
+      platform: RAILWAY_BUILD_PLATFORM,
+    },
+    "effective",
+  );
+  return (yield* sha256Object({
+    contextHash,
+    dockerfilePath: input.dockerfilePath,
+  })).slice(0, 16);
+});
+
+export const hashRailwayLocalContext = Effect.fn(function* (
+  source: RailwayLocalContextSource,
+) {
+  const { build, selected } = yield* resolveBuild(source);
+  yield* selectedEntries(selected);
+  return yield* codeHash({
+    context: build.context,
+    dockerfilePath: selected.dockerfilePath!,
+  });
+});
+
+export const prepareRailwayLocalContext = Effect.fn(function* (
+  source: RailwayLocalContextSource,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const { selected } = yield* resolveBuild(source);
+  const snapshot = yield* fs.makeTempDirectoryScoped({
+    prefix: "alchemy-railway-context-",
+  });
+  const entries = yield* selectedEntries(selected);
+  let copiedSize = 2 * TAR_BLOCK_BYTES;
+  let copiedEntries = 0;
+  for (const entry of entries) {
+    const destination = path.join(snapshot, entry.entry);
+    copiedEntries += 1;
+    if (entry.type === "Directory") {
+      copiedSize += tarEntryBytes(entry.entry, entry.type, 0);
+      yield* checkContextLimit(copiedSize, copiedEntries);
+      yield* fs.makeDirectory(destination, { recursive: true });
+      yield* fs.chmod(destination, entry.mode);
+    } else {
+      yield* fs.makeDirectory(path.dirname(destination), { recursive: true });
+      const contents = yield* fs.readFile(entry.sourcePath);
+      copiedSize += tarEntryBytes(entry.entry, entry.type, contents.byteLength);
+      yield* checkContextLimit(copiedSize, copiedEntries);
+      yield* fs.writeFile(destination, contents);
+      yield* fs.chmod(destination, entry.mode);
+    }
+  }
+  const dockerfilePath = selected.dockerfilePath!;
+  const hash = yield* codeHash({ context: snapshot, dockerfilePath });
+  const tarball = yield* tarGzipDirectory(snapshot, { preserveMode: true });
+  return { codeHash: hash, dockerfilePath, tarball };
+});