vyft 0.1.1-alpha → 0.3.0-alpha

package/dist/services/rabbitmq.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 RabbitMQ instance. */
+export interface RabbitmqConfig {
+    /** Major RabbitMQ version. @defaultValue `4` */
+    version?: number;
+    /** Volume size hint (e.g. `"5GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed RabbitMQ instance with its associated resources. */
+export interface Rabbitmq {
+    /** The underlying service running RabbitMQ. */
+    service: Service;
+    /** Persistent volume for RabbitMQ data. */
+    volume: Volume;
+    /** Auto-generated `RABBITMQ_DEFAULT_PASS` secret. */
+    password: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port RabbitMQ listens on (`5672`). */
+    port: number;
+    /** AMQP connection string with credentials injected at deploy time. */
+    url: Interpolation;
+}
+export declare function createRabbitmq(p: Primitives): (id: string, config?: RabbitmqConfig) => Rabbitmq;

package/dist/services/rabbitmq.js

@@ -0,0 +1,44 @@
+import { interpolate } from "../interpolate.js";
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createRabbitmq(p) {
+    return function rabbitmq(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 4;
+        const password = p.secret(`${id}-password`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `rabbitmq:${version}`,
+            port: 5672,
+            volumes: [{ volume: vol, mount: "/var/lib/rabbitmq" }],
+            env: {
+                RABBITMQ_DEFAULT_PASS: password,
+            },
+            healthCheck: {
+                command: ["rabbitmq-diagnostics", "check_running"],
+                interval: "10s",
+                timeout: "10s",
+                retries: 5,
+                startPeriod: "30s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: `rabbitmq:${version}`,
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && rabbitmqctl export_definitions - | gzip | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.json.gz`,
+                env: { DB_PASSWORD: password },
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            password,
+            host: svc.host,
+            port: 5672,
+            url: interpolate `amqp://guest:${password}@${svc.host}:5672`,
+        };
+    };
+}

package/dist/services/redis.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 Redis instance. */
+export interface RedisConfig {
+    /** Major Redis version. @defaultValue `7` */
+    version?: number;
+    /** Volume size hint (e.g. `"5GB"`). */
+    size?: string;
+    /** Backup configuration. */
+    backup?: BackupConfig;
+}
+/** A managed Redis instance with its associated resources. */
+export interface Redis {
+    /** The underlying service running Redis. */
+    service: Service;
+    /** Persistent volume for Redis data. */
+    volume: Volume;
+    /** Auto-generated `REDIS_PASSWORD` secret. */
+    password: Secret;
+    /** Internal hostname reachable by other services. */
+    host: string;
+    /** Port Redis listens on (`6379`). */
+    port: number;
+    /** Connection string with the password injected at deploy time. */
+    url: Interpolation;
+}
+export declare function createRedis(p: Primitives): (id: string, config?: RedisConfig) => Redis;

package/dist/services/redis.js

@@ -0,0 +1,49 @@
+import { interpolate } from "../interpolate.js";
+import { validateId } from "../resource.js";
+import { createBackupSidecar } from "./storage.js";
+export function createRedis(p) {
+    return function redis(id, config = {}) {
+        validateId(id);
+        const version = config.version ?? 7;
+        const password = p.secret(`${id}-password`, { length: 32 });
+        const vol = p.volume(`${id}-data`, { size: config.size });
+        const svc = p.service(id, {
+            image: `redis:${version}`,
+            port: 6379,
+            command: [
+                "sh",
+                "-c",
+                'redis-server --requirepass "$(cat /run/secrets/*-password)"',
+            ],
+            volumes: [{ volume: vol, mount: "/data" }],
+            env: {
+                REDIS_PASSWORD: password,
+            },
+            healthCheck: {
+                command: ["redis-cli", "ping"],
+                interval: "5s",
+                timeout: "5s",
+                retries: 5,
+                startPeriod: "5s",
+            },
+        });
+        if (config.backup) {
+            createBackupSidecar(p, {
+                id,
+                image: `redis:${version}`,
+                svc,
+                backup: config.backup,
+                dumpScript: `TIMESTAMP=$(date +%Y%m%d-%H%M%S) && redis-cli -h ${svc.host} -a $(cat $DB_PASSWORD_FILE) --rdb /tmp/dump.rdb && gzip -c /tmp/dump.rdb | mc pipe backup/${config.backup.storage.bucket}/${id}-$TIMESTAMP.rdb.gz && rm -f /tmp/dump.rdb`,
+                env: { DB_PASSWORD: password },
+            });
+        }
+        return {
+            service: svc,
+            volume: vol,
+            password,
+            host: svc.host,
+            port: 6379,
+            url: interpolate `redis://:${password}@${svc.host}:6379`,
+        };
+    };
+}

package/dist/services/storage.d.ts

@@ -0,0 +1,39 @@
+import type { EnvValue, Secret, Service } from "../resource.js";
+import type { Primitives } from "./index.js";
+/** Configuration for a managed storage backend. */
+export interface StorageConfig {
+    /** Volume size hint for the backing store. */
+    size?: string;
+    /** MinIO image tag. @defaultValue `"latest"` */
+    version?: string;
+}
+/** An S3-compatible storage bucket provisioned by the shared storage backend. */
+export interface Storage {
+    /** The backing MinIO service (for dependsOn). */
+    service: Service;
+    /** Root access key. */
+    accessKey: Secret;
+    /** Root secret key. */
+    secretKey: Secret;
+    /** S3-compatible endpoint URL (e.g. `http://<host>:9000`). */
+    endpoint: string;
+    /** Bucket name (matches the storage id). */
+    bucket: string;
+}
+/** Backup configuration accepted by service factories. */
+export interface BackupConfig {
+    /** Storage target for backups. */
+    storage: Storage;
+    /** Cron expression for backup schedule. @defaultValue `"0 3 * * *"` (daily 3am) */
+    schedule?: string;
+}
+/** Create a backup sidecar service for a database. */
+export declare function createBackupSidecar(p: Primitives, opts: {
+    id: string;
+    image: string;
+    svc: Service;
+    backup: BackupConfig;
+    dumpScript: string;
+    env?: Record<string, EnvValue>;
+}): void;
+export declare function createStorage(p: Primitives): (id: string, config?: StorageConfig) => Storage;

package/dist/services/storage.js

@@ -0,0 +1,94 @@
+import { validateId } from "../resource.js";
+/** Convert a cron expression to a sleep interval in seconds. */
+function cronToSeconds(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return 86400;
+    const min = parts[0];
+    const hour = parts[1];
+    if (min.startsWith("*/"))
+        return Number.parseInt(min.slice(2), 10) * 60;
+    if (hour.startsWith("*/"))
+        return Number.parseInt(hour.slice(2), 10) * 3600;
+    return 86400;
+}
+const MC_URL = "https://dl.min.io/client/mc/release/linux-amd64/mc";
+/** Create a backup sidecar service for a database. */
+export function createBackupSidecar(p, opts) {
+    const interval = cronToSeconds(opts.backup.schedule ?? "0 3 * * *");
+    p.service(`${opts.id}-backup`, {
+        image: opts.image,
+        command: [
+            "sh",
+            "-c",
+            [
+                `(curl -sLo /usr/local/bin/mc ${MC_URL} 2>/dev/null || wget -qO /usr/local/bin/mc ${MC_URL})`,
+                "chmod +x /usr/local/bin/mc",
+                `mc alias set backup ${opts.backup.storage.endpoint} $(cat $STORAGE_ACCESS_KEY_FILE) $(cat $STORAGE_SECRET_KEY_FILE)`,
+                `while true; do ${opts.dumpScript}; sleep ${interval}; done`,
+            ].join(" && "),
+        ],
+        env: {
+            STORAGE_ACCESS_KEY: opts.backup.storage.accessKey,
+            STORAGE_SECRET_KEY: opts.backup.storage.secretKey,
+            ...opts.env,
+        },
+        dependsOn: [opts.svc, opts.backup.storage.service],
+        restartPolicy: "any",
+    });
+}
+export function createStorage(p) {
+    let shared = null;
+    function ensureMinio(config) {
+        if (shared)
+            return shared;
+        const version = config?.version ?? "latest";
+        const accessKey = p.secret("storage-access-key", { length: 16 });
+        const secretKey = p.secret("storage-secret-key", { length: 32 });
+        const vol = p.volume("storage-data", { size: config?.size });
+        const svc = p.service("storage", {
+            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",
+            },
+        });
+        shared = { service: svc, accessKey, secretKey, host: svc.host, vol };
+        return shared;
+    }
+    return function storage(id, config) {
+        validateId(id);
+        const minio = ensureMinio(config);
+        p.service(`storage-bucket-${id}`, {
+            image: "minio/mc:latest",
+            command: [
+                "sh",
+                "-c",
+                `mc alias set minio http://${minio.host}:9000 $(cat $ACCESS_KEY_FILE) $(cat $SECRET_KEY_FILE) && mc mb --ignore-existing minio/${id}`,
+            ],
+            env: {
+                ACCESS_KEY: minio.accessKey,
+                SECRET_KEY: minio.secretKey,
+            },
+            dependsOn: [minio.service],
+            restartPolicy: "none",
+        });
+        return {
+            service: minio.service,
+            accessKey: minio.accessKey,
+            secretKey: minio.secretKey,
+            endpoint: `http://${minio.host}:9000`,
+            bucket: id,
+        };
+    };
+}

package/dist/swarm/factories.d.ts

@@ -1,8 +1,16 @@
 import type { Secret, SecretConfig, Service, Site, SiteConfig, Volume } from "../resource.js";
 import type { StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig } from "./types.js";
 export declare function createFactories<D extends StorageDriver = "local">(swarmConfig: SwarmConfig<D>): {
-    volume(id: string, config?: SwarmVolumeConfig<D>): Volume;
-    service(id: string, config: SwarmServiceConfig): Service;
-    secret(id: string, config?: SecretConfig): Secret;
-    site(id: string, config: SiteConfig): Site;
+    postgres: (id: string, config?: import("./index.js").PostgresConfig) => import("./index.js").Postgres;
+    redis: (id: string, config?: import("./index.js").RedisConfig) => import("./index.js").Redis;
+    rabbitmq: (id: string, config?: import("./index.js").RabbitmqConfig) => import("./index.js").Rabbitmq;
+    nats: (id: string, config?: import("./index.js").NatsConfig) => import("./index.js").Nats;
+    mysql: (id: string, config?: import("./index.js").MysqlConfig) => import("./index.js").Mysql;
+    mongo: (id: string, config?: import("./index.js").MongoConfig) => import("./index.js").Mongo;
+    minio: (id: string, config?: import("./index.js").MinioConfig) => import("./index.js").Minio;
+    storage: (id: string, config?: import("./index.js").StorageConfig) => import("./index.js").Storage;
+    volume: (id: string, config?: SwarmVolumeConfig<D>) => Volume;
+    service: (id: string, config: SwarmServiceConfig) => Service;
+    secret: (id: string, config?: SecretConfig) => Secret;
+    site: (id: string, config: SiteConfig) => Site;
 };

package/dist/swarm/factories.js

@@ -1,4 +1,5 @@
 import { validateId, validateRoute } from "../resource.js";
+import { createServices } from "../services/index.js";
 import { VYFT_RUNTIME } from "../symbols.js";
 function attachRuntime(obj, config) {
     return Object.assign(obj, {
@@ -8,49 +9,55 @@ function attachRuntime(obj, config) {
 export function createFactories(swarmConfig) {
     const project = process.env.VYFT_PROJECT;
     const prefix = project ? `${project}-` : "";
-    return {
-        volume(id, config = {}) {
-            validateId(id);
-            const fullId = `${prefix}${id}`;
-            return attachRuntime({ type: "volume", id: fullId, config }, swarmConfig);
-        },
-        service(id, config) {
-            validateId(id);
-            if (config.route) {
-                validateRoute(config.route);
-            }
-            const fullId = `${prefix}${id}`;
-            const port = config.port || 3000;
-            return attachRuntime({
-                type: "service",
-                id: fullId,
-                config,
-                host: fullId,
-                port,
-                url: config.route
-                    ? `https://${config.route}`
-                    : `http://${fullId}:${port}`,
-            }, swarmConfig);
-        },
-        secret(id, config = {}) {
-            validateId(id);
-            const fullId = `${prefix}${id}`;
-            return attachRuntime({
-                type: "secret",
-                id: fullId,
-                config,
-            }, swarmConfig);
-        },
-        site(id, config) {
-            validateId(id);
+    function volume(id, config = {}) {
+        validateId(id);
+        const fullId = `${prefix}${id}`;
+        return attachRuntime({ type: "volume", id: fullId, config }, swarmConfig);
+    }
+    function service(id, config) {
+        validateId(id);
+        if (config.route) {
             validateRoute(config.route);
-            const fullId = `${prefix}${id}`;
-            return attachRuntime({
-                type: "site",
-                id: fullId,
-                config,
-                url: `https://${config.route}`,
-            }, swarmConfig);
-        },
+        }
+        const fullId = `${prefix}${id}`;
+        const port = config.port || 3000;
+        return attachRuntime({
+            type: "service",
+            id: fullId,
+            config,
+            host: fullId,
+            port,
+            url: config.route
+                ? `https://${config.route}`
+                : `http://${fullId}:${port}`,
+        }, swarmConfig);
+    }
+    function secret(id, config = {}) {
+        validateId(id);
+        const fullId = `${prefix}${id}`;
+        return attachRuntime({
+            type: "secret",
+            id: fullId,
+            config,
+        }, swarmConfig);
+    }
+    function site(id, config) {
+        validateId(id);
+        validateRoute(config.route);
+        const fullId = `${prefix}${id}`;
+        return attachRuntime({
+            type: "site",
+            id: fullId,
+            config,
+            url: `https://${config.route}`,
+        }, swarmConfig);
+    }
+    const services = createServices({ volume, service, secret });
+    return {
+        volume,
+        service,
+        secret,
+        site,
+        ...services,
     };
 }

package/dist/swarm/index.d.ts

@@ -1,10 +1,20 @@
+export type { BackupConfig, Bucket, Minio, MinioConfig, Mongo, MongoConfig, Mysql, MysqlConfig, Nats, NatsConfig, Postgres, PostgresConfig, Rabbitmq, RabbitmqConfig, Redis, RedisConfig, Storage, StorageConfig, } from "../services/index.js";
 export { createFactories } from "./factories.js";
 export type { DriverVolumeOptions, StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig, } from "./types.js";
 import type { Secret, SecretConfig, Service, Site, SiteConfig, Volume } from "../resource.js";
+import type { Minio, MinioConfig, Mongo, MongoConfig, Mysql, MysqlConfig, Nats, NatsConfig, Postgres, PostgresConfig, Rabbitmq, RabbitmqConfig, Redis, RedisConfig, Storage, StorageConfig } from "../services/index.js";
 import type { StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig } from "./types.js";
 export declare function swarm<D extends StorageDriver = "local">(config?: SwarmConfig<D>): {
     volume: (id: string, config?: SwarmVolumeConfig<D>) => Volume;
     service: (id: string, config: SwarmServiceConfig) => Service;
     secret: (id: string, config?: SecretConfig) => Secret;
     site: (id: string, config: SiteConfig) => Site;
+    postgres: (id: string, config?: PostgresConfig) => Postgres;
+    mysql: (id: string, config?: MysqlConfig) => Mysql;
+    redis: (id: string, config?: RedisConfig) => Redis;
+    rabbitmq: (id: string, config?: RabbitmqConfig) => Rabbitmq;
+    nats: (id: string, config?: NatsConfig) => Nats;
+    mongo: (id: string, config?: MongoConfig) => Mongo;
+    minio: (id: string, config?: MinioConfig) => Minio;
+    storage: (id: string, config?: StorageConfig) => Storage;
 };

package/dist/swarm/proxy.d.ts

@@ -0,0 +1,24 @@
+import type Docker from "dockerode";
+import type { Logger } from "pino";
+import type { ReverseProxy } from "../proxy.js";
+export declare function buildCaddyRoute(resourceId: string, route: string, handler: Record<string, unknown>): Record<string, unknown>;
+export declare class CaddyProxy implements ReverseProxy {
+    private docker;
+    private log;
+    constructor(docker: Docker, log: Logger);
+    ensure(): Promise<void>;
+    addRoute(resourceId: string, route: string, target: {
+        host: string;
+        port: number;
+    }): Promise<void>;
+    removeRoute(resourceId: string): Promise<void>;
+    logs(options: {
+        follow?: boolean;
+        tail?: number;
+    }): Promise<void>;
+    private findProxyContainer;
+    private caddyApiRequest;
+    private seedCaddyConfig;
+    private serviceExists;
+    private ensureNetwork;
+}