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

package/lib/Railway/Mongo.js

@@ -0,0 +1,817 @@
+import { randomBytes } from "node:crypto";
+import * as railway from "@distilled.cloud/railway";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+import { Unowned } from "../AdoptPolicy.js";
+import { isResolved } from "../Diff.js";
+import * as Provider from "../Provider.js";
+import { Resource } from "../Resource.js";
+import { createRailwayName, matchesAlchemyPhysicalName } from "./Metadata.js";
+import { ownedProjects } from "./Project.js";
+export const DEFAULT_MONGO_IMAGE = "mongo:8";
+export const DEFAULT_MONGO_USER = "mongo";
+export const DEFAULT_MONGO_DATABASE = "railway";
+export const MONGO_PORT = 27017;
+export const MONGO_MOUNT_PATH = "/data/db";
+export const MONGO_URL_SECRET = "MONGO_URL";
+export const MONGO_PUBLIC_URL_SECRET = "MONGO_PUBLIC_URL";
+/**
+ * Official Mongo image must bind IPv6 so `{name}.railway.internal` works.
+ * `docker-entrypoint.sh` is required so `MONGO_INITDB_ROOT_*` still runs.
+ */
+export const MONGO_START_COMMAND = "docker-entrypoint.sh mongod --ipv6 --bind_ip ::,0.0.0.0 --setParameter diagnosticDataCollectionEnabled=false";
+const resolveMongoProps = (props) => 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
+        : resolved.project;
+    const environment = resolved.environment === undefined
+        ? undefined
+        : Effect.isEffect(resolved.environment)
+            ? yield* resolved.environment
+            : resolved.environment;
+    return { ...resolved, project, environment };
+});
+const MongoResource = Resource("Railway.Mongo");
+/**
+ * A Railway.Mongo is MongoDB-as-a-Service: the official `mongo` image, a
+ * Volume at `/data/db`, `MONGO_*` / `MONGO_URL` variables, IPv6 bind for
+ * the private network, and an optional TCP proxy for the public URL.
+ *
+ * Private hostname is `{name}.railway.internal`. From a
+ * {@link Service}, yield {@link ConnectMongo}. From a laptop, use
+ * `publicConnectionUri`. The IaC helper is {@link mongo}.
+ *
+ * @see https://docs.railway.com/databases/mongodb
+ *
+ * ### Create Mongo
+ * Pass a Project. Alchemy generates a unique name, password, volume,
+ * and a public TCP proxy.
+ *
+ * **Example:** Generated name
+ * ```typescript
+ * const site = yield* Railway.Project("Site");
+ * const db = yield* Railway.mongo("Db", { project: site });
+ * ```
+ *
+ * :::caution[Changing `project` replaces Mongo]
+ * A new service + volume are created in the new Project. The old
+ * service and volume are deleted. Data is not copied.
+ * :::
+ *
+ * ### Connect from a Service
+ * Yield `ConnectMongo` inside init. Provide
+ * {@link ConnectMongoHttp}. Pass `conn.connectionString` to the
+ * MongoDB driver (or {@link pingMongo}). The binding packs the private
+ * URI (`{name}.railway.internal`).
+ *
+ * **Example:** Bind and ping
+ * ```typescript
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ * import * as Redacted from "effect/Redacted";
+ *
+ * export default class Api extends Railway.Service<Api>()(
+ *   "Api",
+ *   { project: Site, main: import.meta.url, build: { install: ["mongodb"] } },
+ *   Effect.gen(function* () {
+ *     const conn = yield* Railway.ConnectMongo(Db);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const url = yield* conn.connectionString;
+ *         const ping = yield* Railway.pingMongo(Redacted.value(url));
+ *         return HttpServerResponse.json(ping);
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Railway.ConnectMongoHttp)),
+ * ) {}
+ * ```
+ *
+ * ### Public TCP
+ * `public` (default `true`) creates a TCP proxy on 27017.
+ * `publicConnectionUri` is `{domain}:{proxyPort}` for laptop access.
+ *
+ * **Example:** Private only
+ * ```typescript
+ * const db = yield* Railway.mongo("Db", {
+ *   project: site,
+ *   public: false,
+ * });
+ * ```
+ *
+ * ### Image
+ * Default is official Mongo 8. Pass `image` to pin another tag.
+ *
+ * **Example:** Mongo 7
+ * ```typescript
+ * const db = yield* Railway.mongo("Db", {
+ *   project: site,
+ *   image: "mongo:7",
+ * });
+ * ```
+ *
+ * ### Module-scope declarations
+ * Resource-valued props accept the resource or an Effect producing it.
+ *
+ * **Example:** Module-scope Mongo
+ * ```typescript
+ * // src/db.ts
+ * import * as Railway from "alchemy/Railway";
+ *
+ * export const Site = Railway.Project("Site");
+ * export const Db = Railway.mongo("Db", { project: Site });
+ * ```
+ *
+ * @resource
+ */
+export const Mongo = Object.assign((id, props) => MongoResource(id, resolveMongoProps(props)), MongoResource);
+/**
+ * IaC helper matching Railway's `mongo()`. Same resource as {@link Mongo}.
+ */
+export const mongo = Mongo;
+export class MongoNotCreated extends Data.TaggedError("Railway.MongoNotCreated") {
+}
+export class MongoProjectRequired extends Data.TaggedError("Railway.MongoProjectRequired") {
+}
+export class MongoDeployFailed extends Data.TaggedError("Railway.MongoDeployFailed") {
+}
+export class MongoVolumeNotCreated extends Data.TaggedError("Railway.MongoVolumeNotCreated") {
+}
+export class MongoCommandError extends Data.TaggedError("Railway.MongoCommandError") {
+    get message() {
+        return String(this.cause);
+    }
+}
+class MongoPending extends Data.TaggedError("Railway.MongoPending") {
+}
+class MongoDeployPending extends Data.TaggedError("Railway.MongoDeployPending") {
+}
+class VolumePending extends Data.TaggedError("Railway.MongoVolumePending") {
+}
+const projectIdOf = (value) => {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const rec = value;
+    return typeof rec.projectId === "string" && rec.projectId.length > 0
+        ? rec.projectId
+        : undefined;
+};
+const environmentIdOf = (value) => {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const rec = value;
+    return typeof rec.environmentId === "string" && rec.environmentId.length > 0
+        ? rec.environmentId
+        : undefined;
+};
+const unwrapSecret = (value) => Redacted.isRedacted(value) ? Redacted.value(value) : value;
+const generatePassword = Effect.sync(() => {
+    const bytes = randomBytes(24);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+});
+const isGoneService = (service) => service === undefined || service.deletedAt != null;
+const isGoneInstance = (instance) => instance === undefined || instance.deletedAt != null;
+const goneVolumeState = (state) => state === "DELETED" || state === "DELETING";
+const transientVolumeState = (state) => state === "UPDATING" ||
+    state === "MIGRATING" ||
+    state === "MIGRATION_PENDING" ||
+    state === "RESTORING";
+const isGoneVolume = (instance) => instance === undefined ||
+    instance.deletedAt != null ||
+    instance.isPendingDeletion ||
+    goneVolumeState(instance.state);
+const isGoneProxy = (proxy) => proxy === undefined ||
+    proxy.deletedAt != null ||
+    proxy.syncStatus === "DELETED";
+const normalizeDomain = (domain) => domain.replace(/\.+$/, "");
+const alreadyExists = (message) => /already exists|already in use|duplicate/i.test(message);
+const sameImage = (observed, desired) => {
+    if (observed == null || observed.length === 0)
+        return false;
+    if (observed === desired)
+        return true;
+    if (observed === `${desired}:latest` || desired === `${observed}:latest`) {
+        return true;
+    }
+    return (observed.endsWith(`/${desired}`) || observed.endsWith(`/${desired}:latest`));
+};
+const normalizeStart = (value) => (value ?? "").replace(/\s+/g, " ").trim();
+const isMongoImage = (image) => image != null && /(^|\/)mongo(:|$)/i.test(image);
+const deployReady = (status) => status === "SUCCESS";
+const deployFailed = (status) => status === "FAILED" || status === "CRASHED" || status === "REMOVED";
+const resolveName = (id, name, existing) => Effect.gen(function* () {
+    if (name !== undefined)
+        return name;
+    if (existing !== undefined)
+        return existing;
+    return yield* createRailwayName(id);
+});
+const encodePart = (value) => encodeURIComponent(value);
+const privateConnectionUri = (input) => `mongodb://${encodePart(input.user)}:${encodePart(input.password)}@${input.name}.railway.internal:${MONGO_PORT}/${encodePart(input.database)}?authSource=admin&directConnection=true`;
+const publicConnectionUri = (input) => `mongodb://${encodePart(input.user)}:${encodePart(input.password)}@${input.domain}:${input.port}/${encodePart(input.database)}?authSource=admin&directConnection=true`;
+const desiredVariables = (input) => ({
+    MONGO_INITDB_ROOT_USERNAME: input.user,
+    MONGO_INITDB_ROOT_PASSWORD: input.password,
+    MONGO_INITDB_DATABASE: input.database,
+    MONGOUSER: "${{MONGO_INITDB_ROOT_USERNAME}}",
+    MONGOPASSWORD: "${{MONGO_INITDB_ROOT_PASSWORD}}",
+    MONGOHOST: "${{RAILWAY_PRIVATE_DOMAIN}}",
+    MONGOPORT: String(MONGO_PORT),
+    [MONGO_URL_SECRET]: "mongodb://${{MONGO_INITDB_ROOT_USERNAME}}:${{MONGO_INITDB_ROOT_PASSWORD}}@${{RAILWAY_PRIVATE_DOMAIN}}:27017",
+    [MONGO_PUBLIC_URL_SECRET]: "mongodb://${{MONGO_INITDB_ROOT_USERNAME}}:${{MONGO_INITDB_ROOT_PASSWORD}}@${{RAILWAY_TCP_PROXY_DOMAIN}}:${{RAILWAY_TCP_PROXY_PORT}}",
+});
+const toAttrs = (input) => {
+    const name = input.service.name;
+    const domain = input.proxy !== undefined ? normalizeDomain(input.proxy.domain) : undefined;
+    const proxyPort = input.proxy?.proxyPort;
+    return {
+        serviceId: input.service.id,
+        name,
+        projectId: input.projectId,
+        environmentId: input.environmentId,
+        image: input.instance?.source?.image ?? undefined,
+        region: input.instance?.region ?? undefined,
+        volumeId: input.volume?.volumeId || input.volume?.volume.id || "",
+        volumeInstanceId: input.volume?.id ?? "",
+        tcpProxyId: input.proxy?.id,
+        tcpProxyDomain: domain,
+        tcpProxyPort: proxyPort,
+        user: input.user,
+        database: input.database,
+        connectionUri: input.password.length > 0
+            ? privateConnectionUri({
+                user: input.user,
+                password: input.password,
+                name,
+                database: input.database,
+            })
+            : "",
+        publicConnectionUri: input.password.length > 0 &&
+            domain !== undefined &&
+            domain.length > 0 &&
+            proxyPort !== undefined
+            ? publicConnectionUri({
+                user: input.user,
+                password: input.password,
+                domain,
+                port: proxyPort,
+                database: input.database,
+            })
+            : "",
+        deploymentId: input.instance?.latestDeployment?.id,
+        deploymentStatus: input.instance?.latestDeployment?.status,
+    };
+};
+const getById = (serviceId) => railway.service({ id: serviceId }).pipe(Effect.map((service) => (isGoneService(service) ? undefined : service)), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed(undefined)));
+const getInstance = (environmentId, serviceId) => railway.serviceInstance({ environmentId, serviceId }).pipe(Effect.map((instance) => (isGoneInstance(instance) ? undefined : instance)), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed(undefined)));
+const listProjectServices = (projectId) => railway.project({ id: projectId }).pipe(Effect.map((project) => project.services.edges
+    .map((edge) => edge.node)
+    .filter((node) => !isGoneService(node))), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed([])));
+const findByName = (projectId, name) => listProjectServices(projectId).pipe(Effect.map((services) => services.find((service) => service.name === name)));
+const getVolumeByInstanceId = (volumeInstanceId) => railway.volumeInstance({ id: volumeInstanceId }).pipe(Effect.map((instance) => (isGoneVolume(instance) ? undefined : instance)), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed(undefined)));
+const listVolumeInstances = (environmentId, projectId) => railway.environment({ id: environmentId, projectId }).pipe(Effect.map((env) => env.deletedAt != null
+    ? []
+    : env.volumeInstances.edges
+        .map((edge) => edge.node)
+        .filter((node) => !isGoneVolume(node))), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed([])));
+const findVolume = (environmentId, projectId, match) => listVolumeInstances(environmentId, projectId).pipe(Effect.map((instances) => instances.find(match)));
+const listProxies = (environmentId, serviceId) => railway.tcpProxies({ environmentId, serviceId }).pipe(Effect.map((items) => items.filter((proxy) => !isGoneProxy(proxy))), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed([])));
+const findProxy = (environmentId, serviceId, applicationPort) => listProxies(environmentId, serviceId).pipe(Effect.map((items) => items.find((proxy) => proxy.applicationPort === applicationPort)));
+/**
+ * Delete a TCP proxy, riding out Railway's per-environment mutation lock: a
+ * delete racing an in-flight deploy fails with "Cannot delete TCP proxy: an
+ * operation is already in progress". Already-gone proxies are a no-op.
+ */
+const deleteProxy = (id) => railway.tcpProxyDelete({ id }).pipe(Effect.retry({
+    while: (e) => e._tag === "RailwayInternalError" &&
+        e.message.includes("operation is already in progress"),
+    schedule: Schedule.spaced("3 seconds"),
+    times: 20,
+}), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void), Effect.asVoid);
+const asVariableMap = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === "string") {
+            out[key] = item;
+        }
+    }
+    return out;
+};
+const listVariableMap = (projectId, environmentId, serviceId) => railway
+    .variables({
+    projectId,
+    environmentId,
+    serviceId,
+    unrendered: true,
+})
+    .pipe(Effect.map(asVariableMap), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed({})));
+const upsertVariable = (input) => railway.variableUpsert({
+    input: {
+        projectId: input.projectId,
+        environmentId: input.environmentId,
+        serviceId: input.serviceId,
+        name: input.name,
+        value: input.value,
+        skipDeploys: true,
+    },
+});
+const syncEnv = Effect.fn(function* (input) {
+    const observed = yield* listVariableMap(input.projectId, input.environmentId, input.serviceId);
+    let changed = false;
+    for (const [name, value] of Object.entries(input.desired)) {
+        if (observed[name] !== value) {
+            yield* upsertVariable({
+                projectId: input.projectId,
+                environmentId: input.environmentId,
+                serviceId: input.serviceId,
+                name,
+                value,
+            });
+            changed = true;
+        }
+    }
+    return changed;
+});
+const waitForInstance = (environmentId, serviceId) => getInstance(environmentId, serviceId).pipe(Effect.flatMap((instance) => {
+    if (instance === undefined) {
+        return Effect.fail(new MongoPending({ serviceId, status: "creating" }));
+    }
+    return Effect.succeed(instance);
+}), Effect.retry({
+    while: (e) => e._tag === "Railway.MongoPending",
+    // serviceCreate fans the instance out to each environment
+    // asynchronously; under full-suite load the fan-out can take minutes.
+    times: 60,
+    schedule: Schedule.spaced("2 seconds"),
+}), Effect.catchTag("Railway.MongoPending", () => getInstance(environmentId, serviceId)));
+const waitForDeployment = (environmentId, serviceId) => getInstance(environmentId, serviceId).pipe(Effect.flatMap((instance) => {
+    const latest = instance?.latestDeployment;
+    const status = latest?.status;
+    if (instance !== undefined && deployReady(status)) {
+        return Effect.succeed(instance);
+    }
+    return Effect.fail(new MongoDeployPending({
+        serviceId,
+        status: status ?? "pending",
+    }));
+}), Effect.retry({
+    while: (e) => e._tag === "Railway.MongoDeployPending",
+    // Queued builds under full-suite load can exceed 3 minutes — allow ~8.
+    times: 96,
+    schedule: Schedule.spaced("5 seconds"),
+}), Effect.catchTag("Railway.MongoDeployPending", () => getInstance(environmentId, serviceId)));
+const waitForVolume = (environmentId, projectId, volumeId, volumeInstanceId) => {
+    const observe = volumeInstanceId !== undefined && volumeInstanceId.length > 0
+        ? getVolumeByInstanceId(volumeInstanceId)
+        : findVolume(environmentId, projectId, (instance) => instance.volumeId === volumeId);
+    return observe.pipe(Effect.flatMap((instance) => {
+        if (instance === undefined || transientVolumeState(instance.state)) {
+            return Effect.fail(new VolumePending({
+                volumeId,
+                state: instance?.state ?? "creating",
+            }));
+        }
+        return Effect.succeed(instance);
+    }), Effect.retry({
+        while: (e) => e._tag === "Railway.MongoVolumePending",
+        times: 10,
+        schedule: Schedule.spaced("3 seconds"),
+    }), Effect.catchTag("Railway.MongoVolumePending", () => observe));
+};
+const stampVolumeName = (volumeId, name) => railway.volumeUpdate({
+    volumeId,
+    input: { name },
+});
+/**
+ * Ping a MongoDB deployment. Used from tests over the public TCP proxy
+ * and from a {@link Service} with {@link ConnectMongo}.
+ */
+export const pingMongo = (url) => Effect.tryPromise({
+    try: async () => {
+        const { MongoClient } = await import("mongodb");
+        const client = new MongoClient(url, {
+            directConnection: true,
+            serverSelectionTimeoutMS: 8000,
+        });
+        try {
+            await client.connect();
+            const result = await client.db("admin").command({ ping: 1 });
+            return { ok: Number(result.ok) };
+        }
+        finally {
+            await client.close().catch(() => { });
+        }
+    },
+    catch: (cause) => new MongoCommandError({ cause }),
+});
+export const MongoProvider = () => Provider.succeed(Mongo, {
+    stables: ["serviceId", "projectId", "environmentId", "volumeId"],
+    nuke: { dependsOn: ["Railway.Project"] },
+    diff: Effect.fn(function* ({ news, output }) {
+        if (news === undefined || !isResolved(news))
+            return undefined;
+        if (output === undefined)
+            return undefined;
+        const nextProject = projectIdOf(news.project);
+        const projectChanged = nextProject !== undefined && nextProject !== output.projectId;
+        const nextEnv = environmentIdOf(news.environment);
+        const environmentChanged = nextEnv !== undefined && nextEnv !== output.environmentId;
+        const regionChanged = news.region !== undefined && news.region !== output.region;
+        if (projectChanged || environmentChanged || regionChanged) {
+            return { action: "replace" };
+        }
+        return undefined;
+    }),
+    read: Effect.fn(function* ({ id, olds, output }) {
+        const projectId = output?.projectId ??
+            (olds !== undefined ? projectIdOf(olds.project) : undefined);
+        const environmentId = output?.environmentId ??
+            (olds !== undefined
+                ? (environmentIdOf(olds.environment) ?? environmentIdOf(olds.project))
+                : undefined);
+        const name = yield* resolveName(id, olds?.name, output?.name);
+        const byId = output?.serviceId !== undefined && output.serviceId.length > 0
+            ? yield* getById(output.serviceId)
+            : undefined;
+        const found = byId ??
+            (projectId !== undefined
+                ? yield* findByName(projectId, name)
+                : undefined);
+        if (found === undefined)
+            return undefined;
+        const resolvedProjectId = projectIdOf(found) ?? projectId ?? "";
+        const resolvedEnvId = environmentId ??
+            environmentIdOf(olds?.project) ??
+            output?.environmentId ??
+            "";
+        const instance = resolvedEnvId.length > 0
+            ? yield* getInstance(resolvedEnvId, found.id)
+            : undefined;
+        const volume = output?.volumeInstanceId !== undefined &&
+            output.volumeInstanceId.length > 0
+            ? yield* getVolumeByInstanceId(output.volumeInstanceId)
+            : resolvedEnvId.length > 0 && resolvedProjectId.length > 0
+                ? yield* findVolume(resolvedEnvId, resolvedProjectId, (row) => (row.serviceId ?? undefined) === found.id ||
+                    (output?.volumeId !== undefined &&
+                        row.volumeId === output.volumeId))
+                : undefined;
+        const proxy = resolvedEnvId.length > 0
+            ? yield* findProxy(resolvedEnvId, found.id, MONGO_PORT)
+            : undefined;
+        const vars = resolvedProjectId.length > 0 && resolvedEnvId.length > 0
+            ? yield* listVariableMap(resolvedProjectId, resolvedEnvId, found.id)
+            : {};
+        const attrs = toAttrs({
+            service: found,
+            instance,
+            volume,
+            proxy,
+            projectId: resolvedProjectId,
+            environmentId: resolvedEnvId,
+            user: vars.MONGO_INITDB_ROOT_USERNAME ?? output?.user ?? DEFAULT_MONGO_USER,
+            password: vars.MONGO_INITDB_ROOT_PASSWORD ?? "",
+            database: vars.MONGO_INITDB_DATABASE ??
+                output?.database ??
+                DEFAULT_MONGO_DATABASE,
+        });
+        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) => Effect.gen(function* () {
+            const services = yield* listProjectServices(project.projectId);
+            const envRows = yield* railway.environments
+                .items({ projectId: project.projectId, first: 50 })
+                .pipe(Stream.filter((env) => env.deletedAt == null), Stream.runCollect, Effect.map((chunk) => Array.from(chunk)), Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.succeed([])));
+            const volumes = envRows.flatMap((env) => env.volumeInstances.edges.map((edge) => edge.node));
+            const items = yield* Effect.forEach(services.filter((service) => matchesAlchemyPhysicalName(service.name)), (service) => Effect.gen(function* () {
+                const volume = volumes.find((row) => (row.serviceId ?? undefined) === service.id);
+                const envIds = volume !== undefined
+                    ? [volume.environmentId]
+                    : envRows.map((env) => env.id);
+                let instance;
+                let environmentId = project.environmentId;
+                for (const id of envIds) {
+                    const candidate = yield* getInstance(id, service.id);
+                    if (isMongoImage(candidate?.source?.image)) {
+                        instance = candidate;
+                        environmentId = id;
+                        break;
+                    }
+                }
+                if (!isMongoImage(instance?.source?.image)) {
+                    return undefined;
+                }
+                return toAttrs({
+                    service,
+                    instance,
+                    volume,
+                    proxy: undefined,
+                    projectId: project.projectId,
+                    environmentId,
+                    user: DEFAULT_MONGO_USER,
+                    password: "",
+                    database: DEFAULT_MONGO_DATABASE,
+                });
+            }));
+            return items.filter((item) => item !== undefined);
+        }));
+        return rows.flat();
+    }),
+    reconcile: Effect.fn(function* ({ id, news, output }) {
+        const props = news ?? {};
+        const projectId = projectIdOf(props.project) ?? output?.projectId;
+        if (projectId === undefined) {
+            return yield* new MongoProjectRequired({
+                message: "Mongo requires a resolved Railway.Project",
+            });
+        }
+        const environmentId = environmentIdOf(props.environment) ??
+            environmentIdOf(props.project) ??
+            output?.environmentId;
+        if (environmentId === undefined) {
+            return yield* new MongoProjectRequired({
+                message: "Mongo requires a Railway environment (pass environment or a Project with environmentId)",
+            });
+        }
+        const name = yield* resolveName(id, props.name, output?.name);
+        const sourceImage = props.image ?? DEFAULT_MONGO_IMAGE;
+        const wantPublic = props.public !== false;
+        const volumeName = yield* createRailwayName(`${id}-data`);
+        let current = output?.serviceId !== undefined && output.serviceId.length > 0
+            ? yield* getById(output.serviceId)
+            : undefined;
+        if (current === undefined) {
+            current = yield* findByName(projectId, name);
+        }
+        const existingVars = current !== undefined
+            ? yield* listVariableMap(projectId, environmentId, current.id)
+            : {};
+        const user = existingVars.MONGO_INITDB_ROOT_USERNAME ??
+            props.user ??
+            DEFAULT_MONGO_USER;
+        const database = existingVars.MONGO_INITDB_DATABASE ??
+            props.database ??
+            DEFAULT_MONGO_DATABASE;
+        const password = existingVars.MONGO_INITDB_ROOT_PASSWORD ??
+            (props.password !== undefined
+                ? unwrapSecret(props.password)
+                : undefined) ??
+            (yield* generatePassword);
+        const variables = desiredVariables({ user, password, database });
+        if (current === undefined) {
+            const created = yield* railway
+                .serviceCreate({
+                input: {
+                    projectId,
+                    environmentId,
+                    name,
+                    source: { image: sourceImage },
+                    variables,
+                },
+            })
+                .pipe(Effect.catchTag("RailwayValidationError", (e) => alreadyExists(e.message)
+                ? Effect.succeed(undefined)
+                : Effect.fail(e)), Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+            current = created ?? (yield* findByName(projectId, name));
+        }
+        if (current === undefined || isGoneService(current)) {
+            return yield* new MongoNotCreated({ name, projectId });
+        }
+        if (current.name !== name) {
+            current = yield* railway.serviceUpdate({
+                id: current.id,
+                input: { name },
+            });
+        }
+        let instance = yield* waitForInstance(environmentId, current.id);
+        let needsDeploy = false;
+        const observedImage = instance?.source?.image ?? undefined;
+        const imageChanged = sourceImage !== undefined && !sameImage(observedImage, sourceImage);
+        const observedRegion = instance?.region ?? undefined;
+        const regionChanged = props.region !== undefined && props.region !== observedRegion;
+        const sleepOn = instance?.sleepApplication !== false;
+        const startChanged = normalizeStart(instance?.startCommand) !==
+            normalizeStart(MONGO_START_COMMAND);
+        if (imageChanged || regionChanged || sleepOn || startChanged) {
+            yield* railway.serviceInstanceUpdate({
+                environmentId,
+                serviceId: current.id,
+                input: {
+                    ...(imageChanged ? { source: { image: sourceImage } } : {}),
+                    ...(regionChanged ? { region: props.region } : {}),
+                    ...(sleepOn ? { sleepApplication: false } : {}),
+                    ...(startChanged ? { startCommand: MONGO_START_COMMAND } : {}),
+                },
+            });
+            needsDeploy = true;
+            instance = (yield* getInstance(environmentId, current.id)) ?? instance;
+        }
+        const envChanged = yield* syncEnv({
+            projectId,
+            environmentId,
+            serviceId: current.id,
+            desired: variables,
+        });
+        if (envChanged)
+            needsDeploy = true;
+        let volume = output?.volumeInstanceId !== undefined &&
+            output.volumeInstanceId.length > 0
+            ? yield* getVolumeByInstanceId(output.volumeInstanceId)
+            : undefined;
+        if (volume === undefined && output?.volumeId !== undefined) {
+            volume = yield* findVolume(environmentId, projectId, (row) => row.volumeId === output.volumeId);
+        }
+        if (volume === undefined) {
+            volume = yield* findVolume(environmentId, projectId, (row) => (row.serviceId ?? undefined) === current.id ||
+                row.volume.name === volumeName);
+        }
+        if (volume === undefined) {
+            const created = yield* railway.volumeCreate({
+                input: {
+                    projectId,
+                    environmentId,
+                    mountPath: MONGO_MOUNT_PATH,
+                    serviceId: current.id,
+                    ...(props.region !== undefined ? { region: props.region } : {}),
+                },
+            });
+            if (created.name !== volumeName) {
+                yield* stampVolumeName(created.id, volumeName);
+            }
+            const createdNode = created.volumeInstances.edges
+                .map((edge) => edge.node)
+                .find((node) => (node.volumeId === created.id || node.volume.id === created.id) &&
+                (node.deletedAt == null || node.deletedAt.length === 0) &&
+                !goneVolumeState(node.state));
+            volume = yield* waitForVolume(environmentId, projectId, created.id, createdNode?.id);
+            needsDeploy = true;
+        }
+        if (volume === undefined || isGoneVolume(volume)) {
+            return yield* new MongoVolumeNotCreated({
+                name: volumeName,
+                serviceId: current.id,
+            });
+        }
+        if (volume.volume.name !== volumeName) {
+            yield* stampVolumeName(volume.volumeId, volumeName);
+        }
+        const observedMount = volume.mountPath;
+        const observedServiceId = volume.serviceId ?? undefined;
+        const mountChanged = observedMount !== MONGO_MOUNT_PATH;
+        const attached = observedServiceId === current.id;
+        if (mountChanged || !attached) {
+            yield* railway.volumeInstanceUpdate({
+                volumeId: volume.volumeId,
+                environmentId,
+                input: {
+                    ...(mountChanged ? { mountPath: MONGO_MOUNT_PATH } : {}),
+                    ...(!attached ? { serviceId: current.id } : {}),
+                },
+            });
+            volume =
+                (yield* waitForVolume(environmentId, projectId, volume.volumeId)) ??
+                    volume;
+            needsDeploy = true;
+        }
+        let proxy = yield* findProxy(environmentId, current.id, MONGO_PORT);
+        if (wantPublic && proxy === undefined) {
+            const created = yield* railway
+                .tcpProxyCreate({
+                input: {
+                    applicationPort: MONGO_PORT,
+                    environmentId,
+                    serviceId: current.id,
+                },
+            })
+                .pipe(Effect.catchTag("RailwayValidationError", () => Effect.succeed(undefined)));
+            proxy =
+                created !== undefined && !isGoneProxy(created)
+                    ? created
+                    : yield* findProxy(environmentId, current.id, MONGO_PORT);
+        }
+        if (!wantPublic && proxy !== undefined) {
+            yield* deleteProxy(proxy.id);
+            proxy = undefined;
+        }
+        if (needsDeploy || instance?.latestDeployment == null) {
+            yield* railway
+                .serviceInstanceDeployV2({
+                environmentId,
+                serviceId: current.id,
+            })
+                .pipe(Effect.catchTag("RailwayValidationError", () => Effect.void));
+        }
+        instance =
+            (yield* waitForDeployment(environmentId, current.id)) ?? instance;
+        let finalStatus = instance?.latestDeployment?.status;
+        // A deployment can wedge in DEPLOYING and never reach SUCCESS — the
+        // container may serve, but Railway keeps its per-environment operation
+        // lock and the TCP proxy's routing is not committed. Converge: cancel
+        // the wedged deployment, redeploy once, and insist on SUCCESS.
+        if (!deployFailed(finalStatus) && !deployReady(finalStatus)) {
+            const wedged = instance?.latestDeployment?.id;
+            if (wedged != null && wedged.length > 0) {
+                yield* railway.deploymentCancel({ id: wedged }).pipe(Effect.ignore);
+            }
+            yield* railway
+                .serviceInstanceDeployV2({ environmentId, serviceId: current.id })
+                .pipe(Effect.catchTag("RailwayValidationError", () => Effect.void));
+            instance =
+                (yield* waitForDeployment(environmentId, current.id)) ?? instance;
+            finalStatus = instance?.latestDeployment?.status;
+        }
+        if (deployFailed(finalStatus) || !deployReady(finalStatus)) {
+            return yield* new MongoDeployFailed({
+                serviceId: current.id,
+                status: finalStatus ?? "failed",
+                deploymentId: instance?.latestDeployment?.id,
+            });
+        }
+        return toAttrs({
+            service: current,
+            instance,
+            volume,
+            proxy,
+            projectId,
+            environmentId,
+            user,
+            password,
+            database,
+        });
+    }),
+    delete: Effect.fn(function* ({ output }) {
+        const serviceId = output.serviceId;
+        const environmentId = output.environmentId;
+        // Cancel a still-running deployment first: it holds Railway's
+        // per-environment operation lock ("Cannot delete TCP proxy: an
+        // operation is already in progress") and can stall the service
+        // teardown indefinitely. A finished deployment makes this a no-op.
+        if (environmentId.length > 0 && serviceId.length > 0) {
+            const instance = yield* getInstance(environmentId, serviceId);
+            const latest = instance?.latestDeployment;
+            if (latest?.id != null &&
+                latest.id.length > 0 &&
+                !deployReady(latest.status) &&
+                !deployFailed(latest.status)) {
+                yield* railway
+                    .deploymentCancel({ id: latest.id })
+                    .pipe(Effect.ignore);
+            }
+        }
+        // Delete the SERVICE next — its teardown cascades onto the proxies.
+        if (serviceId.length > 0) {
+            yield* railway
+                .serviceDelete({
+                id: serviceId,
+                ...(environmentId.length > 0 ? { environmentId } : {}),
+            })
+                .pipe(Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void));
+            yield* getById(serviceId).pipe(Effect.map((service) => service === undefined), Effect.repeat({
+                schedule: Schedule.spaced("1 second"),
+                until: (gone) => gone,
+                times: 8,
+            }));
+        }
+        // Proxies usually disappear with the service; wait for the cascade
+        // instead of fighting the teardown's lock, then force-delete any
+        // survivor (which no-ops on NotFound).
+        if (environmentId.length > 0 && serviceId.length > 0) {
+            const leftover = yield* listProxies(environmentId, serviceId).pipe(Effect.repeat({
+                schedule: Schedule.spaced("3 seconds"),
+                until: (rows) => rows.length === 0,
+                times: 20,
+            }));
+            yield* Effect.forEach(leftover, (proxy) => deleteProxy(proxy.id), {
+                concurrency: 4,
+            });
+        }
+        else if (output.tcpProxyId !== undefined &&
+            output.tcpProxyId.length > 0) {
+            yield* deleteProxy(output.tcpProxyId);
+        }
+        if (output.volumeId.length > 0) {
+            yield* railway
+                .volumeDelete({ volumeId: output.volumeId })
+                .pipe(Effect.catchTag(["RailwayNotFound", "NotFound"], () => Effect.void));
+            const check = output.volumeInstanceId.length > 0
+                ? getVolumeByInstanceId(output.volumeInstanceId).pipe(Effect.map((instance) => instance === undefined))
+                : Effect.succeed(true);
+            yield* check.pipe(Effect.repeat({
+                schedule: Schedule.spaced("1 second"),
+                until: (gone) => gone,
+                times: 8,
+            }));
+        }
+    }),
+});
+//# sourceMappingURL=Mongo.js.map