dokku-compose 0.6.13 → 0.8.0

package/README.md

@@ -16,396 +16,82 @@
 
 ## Why
 
-Configuring a Dokku server means running dozens of imperative commands in the right order. Miss one and your deploy breaks. Change servers and you're starting over.
-
-`dokku-compose` replaces that with a single YAML file. Like Docker Compose, but for Dokku.
-
-## A Complete Example
-
-```yaml
-dokku:
-  version: "0.35.12"
-
-plugins:
-  postgres:
-    url: https://github.com/dokku/dokku-postgres.git
-    version: "1.41.0"
-  redis:
-    url: https://github.com/dokku/dokku-redis.git
-
-services:
-  api-postgres:
-    plugin: postgres
-    version: "17-3.5"
-  shared-cache:
-    plugin: redis
-
-networks:
-  - backend-net
-
-domains:
-  - example.com
-
-nginx:
-  client-max-body-size: "50m"
-
-logs:
-  max-size: "50m"
-
-apps:
-  api:
-    build:
-      context: apps/api
-      dockerfile: docker/prod/api/Dockerfile
-    env:
-      APP_ENV: production
-      APP_SECRET: "${SECRET_KEY}"
-    domains:
-      - api.example.com
-    links:
-      - api-postgres
-      - shared-cache
-    networks:
-      - backend-net
-    ports:
-      - "https:4001:4000"
-    ssl:
-      certfile: certs/example.com/fullchain.pem
-      keyfile: certs/example.com/privkey.pem
-    storage:
-      - "/var/lib/dokku/data/storage/api/uploads:/app/uploads"
-    nginx:
-      client-max-body-size: "15m"
-      proxy-read-timeout: "120s"
-    checks:
-      wait-to-retire: 60
-      disabled:
-        - worker
-
-  worker:
-    links:
-      - api-postgres
-      - shared-cache
-    checks: false
-    proxy:
-      enabled: false
-```
+Dokku is a battle-tested, single-server PaaS — and one of the best platforms for self-hosting. But configuring it means running dozens of imperative commands in the right order. Miss one and your deploy breaks. Change servers and you're starting over.
+
+AI agents can generate and deploy code better than ever, but they can't reason about infrastructure that lives as a sequence of shell commands. There's no file to diff, no history to track, no way to review changes in a PR.
+
+`dokku-compose` makes Dokku declarative. One YAML file. Git-trackable. AI-friendly. Like Docker Compose, but for Dokku.
 
 ## Quick Start
 
 ```bash
-# Install
 npm install -g dokku-compose
-
-# Create a starter config
-dokku-compose init myapp
-
-# Preview what will happen
-dokku-compose up --dry-run
-
-# Apply configuration
-dokku-compose up
-
-# Or apply to a remote server over SSH
-DOKKU_HOST=my-server.example.com dokku-compose up
-```
-
-Requires Node.js >= 18. See the [Installation Reference →](docs/reference/install.md) for requirements and remote execution details.
-
-## Features
-
-Features are listed roughly in execution order — the sequence `dokku-compose up` follows.
-
-### Dokku Version Check
-
-Declare the expected Dokku version. A warning is logged if the running version doesn't match.
-
-```yaml
-dokku:
-  version: "0.35.12"
-```
-
-```
-[dokku      ] WARN: Version mismatch: running 0.34.0, config expects 0.35.12
 ```
 
-Dokku must be pre-installed on the target server.
+Requires Node.js >= 20. See the [Installation Reference](docs/reference/install.md) for details.
 
-### Application Management
+### 1. Export your existing server
 
-Create and destroy Dokku apps idempotently. If the app already exists, it's skipped.
-
-```yaml
-apps:
-  api:
-    # per-app configuration goes here
-```
-
-[Application Management Reference →](docs/reference/apps.md)
-
-### Environment Variables
-
-Set config vars per app or globally. All declared vars are converged — orphaned vars are automatically unset.
-
-```yaml
-apps:
-  api:
-    env:
-      APP_ENV: production
-      APP_SECRET: "${SECRET_KEY}"
-```
+Point at your Dokku server and generate a config file from its current state:
 
-[Environment Variables Reference →](docs/reference/config.md)
-
-### Build
-
-Configure Dockerfile builds: build context, Dockerfile path, app.json location, and build args. Key names follow docker-compose conventions.
-
-```yaml
-apps:
-  api:
-    build:
-      context: apps/api
-      dockerfile: docker/prod/api/Dockerfile
-      app_json: docker/prod/api/app.json
-      args:
-        SENTRY_AUTH_TOKEN: "${SENTRY_AUTH_TOKEN}"
-```
-
-[Build Reference →](docs/reference/builder.md)
-
-### Docker Options
-
-Add custom Docker options per build phase (`build`, `deploy`, `run`). Options are converged with targeted add/remove — only changed options are modified, preserving entries managed by other resources (e.g. `--link`, `--build-arg`).
-
-```yaml
-apps:
-  api:
-    docker_options:
-      deploy:
-        - "--shm-size 256m"
-      run:
-        - "--ulimit nofile=12"
-```
-
-[Docker Options Reference →](docs/reference/docker_options.md)
-
-### Networks
-
-Create shared Docker networks and configure per-app network properties.
-
-```yaml
-networks:
-  - backend-net
-
-apps:
-  api:
-    networks:                      # attach-post-deploy
-      - backend-net
-    network:                       # other network:set properties
-      attach_post_create:
-        - init-net
-      initial_network: custom-bridge
-      bind_all_interfaces: true
-      tld: internal
-```
-
-`down --force` clears network settings and destroys declared networks.
-
-[Networks Reference →](docs/reference/network.md)
-
-### Domains
-
-Configure custom domains per app or globally.
-
-```yaml
-domains:
-  - example.com
-
-apps:
-  api:
-    domains:
-      - api.example.com
-      - api.example.co
-```
-
-[Domains Reference →](docs/reference/domains.md)
-
-### Port Mappings
-
-Map external ports to container ports using `SCHEME:HOST_PORT:CONTAINER_PORT` format.
-
-```yaml
-apps:
-  api:
-    ports:
-      - "https:4001:4000"
+```bash
+DOKKU_HOST=my-server.example.com dokku-compose export -o dokku-compose.yml
 ```
 
-Comparison is order-insensitive. `down --force` clears port mappings before destroying the app.
+This produces a complete `dokku-compose.yml` reflecting everything on the server — apps, services, domains, env vars, and more.
 
-[Port Mappings Reference →](docs/reference/ports.md)
+### 2. See what's in sync
 
-### SSL Certificates
-
-Specify cert and key file paths. Idempotent — skips if SSL is already enabled. Set to `false` to remove an existing certificate.
-
-```yaml
-apps:
-  api:
-    ssl:                                  # add cert (idempotent)
-      certfile: certs/example.com/fullchain.pem
-      keyfile: certs/example.com/privkey.pem
-  worker:
-    ssl: false                            # remove cert
+```bash
+dokku-compose diff
 ```
 
-[SSL Certificates Reference →](docs/reference/certs.md)
-
-### Proxy
-
-Enable or disable the proxy for an app, and optionally select the proxy implementation (nginx, caddy, haproxy, traefik). All operations are idempotent.
-
-```yaml
-apps:
-  api:
-    proxy: true               # shorthand enable
-
-  worker:
-    proxy: false              # shorthand disable
-
-  caddy-app:
-    proxy:
-      enabled: true
-      type: caddy             # proxy:set caddy-app caddy
 ```
+  app: api
+    (in sync)
+  app: worker
+    ~ env: 1 → 2 items
+    + ports: (not set on server)
 
-[Proxy Reference →](docs/reference/proxy.md)
-
-### Persistent Storage
-
-Declare persistent bind mounts for an app. Mounts are fully converged on each `up` run — new mounts are added, mounts removed from YAML are unmounted, and existing mounts are skipped.
-
-```yaml
-apps:
-  api:
-    storage:
-      - "/var/lib/dokku/data/storage/api/uploads:/app/uploads"
+  1 resource(s) out of sync.
 ```
 
-Host directories must exist before mounting. On `down`, declared mounts are unmounted.
-
-[Storage Reference →](docs/reference/storage.md)
-
-### Nginx Configuration
-
-Set any nginx property supported by Dokku via a key-value map — per-app or globally.
+### 3. Preview changes
 
-```yaml
-nginx:                        # global defaults
-  client-max-body-size: "50m"
-
-apps:
-  api:
-    nginx:                    # per-app overrides
-      client-max-body-size: "15m"
-      proxy-read-timeout: "120s"
+```bash
+dokku-compose up --dry-run
 ```
 
-[Nginx Reference →](docs/reference/nginx.md)
-
-### Zero-Downtime Checks
-
-Configure zero-downtime deploy check properties, disable checks entirely, or control per process type. Properties are idempotent — current values are checked before setting.
-
-```yaml
-apps:
-  api:
-    checks:
-      wait-to-retire: 60
-      attempts: 5
-      disabled:
-        - worker
-      skipped:
-        - cron
-  worker:
-    checks: false                     # disable all checks (causes downtime)
 ```
+[worker    ] Setting 2 env var(s)... (dry run)
+[worker    ] Setting ports http:5000:5000... (dry run)
 
-[Zero-Downtime Checks Reference →](docs/reference/checks.md)
-
-### Log Management
-
-Configure log retention and shipping globally or per-app.
-
-```yaml
-logs:                            # global defaults
-  max-size: "50m"
-  vector-sink: "console://?encoding[codec]=json"
-
-apps:
-  api:
-    logs:                        # per-app overrides
-      max-size: "10m"
+# Commands that would run:
+dokku config:set --no-restart worker APP_ENV=production WORKER_COUNT=****
+dokku ports:set worker http:5000:5000
 ```
 
-[Log Management Reference →](docs/reference/logs.md)
-
-### Plugins and Services
-
-Install plugins and declare service instances. Services are created before apps during `up` and linked on demand.
-
-```yaml
-plugins:
-  postgres:
-    url: https://github.com/dokku/dokku-postgres.git
-    version: "1.41.0"
+### 4. Apply
 
-services:
-  api-postgres:
-    plugin: postgres
-
-apps:
-  api:
-    links:
-      - api-postgres
+```bash
+dokku-compose up
 ```
 
-[Plugins and Services Reference →](docs/reference/plugins.md)
+Running `up` again produces no changes — every step checks current state before acting.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `dokku-compose init [app...]` | Create a starter `dokku-compose.yml` |
-| `dokku-compose up` | Create/update apps and services to match config |
-| `dokku-compose down --force` | Destroy apps and services (requires `--force`) |
-| `dokku-compose ps` | Show status of configured apps |
-| `dokku-compose validate` | Validate config file offline (no server contact) |
-| `dokku-compose export` | Reverse-engineer server state into YAML |
+| `dokku-compose up [apps...]` | Create/update apps and services to match config |
+| `dokku-compose down --force [apps...]` | Destroy apps and services (requires `--force`) |
 | `dokku-compose diff` | Show what's out of sync between config and server |
+| `dokku-compose export` | Export current server state to YAML |
+| `dokku-compose ps [apps...]` | Show status of configured apps |
+| `dokku-compose validate` | Validate config file offline (no server contact) |
+| `dokku-compose init [apps...]` | Create a starter `dokku-compose.yml` |
 
-### `ps` — Show Status
-
-Queries each configured app and prints its deploy status:
-
-```
-$ dokku-compose ps
-api                  running
-worker               running
-web                  not created
-```
-
-### `down` — Tear Down
-
-Destroys apps and their linked services. Requires `--force` as a safety measure. For each app, services are unlinked first, then the app is destroyed. Service instances from the top-level `services:` section are destroyed after all apps.
-
-```bash
-dokku-compose down --force myapp     # Destroy one app and its services
-dokku-compose down --force           # Destroy all configured apps
-```
-
-## Options
+### Options
 
 | Option | Description |
 |--------|-------------|
@@ -415,18 +101,30 @@ dokku-compose down --force           # Destroy all configured apps
 | `--fail-fast` | Stop on first error (default: continue to next app) |
 | `--remove-orphans` | Destroy services and networks not in config |
 | `--verbose` | Show git-style +/- diff (diff command only) |
-| `--help` | Show usage |
-| `--version` | Show version |
 
-## Examples
+## Features
 
-```bash
-dokku-compose up                      # Configure all apps
-dokku-compose up myapp                # Configure one app
-dokku-compose up --dry-run            # Preview changes
-dokku-compose down --force myapp      # Destroy an app
-dokku-compose ps                      # Show status
-```
+All features are idempotent — running `up` twice produces no changes.
+
+| Feature | Description | Reference |
+|---------|-------------|-----------|
+| Apps | Create and destroy Dokku apps | [apps](docs/reference/apps.md) |
+| Environment Variables | Set config vars per app or globally, with full convergence | [config](docs/reference/config.md) |
+| Build | Dockerfile path, build context, app.json, build args | [builder](docs/reference/builder.md) |
+| Docker Options | Custom Docker options per phase (build/deploy/run) | [docker_options](docs/reference/docker_options.md) |
+| Networks | Create shared Docker networks, attach to apps | [network](docs/reference/network.md) |
+| Domains | Configure domains per app or globally | [domains](docs/reference/domains.md) |
+| Port Mappings | Map external ports to container ports | [ports](docs/reference/ports.md) |
+| SSL Certificates | Add or remove SSL certs | [certs](docs/reference/certs.md) |
+| Proxy | Enable/disable proxy, select implementation | [proxy](docs/reference/proxy.md) |
+| Storage | Persistent bind mounts with full convergence | [storage](docs/reference/storage.md) |
+| Nginx | Set any nginx property per app or globally | [nginx](docs/reference/nginx.md) |
+| Zero-Downtime Checks | Configure deploy checks, disable per process type | [checks](docs/reference/checks.md) |
+| Log Management | Log retention and vector sink configuration | [logs](docs/reference/logs.md) |
+| Plugins | Install Dokku plugins declaratively | [plugins](docs/reference/plugins.md) |
+| Postgres | Postgres services with optional S3 backups | [postgres](docs/reference/postgres.md) |
+| Redis | Redis service instances | [redis](docs/reference/redis.md) |
+| Service Links | Link postgres/redis services to apps | [plugins](docs/reference/plugins.md#linking-services-to-apps-appsapplinks) |
 
 ## Execution Modes
 
@@ -434,52 +132,11 @@ dokku-compose ps                      # Show status
 # Run remotely over SSH (recommended)
 DOKKU_HOST=my-server.example.com dokku-compose up
 
-# Run on the Dokku server itself (use DOKKU_HOST=localhost for best compatibility)
+# Run on the Dokku server itself
 DOKKU_HOST=localhost dokku-compose up
 ```
 
-When `DOKKU_HOST` is set, all Dokku commands are sent over SSH. This is the recommended mode — it works both remotely from your local machine and directly on the server. SSH mode avoids compatibility issues with Dokku's basher environment that can affect some commands when called directly from Node.js. SSH key access to the Dokku server is required.
-
-## What `up` Does
-
-Idempotently ensures desired state, in order:
-
-1. Check Dokku version (warn on mismatch)
-2. Install missing plugins
-3. Set global config (domains, env vars, nginx defaults)
-4. Create shared networks
-5. Create service instances (from top-level `services:`)
-6. For each app:
-   - Create app (if not exists)
-   - Set domains, link/unlink services, attach networks
-   - Enable/disable proxy, set ports, add SSL, mount storage
-   - Configure nginx, checks, logs, env vars, build, and docker options
-
-Running `up` twice produces no changes — every step checks current state before acting.
-
-`up` is mostly additive. Removing a key (e.g. deleting a `ports:` block) won't remove the corresponding setting from Dokku. The exception is `links:`, which is fully declarative — services not in the list are unlinked. Use `down --force` to fully reset an app, or `--remove-orphans` to destroy services and networks no longer in config.
-
-## Output
-
-```
-[networks  ] Creating backend-net... done
-[services  ] Creating api-postgres (postgres 17-3.5)... done
-[services  ] Creating api-redis (redis)... done
-[services  ] Creating shared-cache (redis)... done
-[api       ] Creating app... done
-[api       ] Setting domains: api.example.com... done
-[api       ] Linking api-postgres... done
-[api       ] Linking api-redis... done
-[api       ] Linking shared-cache... done
-[api       ] Setting ports https:4001:4000... done
-[api       ] Adding SSL certificate... done
-[api       ] Mounting /var/lib/dokku/data/storage/api/uploads:/app/uploads... done
-[api       ] Setting nginx client-max-body-size=15m... done
-[api       ] Setting checks wait-to-retire=60... done
-[api       ] Setting 2 env var(s)... done
-[worker    ] Creating app... already configured
-[worker    ] Linking shared-cache... already configured
-```
+When `DOKKU_HOST` is set, all commands are sent over SSH. This is the recommended mode — it works both remotely and on the server. SSH key access to the Dokku server is required.
 
 ## Architecture
 
@@ -513,7 +170,9 @@ dokku-compose/
 │   │   ├── proxy.ts          # dokku proxy:*
 │   │   ├── registry.ts       # dokku registry:*
 │   │   ├── scheduler.ts      # dokku scheduler:*
-│   │   ├── services.ts       # Service instances, links, plugin scripts
+│   │   ├── postgres.ts       # dokku postgres:* (create, backup, export)
+│   │   ├── redis.ts          # dokku redis:* (create, export)
+│   │   ├── links.ts          # Service link resolution across plugins
 │   │   └── storage.ts        # dokku storage:*
 │   ├── commands/
 │   │   ├── up.ts             # up command orchestration
@@ -542,7 +201,7 @@ bun install
 bun test
 
 # Run a specific module's tests
-bun test src/modules/services.test.ts
+bun test src/modules/postgres.test.ts
 ```
 
 Tests use [Bun's test runner](https://bun.sh/docs/cli/test) with a mocked `Runner` — no real Dokku server needed.

package/dist/index.js

@@ -79,12 +79,15 @@ var ServiceBackupSchema = z.object({
   bucket: z.string(),
   auth: ServiceBackupAuthSchema
 });
-var ServiceSchema = z.object({
-  plugin: z.string(),
+var PostgresSchema = z.object({
   version: z.string().optional(),
   image: z.string().optional(),
   backup: ServiceBackupSchema.optional()
 });
+var RedisSchema = z.object({
+  version: z.string().optional(),
+  image: z.string().optional()
+});
 var PluginSchema = z.object({
   url: z.string().url(),
   version: z.string().optional()
@@ -95,7 +98,8 @@ var ConfigSchema = z.object({
   }).optional(),
   plugins: z.record(z.string(), PluginSchema).optional(),
   networks: z.array(z.string()).optional(),
-  services: z.record(z.string(), ServiceSchema).optional(),
+  postgres: z.record(z.string(), PostgresSchema).optional(),
+  redis: z.record(z.string(), RedisSchema).optional(),
   apps: z.record(z.string(), AppSchema),
   domains: z.union([z.array(z.string()), z.literal(false)]).optional(),
   env: EnvMapSchema.optional(),
@@ -805,7 +809,7 @@ async function exportNetworks(ctx) {
   return output.split("\n").map((s) => s.trim()).filter((s) => s && !s.startsWith("=====>") && !DOCKER_BUILTIN_NETWORKS.has(s));
 }
 
-// src/modules/services.ts
+// src/modules/postgres.ts
 import { createHash as createHash2 } from "crypto";
 function backupHashKey(serviceName) {
   return "DOKKU_COMPOSE_BACKUP_HASH_" + serviceName.toUpperCase().replace(/-/g, "_");
@@ -813,22 +817,22 @@ function backupHashKey(serviceName) {
 function computeBackupHash(backup) {
   return createHash2("sha256").update(JSON.stringify(backup)).digest("hex");
 }
-async function ensureServices(ctx, services) {
+async function ensurePostgres(ctx, services) {
   for (const [name, config] of Object.entries(services)) {
     logAction("services", `Ensuring ${name}`);
-    const exists = await ctx.check(`${config.plugin}:exists`, name);
+    const exists = await ctx.check("postgres:exists", name);
     if (exists) {
       logSkip();
       continue;
     }
-    const args = [`${config.plugin}:create`, name];
+    const args = ["postgres:create", name];
     if (config.image) args.push("--image", config.image);
     if (config.version) args.push("--image-version", config.version);
     await ctx.run(...args);
     logDone();
   }
 }
-async function ensureServiceBackups(ctx, services) {
+async function ensurePostgresBackups(ctx, services) {
   for (const [name, config] of Object.entries(services)) {
     if (!config.backup) continue;
     logAction("services", `Configuring backup for ${name}`);
@@ -840,9 +844,9 @@ async function ensureServiceBackups(ctx, services) {
       continue;
     }
     const { schedule, bucket, auth } = config.backup;
-    await ctx.run(`${config.plugin}:backup-deauth`, name);
+    await ctx.run("postgres:backup-deauth", name);
     await ctx.run(
-      `${config.plugin}:backup-auth`,
+      "postgres:backup-auth",
       name,
       auth.access_key_id,
       auth.secret_access_key,
@@ -850,56 +854,145 @@ async function ensureServiceBackups(ctx, services) {
       auth.signature_version,
       auth.endpoint
     );
-    await ctx.run(`${config.plugin}:backup-schedule`, name, schedule, bucket);
+    await ctx.run("postgres:backup-schedule", name, schedule, bucket);
     await ctx.run("config:set", "--global", `${hashKey}=${desiredHash}`);
     logDone();
   }
 }
-async function ensureAppLinks(ctx, app, desiredLinks, allServices) {
-  const desiredSet = new Set(desiredLinks);
-  for (const [serviceName, serviceConfig] of Object.entries(allServices)) {
-    const isLinked = await ctx.check(`${serviceConfig.plugin}:linked`, serviceName, app);
-    const isDesired = desiredSet.has(serviceName);
-    if (isDesired && !isLinked) {
-      logAction(app, `Linking ${serviceName}`);
-      await ctx.run(`${serviceConfig.plugin}:link`, serviceName, app, "--no-restart");
-      logDone();
-    } else if (!isDesired && isLinked) {
-      logAction(app, `Unlinking ${serviceName}`);
-      await ctx.run(`${serviceConfig.plugin}:unlink`, serviceName, app, "--no-restart");
-      logDone();
+async function destroyPostgres(ctx, services) {
+  for (const [name] of Object.entries(services)) {
+    logAction("services", `Destroying ${name}`);
+    const exists = await ctx.check("postgres:exists", name);
+    if (!exists) {
+      logSkip();
+      continue;
     }
+    await ctx.run("postgres:destroy", name, "--force");
+    logDone();
   }
 }
-async function destroyAppLinks(ctx, app, links, allServices) {
-  for (const serviceName of links) {
-    const config = allServices[serviceName];
-    if (!config) continue;
-    const isLinked = await ctx.check(`${config.plugin}:linked`, serviceName, app);
-    if (isLinked) {
-      await ctx.run(`${config.plugin}:unlink`, serviceName, app, "--no-restart");
+async function exportPostgres(ctx) {
+  const services = {};
+  const listOutput = await ctx.query("postgres:list");
+  const lines = listOutput.split("\n").slice(1);
+  for (const line of lines) {
+    const name = line.trim().split(/\s+/)[0];
+    if (!name) continue;
+    const infoOutput = await ctx.query("postgres:info", name);
+    const versionMatch = infoOutput.match(/Version:\s+(\S+)/);
+    if (!versionMatch) continue;
+    const versionField = versionMatch[1];
+    const colonIdx = versionField.lastIndexOf(":");
+    const config = {};
+    if (colonIdx > 0) {
+      const image = versionField.slice(0, colonIdx);
+      const version2 = versionField.slice(colonIdx + 1);
+      if (image !== "postgres") config.image = image;
+      if (version2) config.version = version2;
+    } else {
+      config.version = versionField;
     }
+    services[name] = config;
   }
+  return services;
 }
-async function destroyServices(ctx, services) {
+
+// src/modules/redis.ts
+async function ensureRedis(ctx, services) {
   for (const [name, config] of Object.entries(services)) {
+    logAction("services", `Ensuring ${name}`);
+    const exists = await ctx.check("redis:exists", name);
+    if (exists) {
+      logSkip();
+      continue;
+    }
+    const args = ["redis:create", name];
+    if (config.image) args.push("--image", config.image);
+    if (config.version) args.push("--image-version", config.version);
+    await ctx.run(...args);
+    logDone();
+  }
+}
+async function destroyRedis(ctx, services) {
+  for (const [name] of Object.entries(services)) {
     logAction("services", `Destroying ${name}`);
-    const exists = await ctx.check(`${config.plugin}:exists`, name);
+    const exists = await ctx.check("redis:exists", name);
     if (!exists) {
       logSkip();
       continue;
     }
-    await ctx.run(`${config.plugin}:destroy`, name, "--force");
+    await ctx.run("redis:destroy", name, "--force");
     logDone();
   }
 }
-async function exportServices(_ctx) {
-  return {};
+async function exportRedis(ctx) {
+  const services = {};
+  const listOutput = await ctx.query("redis:list");
+  const lines = listOutput.split("\n").slice(1);
+  for (const line of lines) {
+    const name = line.trim().split(/\s+/)[0];
+    if (!name) continue;
+    const infoOutput = await ctx.query("redis:info", name);
+    const versionMatch = infoOutput.match(/Version:\s+(\S+)/);
+    if (!versionMatch) continue;
+    const versionField = versionMatch[1];
+    const colonIdx = versionField.lastIndexOf(":");
+    const config = {};
+    if (colonIdx > 0) {
+      const image = versionField.slice(0, colonIdx);
+      const version2 = versionField.slice(colonIdx + 1);
+      if (image !== "redis") config.image = image;
+      if (version2) config.version = version2;
+    } else {
+      config.version = versionField;
+    }
+    services[name] = config;
+  }
+  return services;
+}
+
+// src/modules/links.ts
+function resolveServicePlugin(name, config) {
+  if (config.postgres?.[name]) return { plugin: "postgres", config: config.postgres[name] };
+  if (config.redis?.[name]) return { plugin: "redis", config: config.redis[name] };
+  return void 0;
+}
+function allServices(config) {
+  const entries = [];
+  for (const name of Object.keys(config.postgres ?? {})) entries.push([name, "postgres"]);
+  for (const name of Object.keys(config.redis ?? {})) entries.push([name, "redis"]);
+  return entries;
+}
+async function ensureAppLinks(ctx, app, desiredLinks, config) {
+  const desiredSet = new Set(desiredLinks);
+  for (const [serviceName, plugin] of allServices(config)) {
+    const isLinked = await ctx.check(`${plugin}:linked`, serviceName, app);
+    const isDesired = desiredSet.has(serviceName);
+    if (isDesired && !isLinked) {
+      logAction(app, `Linking ${serviceName}`);
+      await ctx.run(`${plugin}:link`, serviceName, app, "--no-restart");
+      logDone();
+    } else if (!isDesired && isLinked) {
+      logAction(app, `Unlinking ${serviceName}`);
+      await ctx.run(`${plugin}:unlink`, serviceName, app, "--no-restart");
+      logDone();
+    }
+  }
+}
+async function destroyAppLinks(ctx, app, links, config) {
+  for (const serviceName of links) {
+    const resolved = resolveServicePlugin(serviceName, config);
+    if (!resolved) continue;
+    const isLinked = await ctx.check(`${resolved.plugin}:linked`, serviceName, app);
+    if (isLinked) {
+      await ctx.run(`${resolved.plugin}:unlink`, serviceName, app, "--no-restart");
+    }
+  }
 }
-async function exportAppLinks(ctx, app, services) {
+async function exportAppLinks(ctx, app, config) {
   const linked = [];
-  for (const [serviceName, config] of Object.entries(services)) {
-    const isLinked = await ctx.check(`${config.plugin}:linked`, serviceName, app);
+  for (const [serviceName, plugin] of allServices(config)) {
+    const isLinked = await ctx.check(`${plugin}:linked`, serviceName, app);
     if (isLinked) linked.push(serviceName);
   }
   return linked;
@@ -946,8 +1039,9 @@ async function runUp(ctx, config, appFilter) {
   if (config.logs !== void 0) await ensureGlobalLogs(ctx, config.logs);
   if (config.nginx !== void 0) await ensureGlobalNginx(ctx, config.nginx);
   if (config.networks) await ensureNetworks(ctx, config.networks);
-  if (config.services) await ensureServices(ctx, config.services);
-  if (config.services) await ensureServiceBackups(ctx, config.services);
+  if (config.postgres) await ensurePostgres(ctx, config.postgres);
+  if (config.redis) await ensureRedis(ctx, config.redis);
+  if (config.postgres) await ensurePostgresBackups(ctx, config.postgres);
   for (const app of apps) {
     const appConfig = config.apps[app];
     if (!appConfig) continue;
@@ -957,8 +1051,8 @@ async function runUp(ctx, config, appFilter) {
     await reconcile(NetworkProps, ctx, app, appConfig.network);
     await reconcile(Proxy, ctx, app, appConfig.proxy?.enabled);
     await reconcile(Ports, ctx, app, appConfig.ports);
-    if (config.services) {
-      await ensureAppLinks(ctx, app, appConfig.links ?? [], config.services);
+    if (config.postgres || config.redis) {
+      await ensureAppLinks(ctx, app, appConfig.links ?? [], config);
     }
     await reconcile(Certs, ctx, app, appConfig.ssl);
     await reconcile(Storage, ctx, app, appConfig.storage);
@@ -998,14 +1092,13 @@ async function runDown(ctx, config, appFilter, opts) {
   for (const app of apps) {
     const appConfig = config.apps[app];
     if (!appConfig) continue;
-    if (config.services && appConfig.links) {
-      await destroyAppLinks(ctx, app, appConfig.links, config.services);
+    if (appConfig.links && (config.postgres || config.redis)) {
+      await destroyAppLinks(ctx, app, appConfig.links, config);
     }
     await destroyApp(ctx, app);
   }
-  if (config.services) {
-    await destroyServices(ctx, config.services);
-  }
+  if (config.postgres) await destroyPostgres(ctx, config.postgres);
+  if (config.redis) await destroyRedis(ctx, config.redis);
   if (config.networks) {
     for (const net of config.networks) {
       logAction("network", `Destroying ${net}`);
@@ -1058,8 +1151,10 @@ async function runExport(ctx, opts) {
   const apps = opts.appFilter?.length ? opts.appFilter : await exportApps(ctx);
   const networks = await exportNetworks(ctx);
   if (networks.length > 0) config.networks = networks;
-  const services = await exportServices(ctx);
-  if (Object.keys(services).length > 0) config.services = services;
+  const postgres = await exportPostgres(ctx);
+  if (Object.keys(postgres).length > 0) config.postgres = postgres;
+  const redis = await exportRedis(ctx);
+  if (Object.keys(redis).length > 0) config.redis = redis;
   const prefetched = /* @__PURE__ */ new Map();
   await Promise.all(
     ALL_APP_RESOURCES.filter((r) => !r.forceApply && !r.key.startsWith("_") && r.readAll).map(async (r) => {
@@ -1082,8 +1177,8 @@ async function runExport(ctx, opts) {
         appConfig[resource.key] = value;
       }
     }
-    if (Object.keys(services).length > 0) {
-      const links = await exportAppLinks(ctx, app, services);
+    if (config.postgres || config.redis) {
+      const links = await exportAppLinks(ctx, app, config);
       if (links.length > 0) appConfig.links = links;
     }
     config.apps[app] = appConfig;
@@ -1159,8 +1254,13 @@ async function computeDiff(ctx, config) {
     }
     result.apps[app] = appDiff;
   }
-  for (const [svc, svcConfig] of Object.entries(config.services ?? {})) {
-    const exists = await ctx.check(`${svcConfig.plugin}:exists`, svc);
+  for (const svc of Object.keys(config.postgres ?? {})) {
+    const exists = await ctx.check("postgres:exists", svc);
+    result.services[svc] = { status: exists ? "in-sync" : "missing" };
+    if (!exists) result.inSync = false;
+  }
+  for (const svc of Object.keys(config.redis ?? {})) {
+    const exists = await ctx.check("redis:exists", svc);
     result.services[svc] = { status: exists ? "in-sync" : "missing" };
     if (!exists) result.inSync = false;
   }
@@ -1266,25 +1366,28 @@ function validate(filePath) {
   }
   const data = raw;
   if (data?.apps && typeof data.apps === "object") {
-    const serviceNames = new Set(
-      data?.services && typeof data.services === "object" ? Object.keys(data.services) : []
-    );
+    const serviceNames = /* @__PURE__ */ new Set();
+    if (data?.postgres && typeof data.postgres === "object") {
+      for (const name of Object.keys(data.postgres)) serviceNames.add(name);
+    }
+    if (data?.redis && typeof data.redis === "object") {
+      for (const name of Object.keys(data.redis)) serviceNames.add(name);
+    }
     for (const [appName, appCfg] of Object.entries(data.apps)) {
       if (!appCfg?.links) continue;
       for (const link of appCfg.links) {
         if (!serviceNames.has(link)) {
-          errors.push(`apps.${appName}.links: service "${link}" not defined in services`);
+          errors.push(`apps.${appName}.links: service "${link}" not defined in postgres or redis`);
         }
       }
     }
   }
-  if (data?.services && data?.plugins) {
-    const pluginNames = new Set(Object.keys(data.plugins));
-    for (const [svcName, svcCfg] of Object.entries(data.services)) {
-      if (svcCfg?.plugin && !pluginNames.has(svcCfg.plugin)) {
-        warnings.push(`services.${svcName}.plugin: "${svcCfg.plugin}" not declared in plugins (may be pre-installed)`);
-      }
-    }
+  const pluginNames = data?.plugins ? new Set(Object.keys(data.plugins)) : /* @__PURE__ */ new Set();
+  if (data?.postgres && pluginNames.size > 0 && !pluginNames.has("postgres")) {
+    warnings.push(`postgres: "postgres" plugin not declared in plugins (may be pre-installed)`);
+  }
+  if (data?.redis && pluginNames.size > 0 && !pluginNames.has("redis")) {
+    warnings.push(`redis: "redis" plugin not declared in plugins (may be pre-installed)`);
   }
   return { errors, warnings };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dokku-compose",
-  "version": "0.6.13",
+  "version": "0.8.0",
   "description": "Docker Compose for Dokku — declare your entire server in a single YAML file.",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -13,7 +13,7 @@
   ],
   "type": "module",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "test": "bun test",