alchemy 2.0.0-beta.74 → 2.0.0-beta.76

package/src/Railway/ProjectEnvironment.ts

@@ -0,0 +1,374 @@
+import type {
+  EnvironmentCreateResponse,
+  EnvironmentRenameResponse,
+  EnvironmentResponse,
+  EnvironmentsResponseEdgesItemNode,
+} from "@distilled.cloud/railway";
+import * as railway from "@distilled.cloud/railway";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+import { Unowned } from "../AdoptPolicy.ts";
+import { isResolved } from "../Diff.ts";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import {
+  createRailwayEnvironmentName,
+  matchesAlchemyPhysicalName,
+  sanitizeRailwayEnvironmentName,
+} from "./Metadata.ts";
+import { ownedProjects, type Project } from "./Project.ts";
+import type { Providers } from "./Providers.ts";
+import { waitOutCreateRateLimit } from "./transient.ts";
+
+/**
+ * A resource-valued prop: the resource itself, or an Effect that produces
+ * it (so `yield* Project(...)` and `Project(...)` both type-check).
+ */
+type Ref<T> = T | Effect.Effect<T, never, Providers>;
+
+export interface EnvironmentProps {
+  /**
+   * Parent Railway Project. Accepts a `Railway.Project` resource or an
+   * Effect that produces one. Changing it replaces the Environment.
+   */
+  project: Ref<Project>;
+  /**
+   * Environment name. Unique per project. If omitted, a unique name is
+   * generated from the stack, stage and logical ID. Changing it updates
+   * the environment in place via `environmentRename`.
+   */
+  name?: string;
+  /**
+   * Fork this environment from an existing one (`sourceEnvironmentId`).
+   * Create-only; ignored on update. Pass the project's `environmentId` to
+   * copy production's services, volumes, and variables.
+   */
+  sourceEnvironmentId?: string;
+}
+
+export type Environment = Resource<
+  "Railway.Environment",
+  EnvironmentProps,
+  {
+    /** Railway environment id. */
+    environmentId: string;
+    /** Physical environment name (unique per project). */
+    name: string;
+    /** Parent Railway project id. */
+    projectId: string;
+    /** Whether this is an ephemeral (PR) environment. */
+    isEphemeral: boolean;
+    /** Dashboard URL for this environment. */
+    url: string;
+  },
+  never,
+  Providers
+>;
+
+const EnvironmentResource = Resource<Environment>("Railway.Environment");
+
+const resolveEnvironmentProps = (
+  props: EnvironmentProps | Effect.Effect<EnvironmentProps, never, Providers>,
+): Effect.Effect<EnvironmentProps, never, Providers> =>
+  Effect.gen(function* () {
+    const resolved = Effect.isEffect(props) ? yield* props : props;
+    if (globalThis.__ALCHEMY_RUNTIME__) return resolved;
+    const project = Effect.isEffect(resolved.project)
+      ? yield* resolved.project as Effect.Effect<Project, never, Providers>
+      : resolved.project;
+    return { ...resolved, project };
+  });
+
+/**
+ * A Railway.Environment is an extra deploy environment under a Project
+ * (staging, preview, …). The production environment is created with the
+ * Project — do not recreate it as an Environment resource.
+ *
+ * @see https://docs.railway.com/guides/environments
+ *
+ * ### Create an extra environment
+ * Alchemy generates a unique name unless you pass one. Production is
+ * already on the Project as `environmentId`.
+ *
+ * **Example:** Staging next to production
+ * ```typescript
+ * const site = yield* Railway.Project("Site");
+ * const staging = yield* Railway.Environment("Staging", {
+ *   project: site,
+ * });
+ * ```
+ *
+ * :::note
+ * Prefer omitting `name` in tests and CI so names stay unique and
+ * reclaimable.
+ * :::
+ *
+ * ### A stable name
+ * Pass `name` when you need a stable environment name (`staging`).
+ * Changing it later updates the environment in place.
+ *
+ * **Example:** Explicit name
+ * ```typescript
+ * const staging = yield* Railway.Environment("Staging", {
+ *   project: site,
+ *   name: "staging",
+ * });
+ * ```
+ *
+ * ### Fork from production
+ * `sourceEnvironmentId` copies services, volumes, configuration, and
+ * variables from another environment. Create-only.
+ *
+ * **Example:** Fork production
+ * ```typescript
+ * const staging = yield* Railway.Environment("Staging", {
+ *   project: site,
+ *   sourceEnvironmentId: site.environmentId,
+ * });
+ * ```
+ *
+ * ### Module-scope declarations
+ * Declare the Project once. Pass it into every child. Resource-valued
+ * props accept the resource or an Effect producing it.
+ *
+ * **Example:** Module-scope Environment
+ * ```typescript
+ * // src/project.ts
+ * import * as Railway from "alchemy/Railway";
+ *
+ * export const Site = Railway.Project("Site");
+ * export const Staging = Railway.Environment("Staging", {
+ *   project: Site,
+ * });
+ * ```
+ *
+ * @resource
+ */
+export const Environment: typeof EnvironmentResource = Object.assign(
+  (
+    id: string,
+    props: EnvironmentProps | Effect.Effect<EnvironmentProps, never, Providers>,
+  ) => EnvironmentResource(id, resolveEnvironmentProps(props)),
+  EnvironmentResource,
+);
+
+export class EnvironmentNotCreated extends Data.TaggedError(
+  "Railway.EnvironmentNotCreated",
+)<{
+  name: string;
+  projectId: string;
+}> {}
+
+export class EnvironmentProjectRequired extends Data.TaggedError(
+  "Railway.EnvironmentProjectRequired",
+)<{
+  message: string;
+}> {}
+
+type CloudEnvironment =
+  | EnvironmentResponse
+  | EnvironmentCreateResponse
+  | EnvironmentRenameResponse
+  | EnvironmentsResponseEdgesItemNode;
+
+const toAttrs = (
+  env: CloudEnvironment,
+  fallback?: { name?: string; projectId?: string },
+): Environment["Attributes"] => {
+  const name = env.name || fallback?.name || "";
+  const projectId = env.projectId || fallback?.projectId || "";
+  return {
+    environmentId: env.id,
+    name,
+    projectId,
+    isEphemeral: env.isEphemeral,
+    url: `https://railway.com/project/${projectId}?environmentId=${env.id}`,
+  };
+};
+
+const resolveName = (id: string, name: string | undefined, existing?: string) =>
+  Effect.gen(function* () {
+    if (name !== undefined) return sanitizeRailwayEnvironmentName(name);
+    if (existing !== undefined) return existing;
+    return yield* createRailwayEnvironmentName(id);
+  });
+
+const isGone = (env: CloudEnvironment | undefined) =>
+  env === undefined || env.deletedAt != null;
+
+const projectIdOf = (value: unknown): string | undefined => {
+  if (value === null || typeof value !== "object") return undefined;
+  const rec = value as { projectId?: unknown };
+  return typeof rec.projectId === "string" && rec.projectId.length > 0
+    ? rec.projectId
+    : undefined;
+};
+
+const getById = (environmentId: string, projectId?: string) =>
+  railway
+    .environment({
+      id: environmentId,
+      ...(projectId !== undefined ? { projectId } : {}),
+    })
+    .pipe(
+      Effect.map((env) => (isGone(env) ? undefined : env)),
+      Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
+        Effect.succeed(undefined),
+      ),
+    );
+
+const findByName = (projectId: string, name: string) =>
+  railway.environments.items({ projectId, first: 50 }).pipe(
+    Stream.filter((env) => !isGone(env) && env.name === name),
+    Stream.take(1),
+    Stream.runHead,
+    Effect.map((option) => (option._tag === "Some" ? option.value : undefined)),
+    Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
+      Effect.succeed(undefined),
+    ),
+  );
+
+const listProjectEnvironments = (projectId: string) =>
+  railway.environments.items({ projectId, first: 50 }).pipe(
+    Stream.runCollect,
+    Effect.map((envs) => Array.from(envs)),
+    Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
+      Effect.succeed([] as EnvironmentsResponseEdgesItemNode[]),
+    ),
+  );
+
+export const EnvironmentProvider = () =>
+  Provider.succeed(Environment, {
+    stables: ["environmentId", "projectId"],
+    nuke: { dependsOn: ["Railway.Project"] },
+
+    diff: Effect.fn(function* ({ news, output }) {
+      if (news === undefined || !isResolved(news)) return undefined;
+      if (output === undefined) return undefined;
+      const nextProjectId = projectIdOf(news.project);
+      if (nextProjectId !== undefined && nextProjectId !== output.projectId) {
+        return { action: "replace" as const };
+      }
+      return undefined;
+    }),
+
+    read: Effect.fn(function* ({ id, olds, output }) {
+      const name = yield* resolveName(id, olds?.name, output?.name);
+      const projectId =
+        output?.projectId ??
+        (olds !== undefined ? projectIdOf(olds.project) : undefined);
+      const found =
+        (output?.environmentId !== undefined
+          ? yield* getById(output.environmentId, output.projectId)
+          : undefined) ??
+        (projectId !== undefined
+          ? yield* findByName(projectId, name)
+          : undefined);
+      if (found === undefined) return undefined;
+      const attrs = toAttrs(found, { name, projectId });
+      if (output !== undefined) return attrs;
+      return matchesAlchemyPhysicalName(found.name) ? attrs : Unowned(attrs);
+    }),
+
+    list: Effect.fn(function* () {
+      const projects = yield* ownedProjects();
+      const rows = yield* Effect.forEach(projects, (project) =>
+        railway.environments
+          .items({ projectId: project.projectId, first: 50 })
+          .pipe(
+            Stream.filter(
+              (env) =>
+                env.deletedAt == null && matchesAlchemyPhysicalName(env.name),
+            ),
+            Stream.runCollect,
+            Effect.map((chunk) =>
+              Array.from(chunk).map((env) => {
+                const projectId = env.projectId || project.projectId;
+                return {
+                  environmentId: env.id,
+                  name: env.name,
+                  projectId,
+                  isEphemeral: env.isEphemeral,
+                  url: `https://railway.com/project/${projectId}?environmentId=${env.id}`,
+                };
+              }),
+            ),
+            Effect.catchTag(["RailwayNotFound", "NotFound"], () =>
+              Effect.succeed([] as Environment["Attributes"][]),
+            ),
+          ),
+      );
+      return rows.flat();
+    }),
+
+    reconcile: Effect.fn(function* ({ id, news, output }) {
+      const props = news ?? ({} as EnvironmentProps);
+      const projectId = projectIdOf(props.project) ?? output?.projectId;
+      if (projectId === undefined) {
+        return yield* new EnvironmentProjectRequired({
+          message: "Environment requires a resolved Railway.Project",
+        });
+      }
+      const name = yield* resolveName(id, props.name, output?.name);
+
+      let current: CloudEnvironment | undefined =
+        output?.environmentId !== undefined
+          ? yield* getById(output.environmentId, output.projectId)
+          : undefined;
+      if (current === undefined) {
+        current = yield* findByName(projectId, name);
+      }
+
+      if (current === undefined) {
+        const created = yield* waitOutCreateRateLimit(
+          railway.environmentCreate({
+            input: {
+              name,
+              projectId,
+              ...(props.sourceEnvironmentId !== undefined
+                ? { sourceEnvironmentId: props.sourceEnvironmentId }
+                : {}),
+            },
+          }),
+        ).pipe(
+          Effect.catchTag("RailwayValidationError", () =>
+            Effect.succeed(undefined),
+          ),
+        );
+        current = created ?? (yield* findByName(projectId, name));
+      }
+
+      if (current === undefined || isGone(current)) {
+        return yield* new EnvironmentNotCreated({ name, projectId });
+      }
+
+      if (current.name !== name) {
+        current = yield* railway.environmentRename({
+          id: current.id,
+          input: { name },
+        });
+      }
+
+      return toAttrs(current, { name, projectId });
+    }),
+
+    delete: Effect.fn(function* ({ output }) {
+      const environmentId = output.environmentId;
+      if (environmentId.length === 0) return;
+      yield* railway
+        .environmentDelete({ id: environmentId })
+        .pipe(
+          Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void),
+        );
+      yield* getById(environmentId, output.projectId).pipe(
+        Effect.map((env) => env === undefined),
+        Effect.repeat({
+          schedule: Schedule.spaced("1 second"),
+          until: (gone) => gone,
+          times: 8,
+        }),
+      );
+    }),
+  });

package/src/Railway/Providers.ts

@@ -0,0 +1,173 @@
+import * as Layer from "effect/Layer";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
+import { ProfileLive } from "../Auth/Profile.ts";
+import * as Command from "../Command/index.ts";
+import * as Provider from "../Provider.ts";
+import { Random, RandomProvider } from "../Random.ts";
+import { RailwayAuth } from "./AuthProvider.ts";
+import { Bucket, BucketProvider } from "./Bucket.ts";
+import { CloudAgent, CloudAgentProvider } from "./CloudAgent.ts";
+import * as Credentials from "./Credentials.ts";
+import { DeleteObjectHttp } from "./DeleteObjectHttp.ts";
+import { GetObjectHttp } from "./GetObjectHttp.ts";
+import { HeadObjectHttp } from "./HeadObjectHttp.ts";
+import { ListObjectsV2Http } from "./ListObjectsV2Http.ts";
+import { PutObjectHttp } from "./PutObjectHttp.ts";
+import { CustomDomain, CustomDomainProvider } from "./CustomDomain.ts";
+import { fromCredentials } from "./Environment.ts";
+import { Function, FunctionProvider } from "./Function.ts";
+import { Group, GroupProvider } from "./Group.ts";
+import { Project, ProjectProvider } from "./Project.ts";
+import { Environment, EnvironmentProvider } from "./ProjectEnvironment.ts";
+import { TcpProxy, TcpProxyProvider } from "./TcpProxy.ts";
+import { Template, TemplateProvider } from "./Template.ts";
+import { UsageLimit, UsageLimitProvider } from "./Usage.ts";
+import { Variable, VariableProvider } from "./Variable.ts";
+import { MountVolumeLive } from "./MountVolume.ts";
+import { ConnectMongoHttp } from "./ConnectMongoHttp.ts";
+import { ConnectMySQLHttp } from "./ConnectMySQLHttp.ts";
+import { ConnectPostgresHttp } from "./ConnectPostgresHttp.ts";
+import { Mongo, MongoProvider } from "./Mongo.ts";
+import { MySQL, MySQLProvider } from "./MySQL.ts";
+import { Postgres, PostgresProvider } from "./Postgres.ts";
+import {
+  PrivateNetwork,
+  PrivateNetworkEndpoint,
+  PrivateNetworkEndpointProvider,
+  PrivateNetworkProvider,
+} from "./PrivateNetwork.ts";
+import { ReadRedisHttp } from "./ReadRedisHttp.ts";
+import { ReadWriteRedisHttp } from "./ReadWriteRedisHttp.ts";
+import { RailwayRetryPolicy } from "./RetryPolicy.ts";
+import { Redis, RedisProvider } from "./Redis.ts";
+import { Service } from "./Service.ts";
+import { ServiceProvider } from "./ServiceProvider.ts";
+import { Cdn, CdnProvider } from "./Website/Cdn.ts";
+import {
+  Server as WebsiteServer,
+  ServerProvider as WebsiteServerProvider,
+} from "../Website/Server.ts";
+import { ExecHttp, Sandbox, SandboxProvider } from "./Sandbox.ts";
+import { Volume, VolumeProvider } from "./Volume.ts";
+import { VolumeBackup, VolumeBackupProvider } from "./VolumeBackup.ts";
+import { WriteRedisHttp } from "./WriteRedisHttp.ts";
+
+export class Providers extends Provider.ProviderCollection<Providers>()(
+  "Railway",
+) {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+/**
+ * Build a layer that registers Railway resource providers, the Railway
+ * `AuthProvider`, the resolved `Credentials`, and an `HttpClient`. Include
+ * this from your stack alongside other cloud `providers()` layers.
+ *
+ * Resource providers are inserted into {@link Provider.collection} as they
+ * land. The collection starts empty so Project / Service agents can make a
+ * single minimal insertion.
+ *
+ * @example
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as Railway from "alchemy/Railway";
+ * import * as Effect from "effect/Effect";
+ *
+ * export default Alchemy.Stack(
+ *   "MyStack",
+ *   {
+ *     providers: Railway.providers(),
+ *     state: Alchemy.localState(),
+ *   },
+ *   Effect.gen(function* () {
+ *     return {};
+ *   }),
+ * );
+ * ```
+ */
+export const providers = () =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      Project,
+      Postgres,
+      PrivateNetwork,
+      PrivateNetworkEndpoint,
+      MySQL,
+      Mongo,
+      Cdn,
+      CustomDomain,
+      Environment,
+      Function,
+      Group,
+      Service,
+      TcpProxy,
+      Template,
+      UsageLimit,
+      Variable,
+      Volume,
+      VolumeBackup,
+      Redis,
+      Bucket,
+      CloudAgent,
+      Sandbox,
+      Random,
+      WebsiteServer,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        ProjectProvider(),
+        PostgresProvider(),
+        PrivateNetworkProvider(),
+        PrivateNetworkEndpointProvider(),
+        MySQLProvider(),
+        MongoProvider(),
+        CdnProvider(),
+        CustomDomainProvider(),
+        EnvironmentProvider(),
+        FunctionProvider(),
+        GroupProvider(),
+        ServiceProvider(),
+        TcpProxyProvider(),
+        TemplateProvider(),
+        UsageLimitProvider(),
+        VariableProvider(),
+        VolumeProvider(),
+        VolumeBackupProvider(),
+        RedisProvider(),
+        BucketProvider(),
+        CloudAgentProvider(),
+        SandboxProvider(),
+        RandomProvider(),
+        WebsiteServerProvider(),
+      ),
+    ),
+    Layer.provideMerge(
+      Layer.mergeAll(
+        MountVolumeLive,
+        ConnectPostgresHttp,
+        ConnectMySQLHttp,
+        ConnectMongoHttp,
+        PutObjectHttp,
+        GetObjectHttp,
+        DeleteObjectHttp,
+        HeadObjectHttp,
+        ListObjectsV2Http,
+        ReadRedisHttp,
+        WriteRedisHttp,
+        ReadWriteRedisHttp,
+        ExecHttp,
+      ),
+    ),
+    Layer.provide(RailwayRetryPolicy),
+    Layer.provideMerge(fromCredentials()),
+    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(RailwayAuth),
+    Layer.provideMerge(ProfileLive),
+    Layer.provideMerge(CredentialsStoreLive),
+    Layer.provideMerge(FetchHttpClient.layer),
+    Layer.provideMerge(Command.providers()),
+    Layer.orDie,
+  );

package/src/Railway/PutObject.ts

@@ -0,0 +1,49 @@
+import type * as S3 from "@distilled.cloud/aws/s3";
+import type * as Config from "effect/Config";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../Binding.ts";
+import type { RuntimeContext } from "../RuntimeContext.ts";
+import type { Bucket } from "./Bucket.ts";
+import type { RailwayS3CredentialsMissing } from "./BucketBinding.ts";
+
+export interface PutObjectRequest extends Omit<S3.PutObjectRequest, "Bucket"> {}
+
+/**
+ * Runtime binding for Railway `PutObject` over the S3 API.
+ *
+ * Bind this operation to a {@link Bucket} in Service init. The bucket
+ * name, endpoint, and credentials are injected automatically. Provide
+ * {@link PutObjectHttp}.
+ *
+ *
+ * ### Writing Objects
+ * **Example:** Put an Object
+ * ```typescript
+ * const putObject = yield* Railway.PutObject(Data);
+ *
+ * yield* putObject({
+ *   Key: "hello.txt",
+ *   Body: "Hello, world!",
+ *   ContentType: "text/plain",
+ * });
+ * ```
+ *
+ * @binding
+ */
+export interface PutObject extends Binding.Service<
+  PutObject,
+  "Railway.PutObject",
+  (
+    bucket: Bucket,
+  ) => Effect.Effect<
+    (
+      request?: PutObjectRequest,
+    ) => Effect.Effect<
+      S3.PutObjectOutput,
+      S3.PutObjectError | Config.ConfigError | RailwayS3CredentialsMissing,
+      RuntimeContext
+    >
+  >
+> {}
+
+export const PutObject = Binding.Service<PutObject>("Railway.PutObject");

package/src/Railway/PutObjectHttp.ts

@@ -0,0 +1,19 @@
+import * as S3 from "@distilled.cloud/aws/s3";
+import * as Layer from "effect/Layer";
+import { makeRailwayS3Binding } from "./BucketBinding.ts";
+import { PutObject } from "./PutObject.ts";
+
+/**
+ * HTTP implementation of {@link PutObject}. Calls distilled S3
+ * `putObject` against the Railway endpoint with the bucket's credentials.
+ *
+ * @layer
+ * @provides Railway.PutObject
+ */
+export const PutObjectHttp = Layer.effect(
+  PutObject,
+  makeRailwayS3Binding({
+    tag: "Railway.PutObject",
+    operation: S3.putObject,
+  }),
+);

package/src/Railway/ReadRedis.ts

@@ -0,0 +1,30 @@
+import type * as Effect from "effect/Effect";
+import * as Binding from "../Binding.ts";
+import type { ReadClient } from "../Redis/index.ts";
+import type { Redis } from "./Redis.ts";
+
+/**
+ * Bind a {@link Redis} database with read access (`get`, `ping`).
+ *
+ * `ReadRedis` is the Context tag, the type, and the callable —
+ * `yield* Railway.ReadRedis(Cache)`. Provide {@link ReadRedisHttp}.
+ *
+ *
+ * ### Read
+ * **Example:** Get a key
+ * ```typescript
+ * const cache = yield* Railway.ReadRedis(Cache);
+ * const value = yield* cache.get("marker");
+ * ```
+ *
+ * @binding
+ */
+export interface ReadRedis extends Binding.Service<
+  ReadRedis,
+  "Railway.ReadRedis",
+  (redis: Redis) => Effect.Effect<ReadRedisClient>
+> {}
+
+export const ReadRedis = Binding.Service<ReadRedis>("Railway.ReadRedis");
+
+export type ReadRedisClient = ReadClient;

package/src/Railway/ReadRedisHttp.ts

@@ -0,0 +1,17 @@
+import * as Layer from "effect/Layer";
+import { ReadRedis } from "./ReadRedis.ts";
+import { makeRedisBinding } from "./RedisBinding.ts";
+import { makeReadRedisClient } from "./RedisHttp.ts";
+
+/**
+ * HTTP implementation of {@link ReadRedis}.
+ *
+ * @layer
+ * @provides Railway.ReadRedis
+ */
+export const ReadRedisHttp = Layer.effect(
+  ReadRedis,
+  makeRedisBinding({
+    makeClient: makeReadRedisClient,
+  }),
+);

package/src/Railway/ReadWriteRedis.ts

@@ -0,0 +1,35 @@
+import type * as Effect from "effect/Effect";
+import * as Binding from "../Binding.ts";
+import type { ReadRedisClient } from "./ReadRedis.ts";
+import type { Redis } from "./Redis.ts";
+import type { WriteRedisClient } from "./WriteRedis.ts";
+
+/**
+ * Bind a {@link Redis} database with read + write access.
+ *
+ * `ReadWriteRedis` is the Context tag, the type, and the callable —
+ * `yield* Railway.ReadWriteRedis(Cache)`. Provide {@link ReadWriteRedisHttp}.
+ *
+ *
+ * ### Read and write
+ * **Example:** Round-trip a key
+ * ```typescript
+ * const cache = yield* Railway.ReadWriteRedis(Cache);
+ * yield* cache.set("marker", "hello");
+ * const value = yield* cache.get("marker");
+ * ```
+ *
+ * @binding
+ */
+export interface ReadWriteRedis extends Binding.Service<
+  ReadWriteRedis,
+  "Railway.ReadWriteRedis",
+  (redis: Redis) => Effect.Effect<ReadWriteRedisClient>
+> {}
+
+export const ReadWriteRedis = Binding.Service<ReadWriteRedis>(
+  "Railway.ReadWriteRedis",
+);
+
+export interface ReadWriteRedisClient
+  extends ReadRedisClient, WriteRedisClient {}