@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/commands/database-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleDatabaseSchemasCommand(context: CommandContext): Promise<void>;

package/dist/src/commands/database-schemas.js

@@ -0,0 +1,188 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildDatabaseSchemasPlan, pullDatabaseSchemasToWorkspace, pushDatabaseSchemas } from "../resource-syncs/database-schema-sync.js";
+import { printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+function formatPlanChangeValue(value) {
+    if (value === undefined) {
+        return '(absent)';
+    }
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+}
+export async function handleDatabaseSchemasCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand !== 'pull' && subcommand !== 'plan' && subcommand !== 'push') {
+        throw new Error('Unknown database-schemas command. Usage: revo database-schemas <pull|plan|push> --all --project <name>');
+    }
+    const selectedStableKey = context.args._[2];
+    const all = readBoolFlag(context.args, ['all', 'a']);
+    const skipPartitions = readBoolFlag(context.args, ['skip-partitions']);
+    const pruneOrphans = readBoolFlag(context.args, ['prune-orphans']);
+    if (subcommand !== 'push' && !all) {
+        throw new Error(`Database Schema ${subcommand} currently requires --all.`);
+    }
+    if (subcommand === 'push' && all === Boolean(selectedStableKey)) {
+        throw new Error('Database Schema push requires exactly one selector: <stableKey> or --all.');
+    }
+    if (skipPartitions && subcommand !== 'plan') {
+        throw new Error('Database Schema --skip-partitions is supported only by plan.');
+    }
+    if (pruneOrphans && subcommand === 'plan') {
+        throw new Error('Database Schema --prune-orphans is supported only by pull or push.');
+    }
+    if (pruneOrphans && (!readBoolFlag(context.args, ['yes', 'y']) || !readBoolFlag(context.args, ['force', 'f']))) {
+        throw new Error(`Database Schema ${subcommand} --prune-orphans requires --yes --force.`);
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error(`Database Schema ${subcommand} requires a named environment profile; "default" is not supported.`);
+    }
+    const client = new RevoClient({ envName });
+    if (subcommand === 'push') {
+        const confirmed = readBoolFlag(context.args, ['yes', 'y']);
+        if (!confirmed) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Database Schemas to "${envName}"?`, false)) {
+                throw new Error('Database Schema push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const result = await pushDatabaseSchemas({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            ...(selectedStableKey ? { stableKey: selectedStableKey } : {}),
+            force: readBoolFlag(context.args, ['force', 'f']),
+            prunePartitions: readBoolFlag(context.args, ['prune-partitions']),
+            prunePartitionsConfirmed: confirmed,
+            pruneOrphans,
+            pruneOrphansConfirmed: confirmed,
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(result);
+        }
+        else {
+            for (const item of result.results) {
+                const label = item.status === 'deployed'
+                    ? 'Deployed'
+                    : item.status === 'failed'
+                        ? 'Failed'
+                        : item.status === 'write-unverified'
+                            ? 'Unverified'
+                            : 'Skipped';
+                printSyncStatus(context.println, {
+                    status: label,
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+        }
+        const failed = result.results.filter((item) => item.status === 'failed');
+        const unverifiedWrites = result.results.filter((item) => item.status === 'write-unverified');
+        if (failed.length > 0 || unverifiedWrites.length > 0) {
+            const outcomes = [
+                ...(failed.length > 0 ? [`${failed.length} failure(s)`] : []),
+                ...(unverifiedWrites.length > 0 ? [`${unverifiedWrites.length} unverified write(s)`] : []),
+            ];
+            throw new Error(`Database Schema push finished with ${outcomes.join(', ')}.`);
+        }
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildDatabaseSchemasPlan({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            withStats: readBoolFlag(context.args, ['with-stats']),
+            skipPartitions,
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Database Schema',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items.map((item) => ({
+                    ...item,
+                    details: [
+                        ...(item.changes?.length
+                            ? [{
+                                    label: 'changes',
+                                    values: item.changes.map((change) => (`${change.field} (${change.risk}): ${formatPlanChangeValue(change.before)} -> ${formatPlanChangeValue(change.after)}`)),
+                                }]
+                            : []),
+                        ...(item.hints.length ? [{ label: 'hints', values: item.hints }] : []),
+                        ...(item.stats
+                            ? [{
+                                    label: 'size',
+                                    values: `total=${item.stats.total}B table=${item.stats.table}B indexes=${item.stats.indexes}B audit=${item.stats.audit}B`,
+                                }]
+                            : []),
+                    ],
+                })),
+                warnings: plan.warnings,
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const converged = new Set(['clean', 'reconciled', 'orphan-root', 'orphan-partition']);
+            const drift = plan.items.filter((item) => !converged.has(item.status));
+            if (plan.blockers.length > 0 || drift.length > 0) {
+                throw new Error(`Database Schema strict plan is not converged: ${drift.length} drift or incomplete item(s), ${plan.blockers.length} blocker(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullDatabaseSchemasToWorkspace({
+        client,
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+        strict: readBoolFlag(context.args, ['strict']),
+        pruneOrphans,
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+        return;
+    }
+    const output = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        output.push({ status: 'pulled', targetPath: pulled.targetPath });
+    }
+    for (const pruned of result.pruned) {
+        printSyncStatus(context.println, {
+            status: 'Pruned',
+            direction: 'pull',
+            targetPath: pruned.targetPath,
+            reason: `source resource ${pruned.stableKey} is absent`,
+        });
+        output.push({ status: 'pruned', targetPath: pruned.targetPath });
+    }
+    for (const skipped of result.skipped) {
+        printSyncStatus(context.println, {
+            status: 'Skipped', direction: 'pull', targetPath: skipped.targetPath, reason: skipped.reason,
+        });
+        output.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+    }
+    const auditEnabled = result.diagnostics.filter((item) => item.audit === true).length;
+    const restricted = result.diagnostics.filter((item) => (item.acl && typeof item.acl === 'object' && item.acl.restricted === true)).length;
+    const tagged = result.diagnostics.filter((item) => Array.isArray(item.tags) && item.tags.length > 0).length;
+    if (auditEnabled > 0 || restricted > 0 || tagged > 0) {
+        context.println(`Diagnostics (target-local, excluded from portable hash): ${auditEnabled} audit-enabled, ${restricted} restricted, ${tagged} tagged.`);
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

package/dist/src/commands/database-views.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleDatabaseViewsCommand(context: CommandContext): Promise<void>;

package/dist/src/commands/database-views.js

@@ -0,0 +1,123 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildDatabaseViewsPlan, pullDatabaseViewsToWorkspace, pushDatabaseViews } from "../resource-syncs/database-view-sync.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+export async function handleDatabaseViewsCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand !== 'pull' && subcommand !== 'plan' && subcommand !== 'push') {
+        throw new Error('Unknown database-views command. Usage: revo database-views <pull|plan|push> --all --project <name>');
+    }
+    const selectedStableKey = context.args._[2];
+    const all = readBoolFlag(context.args, ['all', 'a']);
+    if (subcommand !== 'push' && !all) {
+        throw new Error(`Database View ${subcommand} currently requires --all.`);
+    }
+    if (subcommand === 'push' && all === Boolean(selectedStableKey)) {
+        throw new Error('Database View push requires exactly one selector: <stableKey> or --all.');
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error(`Database View ${subcommand} requires a named environment profile; "default" is not supported.`);
+    }
+    const client = new RevoClient({ envName });
+    if (subcommand === 'push') {
+        const confirmed = readBoolFlag(context.args, ['yes', 'y']);
+        if (!confirmed) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Database Views to "${envName}"?`, false)) {
+                throw new Error('Database View push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const result = await pushDatabaseViews({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            ...(selectedStableKey ? { stableKey: selectedStableKey } : {}),
+            force: readBoolFlag(context.args, ['force', 'f']),
+            allowMaterializedWrites: readBoolFlag(context.args, ['allow-materialized']),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(result);
+        }
+        else {
+            for (const item of result.results) {
+                printSyncStatus(context.println, {
+                    status: item.status === 'deployed' ? 'Deployed' : item.status === 'write-unverified' ? 'Unverified' : item.status === 'failed' ? 'Failed' : 'Skipped',
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+            const skipped = result.results.filter((item) => item.status === 'skipped');
+            if (skipped.length > 0) {
+                printSyncNotice(context.println, `${skipped.length} Database View resource(s) were skipped; review plan warnings before retrying.`);
+            }
+        }
+        const failed = result.results.filter((item) => item.status === 'failed' || item.status === 'write-unverified');
+        if (failed.length > 0 || result.plan.globalBlockers.length > 0) {
+            const reasons = failed.map((item) => item.error || item.reason || item.stableKey).join('; ');
+            const blockers = result.plan.globalBlockers.join('; ');
+            throw new Error(`Database View push finished with ${failed.length} failed or unverified write(s) and ${result.plan.globalBlockers.length} global blocker(s): ${[reasons, blockers].filter(Boolean).join('; ')}`);
+        }
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildDatabaseViewsPlan({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Database View',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items,
+                warnings: [...plan.exclusions, ...plan.warnings],
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const drift = plan.items.filter((item) => item.status !== 'clean' && item.status !== 'orphan');
+            if (plan.blockers.length > 0 || plan.exclusions.length > 0 || plan.warnings.length > 0 || drift.length > 0) {
+                throw new Error(`Database View strict plan is not converged: ${drift.length} drift or incomplete item(s), ${plan.blockers.length} blocker(s), ${plan.warnings.length} warning(s), ${plan.exclusions.length} exclusion(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullDatabaseViewsToWorkspace({
+        client,
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+        strict: readBoolFlag(context.args, ['strict']),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+        return;
+    }
+    const output = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        output.push({ status: 'pulled', targetPath: pulled.targetPath });
+    }
+    for (const skipped of result.skipped) {
+        printSyncNotice(context.println, `${skipped.stableKey || skipped.name}: ${skipped.reason}`);
+        output.push({ status: 'skipped', targetPath: skipped.name, reason: skipped.reason });
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

package/dist/src/commands/endpoints.js

@@ -1,4 +1,118 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildEndpointsPlan, pullEndpointsToWorkspace, pushEndpoints } from "../resource-syncs/endpoint-sync.js";
+import { printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
 export async function handleEndpointsCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand === 'pull' || subcommand === 'plan' || subcommand === 'push') {
+        if (!readBoolFlag(context.args, ['all', 'a'])) {
+            throw new Error('Endpoint sync currently requires --all.');
+        }
+        const envName = readFlag(context.args, ['env']);
+        if (!envName) {
+            throw new Error('Missing --project <name>.');
+        }
+        if (envName === DEFAULT_ENV_NAME) {
+            throw new Error('Endpoint sync requires a named environment profile; "default" is not supported.');
+        }
+        const client = new RevoClient({ envName });
+        const stableKeyName = readProjectStableKeyName(context.cwd);
+        if (subcommand === 'push') {
+            if (readBoolFlag(context.args, ['prune'])) {
+                throw new Error('Endpoint prune is disabled until a reviewed deletion contract is introduced.');
+            }
+            if (!readBoolFlag(context.args, ['yes', 'y'])) {
+                if (!isInteractiveTerminal() || !await promptConfirm(`Push Endpoints to "${envName}"?`, false)) {
+                    throw new Error('Endpoint push requires confirmation. Re-run with --yes or use an interactive terminal.');
+                }
+            }
+            const startedAt = Date.now();
+            const result = await pushEndpoints({
+                client,
+                cwd: context.cwd,
+                envName,
+                stableKeyName,
+                force: readBoolFlag(context.args, ['force', 'f']),
+            });
+            if (readBoolFlag(context.args, ['json'])) {
+                context.print(result);
+            }
+            else {
+                for (const item of result.results) {
+                    const label = item.status === 'deployed' ? 'Deployed' : item.status === 'failed' ? 'Failed' : 'Skipped';
+                    printSyncStatus(context.println, {
+                        status: label,
+                        direction: 'push',
+                        targetPath: item.targetPath,
+                        reason: item.error || item.reason,
+                    });
+                }
+                printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+            }
+            const failed = result.results.filter((item) => item.status === 'failed');
+            if (failed.length > 0) {
+                throw new Error(`Endpoint push finished with ${failed.length} failure(s).`);
+            }
+            return;
+        }
+        if (subcommand === 'plan') {
+            const plan = await buildEndpointsPlan({ client, cwd: context.cwd, envName, stableKeyName });
+            if (readBoolFlag(context.args, ['json'])) {
+                context.print(plan);
+            }
+            else {
+                printSyncPlan(context.println, {
+                    title: 'Endpoint',
+                    environment: plan.env,
+                    counts: plan.counts,
+                    items: plan.items,
+                    warnings: plan.exclusions,
+                    blockers: plan.blockers,
+                });
+            }
+            if (readBoolFlag(context.args, ['strict'])) {
+                const drift = plan.items.filter((item) => !['clean', 'orphan', 'skipped'].includes(item.status));
+                if (plan.blockers.length > 0 || drift.length > 0) {
+                    throw new Error(`Endpoint strict plan is not converged: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+                }
+            }
+            return;
+        }
+        const startedAt = Date.now();
+        const result = await pullEndpointsToWorkspace({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName,
+            force: readBoolFlag(context.args, ['force', 'f']),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(result);
+            return;
+        }
+        const output = [];
+        for (const pulled of result.pulled) {
+            printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+            output.push({ status: 'pulled', targetPath: pulled.targetPath });
+        }
+        for (const skipped of result.skipped) {
+            printSyncStatus(context.println, {
+                status: 'Skipped',
+                direction: 'pull',
+                targetPath: skipped.targetPath,
+                reason: skipped.reason,
+            });
+            output.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+        }
+        printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+        return;
+    }
+    if (subcommand) {
+        throw new Error('Unknown endpoints command. Usage: revo endpoints [pull|plan|push] --all --project <name>');
+    }
     const endpoints = await context.client.listEndpoints();
     context.print(endpoints);
 }

package/dist/src/commands/env.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleEnvCommand(context: CommandContext): Promise<void>;