@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/component-lock.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { REVO_PROJECT_DIR } from "./project.js";
+import { COMPONENT_IDENTITY_BY_ID, normalizeComponentIdentityConfig, readComponentIdentityValue, sameComponentIdentityConfig, } from "./resource-metadata.js";
 import { readJsonFile, writeJsonFile } from "./utils.js";
 export const REVO_LOCK_FILE = path.join(REVO_PROJECT_DIR, 'revo.lock.json');
 const VOLATILE_COMPONENT_FIELDS = new Set([
@@ -21,6 +22,9 @@ const VOLATILE_COMPONENT_FIELDS = new Set([
     'hash',
     'remoteHash',
 ]);
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 function normalizeValue(value, fallback = null) {
     return value ?? fallback;
 }
@@ -63,10 +67,10 @@ export function normalizeComponentSource(component) {
         async: Boolean(source.async),
         elements: [...(source.elements || [])]
             .map((element) => ({
-            key: element.key,
+            key: typeof element.key === 'string' ? element.key : '',
             desc: normalizeValue(element.desc),
             hidden: Boolean(element.hidden),
-            order: element.order,
+            order: Number.isFinite(Number(element.order)) ? Number(element.order) : 0,
             details: element.details ?? '',
         }))
             .sort((left, right) => left.order - right.order || left.key.localeCompare(right.key)),
@@ -75,6 +79,51 @@ export function normalizeComponentSource(component) {
 export function hashComponentSource(component) {
     return hashStable(normalizeComponentSource(component));
 }
+// componentId is instance-local, so comparing components across two RevoEngine
+// environments must project it away; element componentElementIds are already
+// excluded by normalizeComponentSource.
+export function normalizePortableComponentSource(component) {
+    const { componentId, ...portable } = normalizeComponentSource(component);
+    return portable;
+}
+export function hashPortableComponentSource(component) {
+    return hashStable(normalizePortableComponentSource(component));
+}
+export const PORTABLE_COMPONENT_CONFIG_FIELDS = [
+    'name',
+    'category',
+    'desc',
+    'active',
+    'type',
+    'async',
+];
+export function diffPortableComponentSource(source, target) {
+    const sourcePortable = normalizePortableComponentSource(source);
+    const targetPortable = normalizePortableComponentSource(target);
+    const configurationFields = PORTABLE_COMPONENT_CONFIG_FIELDS.filter((field) => sourcePortable[field] !== targetPortable[field]);
+    const elementsChanged = hashStable(sourcePortable.elements) !== hashStable(targetPortable.elements);
+    return {
+        configurationFields,
+        elementsChanged,
+        changedFields: [
+            ...configurationFields,
+            ...(elementsChanged ? ['elements'] : []),
+        ],
+    };
+}
+export function buildPortableComponentUpdatePayload(source, target, changedFields) {
+    if (!Number.isInteger(target.version)) {
+        throw new Error('target component version is required to update component configuration');
+    }
+    const sourcePortable = normalizePortableComponentSource(source);
+    const payload = { version: target.version };
+    for (const field of PORTABLE_COMPONENT_CONFIG_FIELDS) {
+        if (changedFields.includes(field)) {
+            payload[field] = sourcePortable[field];
+        }
+    }
+    return payload;
+}
 export function getLockPath(projectRoot) {
     return path.join(projectRoot, REVO_LOCK_FILE);
 }
@@ -82,35 +131,349 @@ export function readComponentLock(projectRoot) {
     const lockPath = getLockPath(projectRoot);
     if (!fs.existsSync(lockPath)) {
         return {
-            schemaVersion: 1,
+            schemaVersion: 2,
+            componentIdentity: COMPONENT_IDENTITY_BY_ID,
             components: {},
+            groups: {},
+            roleGroups: {},
+            jobTemplates: {},
+            schedules: {},
+            events: {},
+            endpoints: {},
+            databaseSchemas: {},
+            databaseViews: {},
         };
     }
     const raw = readJsonFile(lockPath);
+    const componentIdentity = normalizeComponentIdentityConfig(raw.componentIdentity, COMPONENT_IDENTITY_BY_ID);
+    const components = Object.fromEntries(Object.entries(raw.components && typeof raw.components === 'object' ? raw.components : {})
+        .map(([key, entry]) => {
+        const remoteComponentId = String(entry.remoteComponentId || entry.componentId || key);
+        const identityMode = entry.identityMode || componentIdentity.mode;
+        return [key, {
+                ...entry,
+                identityMode,
+                ...(identityMode === 'stableKey'
+                    ? {
+                        metadataProperty: entry.metadataProperty || componentIdentity.metadataProperty,
+                        stableKey: entry.stableKey || key,
+                    }
+                    : {}),
+                componentId: String(entry.componentId || remoteComponentId),
+                remoteComponentId,
+                ...(entry.environments && typeof entry.environments === 'object'
+                    ? {
+                        environments: Object.fromEntries(Object.entries(entry.environments)
+                            .filter(([, baseline]) => (typeof baseline.remoteComponentId === 'string'
+                            && typeof baseline.remoteHash === 'string'
+                            && typeof baseline.syncedAt === 'string'))
+                            .map(([envName, baseline]) => [envName, {
+                                remoteComponentId: String(baseline.remoteComponentId),
+                                remoteVersion: typeof baseline.remoteVersion === 'number' ? baseline.remoteVersion : null,
+                                remoteHash: String(baseline.remoteHash),
+                                syncedAt: String(baseline.syncedAt),
+                            }])),
+                    }
+                    : {}),
+            }];
+    }));
     return {
-        schemaVersion: 1,
-        components: raw.components && typeof raw.components === 'object' ? raw.components : {},
+        schemaVersion: 2,
+        componentIdentity,
+        components,
+        groups: Object.fromEntries(Object.entries(raw.groups && typeof raw.groups === 'object' ? raw.groups : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...((isRecord(entry.owner) && entry.owner.type === 'group' && typeof entry.owner.stableKey === 'string')
+                    ? { owner: { type: 'group', stableKey: entry.owner.stableKey } }
+                    : (isRecord(entry.owner) && entry.owner.type === 'manual-user')
+                        ? { owner: { type: 'manual-user' } }
+                        : (isRecord(entry.owner) && entry.owner.type === 'unresolved' && typeof entry.owner.reason === 'string')
+                            ? { owner: { type: 'unresolved', reason: entry.owner.reason } }
+                            : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        roleGroups: Object.fromEntries(Object.entries(raw.roleGroups && typeof raw.roleGroups === 'object' ? raw.roleGroups : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        jobTemplates: Object.fromEntries(Object.entries(raw.jobTemplates && typeof raw.jobTemplates === 'object' ? raw.jobTemplates : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...((isRecord(entry.migration) && (entry.migration.componentBinding === 'pinned-unsupported'
+                    || entry.migration.executionPrincipal === 'excluded')) ? {
+                    migration: {
+                        ...(entry.migration.componentBinding === 'pinned-unsupported' ? { componentBinding: 'pinned-unsupported' } : {}),
+                        ...(entry.migration.executionPrincipal === 'excluded' ? { executionPrincipal: 'excluded' } : {}),
+                    },
+                } : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        schedules: Object.fromEntries(Object.entries(raw.schedules && typeof raw.schedules === 'object' ? raw.schedules : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        events: Object.fromEntries(Object.entries(raw.events && typeof raw.events === 'object' ? raw.events : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        endpoints: Object.fromEntries(Object.entries(raw.endpoints && typeof raw.endpoints === 'object' ? raw.endpoints : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        databaseSchemas: Object.fromEntries(Object.entries(raw.databaseSchemas && typeof raw.databaseSchemas === 'object' ? raw.databaseSchemas : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...(typeof entry.sourceRestricted === 'boolean' ? { sourceRestricted: entry.sourceRestricted } : {}),
+                ...(typeof entry.parentStableKey === 'string' ? { parentStableKey: entry.parentStableKey } : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        ...(typeof baseline.tombstone?.deletedAt === 'string' && typeof baseline.tombstone.parentStableKey === 'string'
+                            ? { tombstone: {
+                                    deletedAt: baseline.tombstone.deletedAt,
+                                    parentStableKey: baseline.tombstone.parentStableKey,
+                                } }
+                            : {}),
+                    }])),
+            }])),
+        databaseViews: Object.fromEntries(Object.entries(raw.databaseViews && typeof raw.databaseViews === 'object' ? raw.databaseViews : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
     };
 }
 export function writeComponentLock(projectRoot, lock) {
     const sortedComponents = Object.fromEntries(Object.entries(lock.components).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedRoleGroups = Object.fromEntries(Object.entries(lock.roleGroups).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedGroups = Object.fromEntries(Object.entries(lock.groups || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedJobTemplates = Object.fromEntries(Object.entries(lock.jobTemplates || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedSchedules = Object.fromEntries(Object.entries(lock.schedules || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedEvents = Object.fromEntries(Object.entries(lock.events || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedEndpoints = Object.fromEntries(Object.entries(lock.endpoints || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedDatabaseSchemas = Object.fromEntries(Object.entries(lock.databaseSchemas || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedDatabaseViews = Object.fromEntries(Object.entries(lock.databaseViews || {}).sort(([left], [right]) => left.localeCompare(right)));
     writeJsonFile(getLockPath(projectRoot), {
-        schemaVersion: 1,
+        schemaVersion: 2,
+        componentIdentity: normalizeComponentIdentityConfig(lock.componentIdentity),
         components: sortedComponents,
+        ...(Object.keys(sortedGroups).length > 0 ? { groups: sortedGroups } : {}),
+        roleGroups: sortedRoleGroups,
+        jobTemplates: sortedJobTemplates,
+        ...(Object.keys(sortedSchedules).length > 0 ? { schedules: sortedSchedules } : {}),
+        ...(Object.keys(sortedEvents).length > 0 ? { events: sortedEvents } : {}),
+        ...(Object.keys(sortedEndpoints).length > 0 ? { endpoints: sortedEndpoints } : {}),
+        ...(Object.keys(sortedDatabaseSchemas).length > 0 ? { databaseSchemas: sortedDatabaseSchemas } : {}),
+        ...(Object.keys(sortedDatabaseViews).length > 0 ? { databaseViews: sortedDatabaseViews } : {}),
     });
 }
-export function upsertComponentLockEntry(projectRoot, entry) {
+export function componentLockKey(identity, component) {
+    return readComponentIdentityValue(component, identity);
+}
+export function componentLockMatchesIdentity(lock, identity) {
+    return sameComponentIdentityConfig(lock.componentIdentity, identity);
+}
+export function getComponentLockEntry(lock, identity, component, environmentName) {
+    if (!componentLockMatchesIdentity(lock, identity)) {
+        return null;
+    }
+    const key = componentLockKey(identity, component);
+    const entry = key ? lock.components[key] || null : null;
+    if (!entry || !environmentName) {
+        return entry;
+    }
+    const baseline = entry.environments?.[environmentName];
+    if (!baseline) {
+        return null;
+    }
+    return {
+        ...entry,
+        remoteComponentId: baseline.remoteComponentId,
+        remoteVersion: baseline.remoteVersion,
+        remoteHash: baseline.remoteHash,
+        pulledAt: baseline.syncedAt,
+    };
+}
+export function getComponentLockEntries(lock, identity, environmentName) {
+    if (!componentLockMatchesIdentity(lock, identity)) {
+        return {};
+    }
+    if (!environmentName) {
+        return lock.components;
+    }
+    return Object.fromEntries(Object.entries(lock.components).flatMap(([key, entry]) => {
+        const baseline = entry.environments?.[environmentName];
+        if (!baseline) {
+            return [];
+        }
+        return [[key, {
+                    ...entry,
+                    remoteComponentId: baseline.remoteComponentId,
+                    remoteVersion: baseline.remoteVersion,
+                    remoteHash: baseline.remoteHash,
+                    pulledAt: baseline.syncedAt,
+                }]];
+    }));
+}
+export function upsertComponentLockEntry(projectRoot, entry, identity = COMPONENT_IDENTITY_BY_ID, environmentName) {
+    const normalizedIdentity = normalizeComponentIdentityConfig(identity);
     const lock = readComponentLock(projectRoot);
-    const existing = lock.components[entry.componentId];
+    if (!componentLockMatchesIdentity(lock, normalizedIdentity)) {
+        lock.componentIdentity = normalizedIdentity;
+        lock.components = {};
+    }
+    const remoteComponentId = entry.remoteComponentId || entry.componentId;
+    const key = normalizedIdentity.mode === 'stableKey'
+        ? entry.stableKey
+        : remoteComponentId;
+    if (!key) {
+        throw new Error(`Cannot write component lock entry without ${normalizedIdentity.mode === 'stableKey' ? normalizedIdentity.metadataProperty : 'componentId'}.`);
+    }
+    const normalizedEntry = {
+        ...entry,
+        identityMode: normalizedIdentity.mode,
+        remoteComponentId,
+        ...(normalizedIdentity.mode === 'stableKey'
+            ? {
+                metadataProperty: normalizedIdentity.metadataProperty,
+                stableKey: key,
+            }
+            : {}),
+    };
+    const existing = lock.components[key];
+    const storedEntry = environmentName
+        ? {
+            ...normalizedEntry,
+            remoteComponentId: existing?.remoteComponentId || normalizedEntry.remoteComponentId,
+            remoteVersion: existing?.remoteVersion ?? normalizedEntry.remoteVersion,
+            remoteHash: existing?.remoteHash || normalizedEntry.remoteHash,
+            environments: {
+                ...existing?.environments,
+                [environmentName]: {
+                    remoteComponentId: normalizedEntry.remoteComponentId,
+                    remoteVersion: normalizedEntry.remoteVersion,
+                    remoteHash: normalizedEntry.remoteHash,
+                    syncedAt: normalizedEntry.pulledAt,
+                },
+            },
+        }
+        : {
+            ...normalizedEntry,
+            ...(existing?.environments ? { environments: existing.environments } : {}),
+        };
     if (existing
-        && existing.componentName === entry.componentName
-        && existing.category === entry.category
-        && existing.path === entry.path
-        && existing.remoteVersion === entry.remoteVersion
-        && existing.remoteHash === entry.remoteHash
-        && existing.sourceHash === entry.sourceHash) {
+        && existing.identityMode === storedEntry.identityMode
+        && existing.metadataProperty === storedEntry.metadataProperty
+        && existing.stableKey === storedEntry.stableKey
+        && existing.componentId === storedEntry.componentId
+        && existing.remoteComponentId === storedEntry.remoteComponentId
+        && existing.componentName === storedEntry.componentName
+        && existing.category === storedEntry.category
+        && existing.path === storedEntry.path
+        && existing.remoteVersion === storedEntry.remoteVersion
+        && existing.remoteHash === storedEntry.remoteHash
+        && existing.sourceHash === storedEntry.sourceHash
+        && JSON.stringify(existing.environments || {}) === JSON.stringify(storedEntry.environments || {})) {
         return;
     }
-    lock.components[entry.componentId] = entry;
+    lock.componentIdentity = normalizedIdentity;
+    lock.components[key] = storedEntry;
     writeComponentLock(projectRoot, lock);
 }

package/dist/src/config.d.ts

@@ -4,14 +4,24 @@ export type RuntimeConfig = {
     baseUrl: string;
     instance: string;
     token: string;
+    production?: true;
 };
 export type RuntimeConfigOptions = {
     baseUrl?: string;
     instance?: string;
     token?: string;
+    envName?: string;
+};
+export type StoredEnvironmentProfile = {
+    baseUrl: string;
+    token: string;
+    instance?: string;
+    production?: true;
 };
 type StoredConfig = Omit<RuntimeConfig, 'instance'> & {
     instance?: string;
+    environments?: Record<string, StoredEnvironmentProfile>;
+    activeEnvironment?: string;
 };
 export type AuthValidationState = {
     key: string;
@@ -45,11 +55,21 @@ export declare function loadStoredConfigIndex(): {
 export declare function loadStoredConfig(options?: {
     allowLegacy?: boolean;
 }): StoredConfig;
+export declare function listEnvironmentProfiles(): Record<string, StoredEnvironmentProfile>;
+export declare function getEnvironmentProfile(name: string): StoredEnvironmentProfile | null;
+export declare const DEFAULT_ENV_NAME = "default";
+export declare function getActiveEnvironmentName(): string;
+export declare function setActiveEnvironmentName(name: string): void;
+export declare function saveEnvironmentProfile(name: string, profile: StoredEnvironmentProfile, options?: {
+    activate?: boolean;
+}): void;
+export declare function removeEnvironmentProfile(name: string): boolean;
 export declare function buildAuthValidationKey(runtime: RuntimeConfigOptions): string;
 export declare function readAuthValidationState(key?: string): AuthValidationState;
 export declare function saveAuthValidationState(state: AuthValidationState): void;
 export declare function clearAuthValidationState(key?: string): void;
 export declare function resolveRuntimeConfig(options?: RuntimeConfigOptions): {
+    production?: true | undefined;
     baseUrl: string;
     instance: string;
     token: string;