@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/project.d.ts

@@ -52,6 +52,7 @@ export type ProjectSyncInput = {
     libVersion: string;
     hash: string;
     lastSyncAt: string;
+    authProfile?: string;
     componentIdentity?: ComponentIdentityConfig;
     trackedResources?: TrackedResource[];
 };
@@ -80,6 +81,7 @@ export declare function buildProjectMetadata(input: {
     baseUrl: string;
     bundle: EditorTypesBundle;
     now?: Date;
+    authProfile?: string;
 }): {
     schemaVersion: 1;
     endpoint: string;

package/dist/src/project.js

@@ -220,13 +220,7 @@ export function resolveProjectInvocation(args) {
     const trackedResourceArgs = readResourceSelectionArgs(args);
     const trackedResources = trackedResourceArgs ? normalizeTrackedResources(trackedResourceArgs) : undefined;
     if (!first) {
-        return {
-            action: 'init',
-            extraArgs: [],
-            identityMode,
-            stableKeyName,
-            ...(trackedResources ? { trackedResources } : {}),
-        };
+        throw new Error('Missing project action. Use `revo project init [path]` or `revo project update [path]`.');
     }
     if (first === 'init' || first === 'update') {
         return {
@@ -241,14 +235,7 @@ export function resolveProjectInvocation(args) {
     if (first === 'switch') {
         throw new Error('`revo project switch` was removed because credentials are no longer instance-scoped.');
     }
-    return {
-        action: 'init',
-        targetArg: first,
-        extraArgs: second ? [second, ...rest] : rest,
-        identityMode,
-        stableKeyName,
-        ...(trackedResources ? { trackedResources } : {}),
-    };
+    throw new Error(`Unknown project action "${first}". Use \`revo project init [path]\` or \`revo project update [path]\`.`);
 }
 function normalizeWorkspaceDirectory(projectRoot, workspaceRoot) {
     const relative = path.relative(projectRoot, workspaceRoot).split(path.sep).join('/');
@@ -361,7 +348,7 @@ export function buildProjectMetadata(input) {
     return {
         schemaVersion: 1,
         endpoint: bundle.endpoint || buildEditorEndpoint(baseUrl),
-        authProfile: 'default',
+        authProfile: input.authProfile || 'default',
         apiVersion: getRequiredMetadataValue(bundle, 'apiVersion'),
         libVersion: getRequiredMetadataValue(bundle, 'libVersion'),
         hash: getRequiredMetadataValue(bundle, 'hash'),
@@ -510,7 +497,7 @@ export function syncProjectFiles(layoutOrTargetDir, input) {
     writeJsonFile(metadataFile, {
         schemaVersion: 1,
         endpoint: input.endpoint,
-        authProfile: 'default',
+        authProfile: input.authProfile || 'default',
         apiVersion: input.apiVersion,
         libVersion: input.libVersion,
         hash: input.hash,

package/dist/src/prompt.js

@@ -1,4 +1,5 @@
 import readline from 'node:readline/promises';
+import { Writable } from 'node:stream';
 export function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -23,32 +24,23 @@ export async function promptSecret(message) {
     if (!isInteractiveTerminal()) {
         return '';
     }
+    const mutedOutput = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout,
+        output: mutedOutput,
         terminal: true,
     });
-    let muted = true;
-    const originalWriteToOutput = rl._writeToOutput.bind(rl);
-    rl._writeToOutput = (value) => {
-        if (!muted) {
-            originalWriteToOutput(value);
-            return;
-        }
-        if (value.startsWith(`${message}: `)) {
-            originalWriteToOutput(value);
-            return;
-        }
-        // Preserve terminal editing/paste behavior while masking visible content.
-        originalWriteToOutput('*');
-    };
     try {
-        const answer = await rl.question(`${message}: `);
-        return answer;
+        process.stdout.write(`${message}: `);
+        return await rl.question('');
     }
     finally {
-        muted = false;
         rl.close();
+        process.stdout.write('\n');
     }
 }
 export async function promptConfirm(message, defaultValue = false) {

package/dist/src/resource-metadata.d.ts

@@ -8,6 +8,7 @@ export type ComponentIdentityConfig = {
 };
 export declare const COMPONENT_IDENTITY_BY_ID: ComponentIdentityConfig;
 export declare const DEFAULT_COMPONENT_IDENTITY: ComponentIdentityConfig;
+export declare function normalizeStableKeyValue(value: string): string;
 export declare function normalizeStableKeyName(value: string | null | undefined): string;
 export declare function normalizeComponentIdentityMode(value: string | null | undefined): ComponentIdentityMode;
 export declare function normalizeComponentIdentityConfig(value: Partial<ComponentIdentityConfig> | null | undefined, fallback?: ComponentIdentityConfig): ComponentIdentityConfig;

package/dist/src/resource-metadata.js

@@ -16,6 +16,9 @@ function readString(value) {
 function normalizeKeyPart(value) {
     return (value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
 }
+export function normalizeStableKeyValue(value) {
+    return normalizeKeyPart(value);
+}
 export function normalizeStableKeyName(value) {
     const normalized = (value || DEFAULT_STABLE_KEY_NAME).trim();
     if (!normalized) {

package/dist/src/resource-syncs/database-schema-sync.d.ts

@@ -0,0 +1,117 @@
+import type { DatabaseSchemaStatsRecord, RevoClient } from '../client.ts';
+export declare const DATABASE_SCHEMAS_DIRECTORY = "DatabaseSchemas";
+export declare const DATABASE_SCHEMA_MANIFEST_FILE = "database-schema.json";
+type PortableDefinition = Record<string, unknown>;
+export type DatabaseSchemaManifest = {
+    kind: 'database-schema' | 'database-partition';
+    stableKey: string;
+    name: string;
+    category?: string | null;
+    description?: string;
+    metadata: Record<string, unknown>;
+    type?: string;
+    definition?: PortableDefinition[];
+    partition?: Record<string, unknown>;
+    parentStableKey?: string;
+    migration?: {
+        foreignReferences: 'manual';
+    };
+};
+export type DatabaseSchemaPullResult = {
+    pulled: Array<{
+        manifest: DatabaseSchemaManifest;
+        targetPath: string;
+    }>;
+    pruned: Array<{
+        stableKey: string;
+        targetPath: string;
+    }>;
+    skipped: Array<{
+        targetPath: string;
+        reason: string;
+    }>;
+    diagnostics: Array<{
+        stableKey: string;
+        audit?: unknown;
+        acl?: unknown;
+        tags?: unknown;
+    }>;
+};
+export type DatabaseSchemaPlanStatus = 'clean' | 'create' | 'safe-update' | 'remote-changed' | 'conflict' | 'missing-lock' | 'orphan-root' | 'orphan-partition' | 'delete-partition' | 'previously-deleted-partition' | 'replacement-requires-two-phases' | 'unmanaged' | 'collision' | 'reconciled' | 'manual-schema-migration-required' | 'access-policy-required';
+export type DatabaseSchemaChange = {
+    kind: 'field-changed' | 'immutable-field' | 'column-added' | 'column-removed' | 'column-changed' | 'column-renamed' | 'column-stable-key-missing' | 'database-view-dependency' | 'column-order' | 'foreign-reference' | 'audit-trigger-rebuild';
+    field: string;
+    risk: 'safe' | 'manual' | 'operational';
+    before?: unknown;
+    after?: unknown;
+    column?: string;
+    hint: string;
+};
+export type DatabaseSchemaPlanItem = {
+    status: DatabaseSchemaPlanStatus;
+    stableKey?: string;
+    name: string;
+    kind?: DatabaseSchemaManifest['kind'];
+    parentStableKey?: string;
+    reason?: string;
+    changedFields?: string[];
+    changes?: DatabaseSchemaChange[];
+    hints: string[];
+    desiredHash?: string;
+    currentHash?: string;
+    baselineHash?: string;
+    stats?: DatabaseSchemaStatsRecord['size'];
+};
+export type DatabaseSchemasPlan = {
+    resourceType: 'database-schema';
+    env: string;
+    withStats: boolean;
+    skipPartitions: boolean;
+    counts: Record<DatabaseSchemaPlanStatus, number>;
+    blockers: string[];
+    warnings: string[];
+    exclusions: string[];
+    items: DatabaseSchemaPlanItem[];
+};
+export type DatabaseSchemaPushResult = {
+    stableKey: string;
+    action: 'create' | 'update' | 'reconcile' | 'delete' | 'skipped';
+    status: 'deployed' | 'skipped' | 'failed' | 'write-unverified';
+    targetPath: string;
+    reason?: string;
+    error?: string;
+};
+export declare function hashPortableDatabaseSchema(manifest: DatabaseSchemaManifest): string;
+export declare function buildDatabaseSchemasPlan(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    withStats?: boolean;
+    skipPartitions?: boolean;
+}): Promise<DatabaseSchemasPlan>;
+export declare function pullDatabaseSchemasToWorkspace(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    force?: boolean;
+    strict?: boolean;
+    pruneOrphans?: boolean;
+}): Promise<DatabaseSchemaPullResult>;
+export declare function pushDatabaseSchemas(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    stableKey?: string;
+    force?: boolean;
+    prunePartitions?: boolean;
+    prunePartitionsConfirmed?: boolean;
+    pruneOrphans?: boolean;
+    pruneOrphansConfirmed?: boolean;
+}): Promise<{
+    plan: DatabaseSchemasPlan;
+    results: DatabaseSchemaPushResult[];
+}>;
+export {};