vyft 0.1.1-alpha → 0.3.0-alpha

package/dist/resource.d.ts

@@ -1,78 +1,174 @@
 import type { RuntimeRef } from "./symbols.js";
+/** Discriminant for the four resource kinds. */
 export type ResourceType = "volume" | "secret" | "service" | "site";
-export type VolumeConfig = {};
+/** Configuration for a persistent volume. */
+export interface VolumeConfig {
+    /** Human-readable size hint (e.g. `"10GB"`). Informational only. */
+    size?: string;
+}
+/** Configuration for an auto-generated secret. */
 export interface SecretConfig {
+    /** Length of the generated random value in bytes. */
     length?: number;
 }
+/** Container health-check configuration. */
 export interface HealthCheckConfig {
+    /** Command to run inside the container (e.g. `["pg_isready", "-U", "postgres"]`). */
     command: string[];
+    /** Time between checks (e.g. `"5s"`, `"1m"`). */
     interval?: string;
+    /** Maximum time a single check may take. */
     timeout?: string;
+    /** Consecutive failures required to mark unhealthy. */
     retries?: number;
+    /** Grace period before the first check runs. */
     startPeriod?: string;
 }
+/** CPU and memory limits for a service. */
 export interface ResourceLimits {
+    /** Memory ceiling (e.g. `"512MB"`, `"2GB"`). */
     memory?: string;
+    /** CPU core limit (e.g. `0.5`, `2`). */
     cpus?: number;
 }
+/** A persistent storage volume. */
 export interface Volume extends RuntimeRef {
     type: "volume";
     id: string;
     config: VolumeConfig;
 }
+/** An auto-generated secret value, injected at deploy time. */
 export interface Secret extends RuntimeRef {
     type: "secret";
     id: string;
     config: SecretConfig;
 }
+/**
+ * A long-running service (container).
+ *
+ * Use `host` and `port` to reference this service from other services
+ * in the same project, or `url` for the full address.
+ */
 export interface Service extends RuntimeRef {
     type: "service";
     id: string;
     config: ServiceConfig;
+    /** Internal hostname reachable by other services. */
     host: string;
+    /** Port the service listens on. */
     port: number;
+    /** Full URL — `https://<route>` if routed, otherwise `http://<host>:<port>`. */
     url: string;
 }
+/** A static site served via Caddy. */
 export interface Site extends RuntimeRef {
     type: "site";
     id: string;
     config: SiteConfig;
+    /** Public URL derived from the route (e.g. `https://example.com`). */
     url: string;
 }
+/** Union of all deployable resource types. */
 export type Resource = Volume | Secret | Service | Site;
+/**
+ * A deferred reference to a value that isn't known until deploy time.
+ *
+ * Currently only {@link Secret} produces deferred values. Expand this
+ * union as more resources gain deferred outputs.
+ */
 export type Reference = Secret;
+/**
+ * A tagged-template interpolation that mixes literal strings with
+ * {@link Reference} values. Created via {@link interpolate}.
+ *
+ * @example
+ * ```ts
+ * const connStr = interpolate`postgres://user:${dbPassword}@${db.host}:5432/app`;
+ * ```
+ */
 export interface Interpolation {
     type: "interpolation";
     strings: TemplateStringsArray;
     values: Array<Reference | string>;
 }
+/**
+ * A value that can appear in a service's `env` map.
+ *
+ * - Plain `string` — set verbatim.
+ * - {@link Reference} — resolved at deploy time (e.g. a secret).
+ * - {@link Interpolation} — a template mixing strings and references.
+ */
 export type EnvValue = string | Reference | Interpolation;
+/** Type-guard: returns `true` if `value` is a {@link Reference}. */
 export declare function isReference(value: unknown): value is Reference;
+/** Type-guard: returns `true` if `value` is a {@link Secret}. */
 export declare function isSecret(value: unknown): value is Secret;
+/** Type-guard: returns `true` if `value` is an {@link Interpolation}. */
 export declare function isInterpolation(value: unknown): value is Interpolation;
+/** Configuration for a long-running service. */
 export interface ServiceConfig {
+    /**
+     * Container image to run.
+     *
+     * - `string` — a registry image (e.g. `"node:22"`).
+     * - `{ context, dockerfile }` — build from a local Dockerfile.
+     */
     image: string | {
         context?: string;
         dockerfile?: string;
     };
+    /** Public route to expose (e.g. `"api.example.com"` or `"example.com/api"`). */
     route?: string;
+    /** Port the container listens on. Defaults to `3000`. */
     port?: number;
+    /** Environment variables injected into the container. */
     env?: Record<string, EnvValue>;
+    /** Override the container's default command. */
     command?: string[];
+    /** Volumes to mount into the container. */
     volumes?: Array<{
         volume: Volume;
         mount: string;
     }>;
+    /** Services that must be healthy before this one starts. */
+    dependsOn?: Service[];
+    /** Container health check. */
+    healthCheck?: HealthCheckConfig;
+    /**
+     * Restart behaviour on failure.
+     * @defaultValue `"any"`
+     */
+    restartPolicy?: "none" | "on-failure" | "any";
 }
+/** Configuration for a static site. */
 export interface SiteConfig {
+    /** Domain (and optional path) to serve the site on. */
     route: string;
+    /**
+     * Enable single-page application mode. When `true`, all requests that
+     * don't match a static file are rewritten to `/index.html`.
+     * @defaultValue `true`
+     */
     spa?: boolean;
+    /** Build settings for the static site. */
     build: {
+        /** Working directory containing the source (relative to project root). */
         cwd: string;
+        /** Directory containing the built output (relative to `cwd`). Defaults to `"dist"`. */
         output?: string;
+        /** Build command to run (e.g. `"npm run build"`). */
         command?: string;
+        /** Environment variables passed to the build command. */
         env?: Record<string, string>;
     };
 }
+/**
+ * Validates a resource ID.
+ * @throws If the ID is empty, too long, or contains invalid characters.
+ */
 export declare function validateId(id: string): void;
+/**
+ * Validates a route string.
+ * @throws If the route is empty or not a valid domain with optional path.
+ */
 export declare function validateRoute(route: string): void;

package/dist/resource.js

@@ -1,19 +1,25 @@
+/** Type-guard: returns `true` if `value` is a {@link Reference}. */
 export function isReference(value) {
     return isSecret(value);
 }
+/** Type-guard: returns `true` if `value` is a {@link Secret}. */
 export function isSecret(value) {
     return (typeof value === "object" &&
         value !== null &&
         value.type === "secret");
 }
+/** Type-guard: returns `true` if `value` is an {@link Interpolation}. */
 export function isInterpolation(value) {
     return (typeof value === "object" &&
         value !== null &&
         value.type === "interpolation");
 }
-// Validation
 const ID_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$|^[a-z]$/;
 const ROUTE_PATTERN = /^(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*(\/.+)?$/;
+/**
+ * Validates a resource ID.
+ * @throws If the ID is empty, too long, or contains invalid characters.
+ */
 export function validateId(id) {
     if (!id || id.length < 1) {
         throw new Error("Resource ID cannot be empty");
@@ -25,6 +31,10 @@ export function validateId(id) {
         throw new Error(`Invalid resource ID "${id}": must start with a letter, contain only lowercase letters, numbers, and hyphens, and end with a letter or number`);
     }
 }
+/**
+ * Validates a route string.
+ * @throws If the route is empty or not a valid domain with optional path.
+ */
 export function validateRoute(route) {
     if (!route) {
         throw new Error("Route cannot be empty");

package/dist/runtime.d.ts

@@ -1,6 +1,10 @@
 import type { Resource } from "./resource.js";
+/** Backend that can deploy, query, and tear down resources. */
 export interface Runtime {
+    /** Deploy or update a resource. */
     create(resource: Resource): Promise<void>;
+    /** Check whether a resource currently exists. */
     exists(resource: Resource): Promise<boolean>;
+    /** Tear down a resource. */
     remove(resource: Resource): Promise<void>;
 }

package/dist/services/index.d.ts

@@ -0,0 +1,24 @@
+import type { Secret, SecretConfig, Service, ServiceConfig, Volume, VolumeConfig } from "../resource.js";
+export interface Primitives {
+    volume(id: string, config?: VolumeConfig): Volume;
+    service(id: string, config: ServiceConfig): Service;
+    secret(id: string, config?: SecretConfig): Secret;
+}
+export declare function createServices(p: Primitives): {
+    postgres: (id: string, config?: import("./postgres.js").PostgresConfig) => import("./postgres.js").Postgres;
+    redis: (id: string, config?: import("./redis.js").RedisConfig) => import("./redis.js").Redis;
+    rabbitmq: (id: string, config?: import("./rabbitmq.js").RabbitmqConfig) => import("./rabbitmq.js").Rabbitmq;
+    nats: (id: string, config?: import("./nats.js").NatsConfig) => import("./nats.js").Nats;
+    mysql: (id: string, config?: import("./mysql.js").MysqlConfig) => import("./mysql.js").Mysql;
+    mongo: (id: string, config?: import("./mongo.js").MongoConfig) => import("./mongo.js").Mongo;
+    minio: (id: string, config?: import("./minio.js").MinioConfig) => import("./minio.js").Minio;
+    storage: (id: string, config?: import("./storage.js").StorageConfig) => import("./storage.js").Storage;
+};
+export type { Bucket, Minio, MinioConfig } from "./minio.js";
+export type { Mongo, MongoConfig } from "./mongo.js";
+export type { Mysql, MysqlConfig } from "./mysql.js";
+export type { Nats, NatsConfig } from "./nats.js";
+export type { Postgres, PostgresConfig } from "./postgres.js";
+export type { Rabbitmq, RabbitmqConfig } from "./rabbitmq.js";
+export type { Redis, RedisConfig } from "./redis.js";
+export type { BackupConfig, Storage, StorageConfig } from "./storage.js";

package/dist/services/index.js

@@ -0,0 +1,20 @@
+import { createMinio } from "./minio.js";
+import { createMongo } from "./mongo.js";
+import { createMysql } from "./mysql.js";
+import { createNats } from "./nats.js";
+import { createPostgres } from "./postgres.js";
+import { createRabbitmq } from "./rabbitmq.js";
+import { createRedis } from "./redis.js";
+import { createStorage } from "./storage.js";
+export function createServices(p) {
+    return {
+        postgres: createPostgres(p),
+        redis: createRedis(p),
+        rabbitmq: createRabbitmq(p),
+        nats: createNats(p),
+        mysql: createMysql(p),
+        mongo: createMongo(p),
+        minio: createMinio(p),
+        storage: createStorage(p),
+    };
+}

package/dist/services/minio.d.ts

@@ -0,0 +1,36 @@
+import type { Secret, Service, Volume } from "../resource.js";
+import type { Primitives } from "./index.js";
+/** Configuration for a managed MinIO instance. */
+export interface MinioConfig {
+    /** MinIO image tag. @defaultValue `"latest"` */
+    version?: string;
+    /** Volume size hint (e.g. `"50GB"`). */
+    size?: string;
+}
+/** A named S3-compatible bucket on this MinIO instance. */
+export interface Bucket {
+    /** Bucket name. */
+    name: string;
+    /** Init service that creates the bucket on first deploy. */
+    service: Service;
+}
+/** A managed MinIO (S3-compatible) instance with its associated resources. */
+export interface Minio {
+    /** The underlying service running MinIO. */
+    service: Service;
+    /** Persistent volume for object storage data. */
+    volume: Volume;
+    /** Auto-generated root access key. */
+    accessKey: Secret;
+    /** Auto-generated root secret key. */
+    secretKey: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port the MinIO API listens on (`9000`). */
+    port: number;
+    /** Full internal endpoint URL (e.g. `http://<host>:9000`). */
+    endpoint: string;
+    /** Create a bucket that is provisioned automatically on deploy. */
+    bucket: (name: string) => Bucket;
+}
+export declare function createMinio(p: Primitives): (id: string, config?: MinioConfig) => Minio;

package/dist/services/minio.js

@@ -0,0 +1,53 @@
+import { validateId } from "../resource.js";
+export function createMinio(p) {
+    return function minio(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? "latest";
+        const accessKey = p.secret(`${id}-access-key`, { length: 16 });
+        const secretKey = p.secret(`${id}-secret-key`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `minio/minio:${version}`,
+            port: 9000,
+            command: ["server", "/data"],
+            volumes: [{ volume: vol, mount: "/data" }],
+            env: {
+                MINIO_ROOT_USER: accessKey,
+                MINIO_ROOT_PASSWORD: secretKey,
+            },
+            healthCheck: {
+                command: ["mc", "ready", "local"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "5s",
+            },
+        });
+        return {
+            service: svc,
+            volume: vol,
+            accessKey,
+            secretKey,
+            host: svc.host,
+            port: 9000,
+            endpoint: `http://${svc.host}:9000`,
+            bucket(name) {
+                const initSvc = p.service(`${id}-bucket-${name}`, {
+                    image: "minio/mc:latest",
+                    command: [
+                        "sh",
+                        "-c",
+                        `mc alias set minio http://${svc.host}:9000 $(cat $ACCESS_KEY_FILE) $(cat $SECRET_KEY_FILE) && mc mb --ignore-existing minio/${name}`,
+                    ],
+                    env: {
+                        ACCESS_KEY: accessKey,
+                        SECRET_KEY: secretKey,
+                    },
+                    dependsOn: [svc],
+                    restartPolicy: "none",
+                });
+                return { name, service: initSvc };
+            },
+        };
+    };
+}

package/dist/services/mongo.d.ts

@@ -0,0 +1,28 @@
+import type { Interpolation, Secret, Service, Volume } from "../resource.js";
+import type { Primitives } from "./index.js";
+import { type BackupConfig } from "./storage.js";
+/** Configuration for a managed MongoDB instance. */
+export interface MongoConfig {
+    /** Major MongoDB version. @defaultValue `8` */
+    version?: number;
+    /** Volume size hint (e.g. `"10GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed MongoDB instance with its associated resources. */
+export interface Mongo {
+    /** The underlying service running MongoDB. */
+    service: Service;
+    /** Persistent volume for MongoDB data. */
+    volume: Volume;
+    /** Auto-generated root password secret. */
+    password: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port MongoDB listens on (`27017`). */
+    port: number;
+    /** Connection string with credentials injected at deploy time. */
+    url: Interpolation;
+}
+export declare function createMongo(p: Primitives): (id: string, config?: MongoConfig) => Mongo;

package/dist/services/mongo.js

@@ -0,0 +1,45 @@
+import { interpolate } from "../interpolate.js";
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createMongo(p) {
+    return function mongo(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 8;
+        const password = p.secret(`${id}-password`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `mongo:${version}`,
+            port: 27017,
+            volumes: [{ volume: vol, mount: "/data/db" }],
+            env: {
+                MONGO_INITDB_ROOT_USERNAME: "mongo",
+                MONGO_INITDB_ROOT_PASSWORD: password,
+            },
+            healthCheck: {
+                command: ["mongosh", "--eval", "db.runCommand('ping').ok", "--quiet"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "10s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: `mongo:${version}`,
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && mongodump --uri="mongodb://mongo:$(cat $DB_PASSWORD_FILE)@${svc.host}:27017" --archive --gzip | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.gz`,
+                env: { DB_PASSWORD: password },
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            password,
+            host: svc.host,
+            port: 27017,
+            url: interpolate `mongodb://mongo:${password}@${svc.host}:27017`,
+        };
+    };
+}

package/dist/services/mysql.d.ts

@@ -0,0 +1,28 @@
+import type { Interpolation, Secret, Service, Volume } from "../resource.js";
+import type { Primitives } from "./index.js";
+import { type BackupConfig } from "./storage.js";
+/** Configuration for a managed MySQL instance. */
+export interface MysqlConfig {
+    /** Major MySQL version. @defaultValue `9` */
+    version?: number;
+    /** Volume size hint (e.g. `"10GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed MySQL instance with its associated resources. */
+export interface Mysql {
+    /** The underlying service running MySQL. */
+    service: Service;
+    /** Persistent volume for MySQL data. */
+    volume: Volume;
+    /** Auto-generated `MYSQL_ROOT_PASSWORD` secret. */
+    password: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port MySQL listens on (`3306`). */
+    port: number;
+    /** Connection string with the password injected at deploy time. */
+    url: Interpolation;
+}
+export declare function createMysql(p: Primitives): (id: string, config?: MysqlConfig) => Mysql;

package/dist/services/mysql.js

@@ -0,0 +1,44 @@
+import { interpolate } from "../interpolate.js";
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createMysql(p) {
+    return function mysql(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 9;
+        const password = p.secret(`${id}-password`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `mysql:${version}`,
+            port: 3306,
+            volumes: [{ volume: vol, mount: "/var/lib/mysql" }],
+            env: {
+                MYSQL_ROOT_PASSWORD: password,
+            },
+            healthCheck: {
+                command: ["mysqladmin", "ping", "-h", "localhost"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "15s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: `mysql:${version}`,
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && mysqldump -h ${svc.host} -u root -p$(cat $DB_PASSWORD_FILE) --all-databases | gzip | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.sql.gz`,
+                env: { DB_PASSWORD: password },
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            password,
+            host: svc.host,
+            port: 3306,
+            url: interpolate `mysql://root:${password}@${svc.host}:3306`,
+        };
+    };
+}

package/dist/services/nats.d.ts

@@ -0,0 +1,26 @@
+import type { Service, Volume } from "../resource.js";
+import type { Primitives } from "./index.js";
+import { type BackupConfig } from "./storage.js";
+/** Configuration for a managed NATS instance. */
+export interface NatsConfig {
+    /** Major NATS version. @defaultValue `2` */
+    version?: number;
+    /** Volume size hint (e.g. `"5GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed NATS instance with JetStream enabled. */
+export interface Nats {
+    /** The underlying service running NATS. */
+    service: Service;
+    /** Persistent volume for JetStream data. */
+    volume: Volume;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port NATS listens on (`4222`). */
+    port: number;
+    /** Connection URL (e.g. `nats://<host>:4222`). */
+    url: string;
+}
+export declare function createNats(p: Primitives): (id: string, config?: NatsConfig) => Nats;

package/dist/services/nats.js

@@ -0,0 +1,38 @@
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createNats(p) {
+    return function nats(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 2;
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `nats:${version}`,
+            port: 4222,
+            command: ["--jetstream", "--store_dir", "/data"],
+            volumes: [{ volume: vol, mount: "/data" }],
+            healthCheck: {
+                command: ["sh", "-c", "wget -qO- http://localhost:8222/healthz"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "5s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: "natsio/nats-box",
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && mkdir -p /tmp/backup && for s in $(nats -s nats://${svc.host}:4222 stream ls -n 2>/dev/null); do nats -s nats://${svc.host}:4222 stream backup "$s" "/tmp/backup/$s"; done && tar czf - -C /tmp backup | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.tar.gz && rm -rf /tmp/backup`,
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            host: svc.host,
+            port: 4222,
+            url: `nats://${svc.host}:4222`,
+        };
+    };
+}

package/dist/services/postgres.d.ts

@@ -0,0 +1,28 @@
+import type { Interpolation, Secret, Service, Volume } from "../resource.js";
+import type { Primitives } from "./index.js";
+import { type BackupConfig } from "./storage.js";
+/** Configuration for a managed Postgres instance. */
+export interface PostgresConfig {
+    /** Major Postgres version. @defaultValue `18` */
+    version?: number;
+    /** Volume size hint (e.g. `"10GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed Postgres instance with its associated resources. */
+export interface Postgres {
+    /** The underlying service running Postgres. */
+    service: Service;
+    /** Persistent volume for Postgres data. */
+    volume: Volume;
+    /** Auto-generated `POSTGRES_PASSWORD` secret. */
+    password: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port Postgres listens on (`5432`). */
+    port: number;
+    /** Connection string with the password injected at deploy time. */
+    url: Interpolation;
+}
+export declare function createPostgres(p: Primitives): (id: string, config?: PostgresConfig) => Postgres;

package/dist/services/postgres.js

@@ -0,0 +1,45 @@
+import { interpolate } from "../interpolate.js";
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createPostgres(p) {
+    return function postgres(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 18;
+        const mount = version >= 18 ? "/var/lib/postgresql" : "/var/lib/postgresql/data";
+        const password = p.secret(`${id}-password`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `postgres:${version}`,
+            port: 5432,
+            volumes: [{ volume: vol, mount }],
+            env: {
+                POSTGRES_PASSWORD: password,
+            },
+            healthCheck: {
+                command: ["pg_isready", "-U", "postgres"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "10s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: `postgres:${version}`,
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && PGPASSWORD=$(cat $DB_PASSWORD_FILE) pg_dump -h ${svc.host} -U postgres | gzip | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.sql.gz`,
+                env: { DB_PASSWORD: password },
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            password,
+            host: svc.host,
+            port: 5432,
+            url: interpolate `postgres://postgres:${password}@${svc.host}:5432/postgres`,
+        };
+    };
+}