vyft 0.2.0-alpha → 0.4.0-alpha

package/dist/services/index.js

@@ -0,0 +1,35 @@
+import { VYFT_MANAGED } from "../symbols.js";
+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";
+function wrapPrimitives(p) {
+    return {
+        volume: (id, cfg) => Object.assign(p.volume(id, cfg), { [VYFT_MANAGED]: true }),
+        service: (id, cfg) => Object.assign(p.service(id, cfg), { [VYFT_MANAGED]: true }),
+        secret: (id, cfg) => Object.assign(p.secret(id, cfg), { [VYFT_MANAGED]: true }),
+    };
+}
+/** Returns `true` if a resource was created by a built-in factory. */
+export function isManaged(resource) {
+    return (typeof resource === "object" &&
+        resource !== null &&
+        resource[VYFT_MANAGED] === true);
+}
+export function createServices(p) {
+    const wrapped = wrapPrimitives(p);
+    return {
+        postgres: createPostgres(wrapped),
+        redis: createRedis(wrapped),
+        rabbitmq: createRabbitmq(wrapped),
+        nats: createNats(wrapped),
+        mysql: createMysql(wrapped),
+        mongo: createMongo(wrapped),
+        minio: createMinio(wrapped),
+        storage: createStorage(wrapped),
+    };
+}

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`,
+        };
+    };
+}

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;