@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/env-sync.js

@@ -1,4 +1,4 @@
-import { hashPortableComponentSource, normalizePortableComponentSource, sanitizeComponentSource, } from "./component-lock.js";
+import { buildPortableComponentUpdatePayload, diffPortableComponentSource, hashPortableComponentSource, normalizePortableComponentSource, sanitizeComponentSource, } from "./component-lock.js";
 import { buildStableKey as buildComponentStableKey, DEFAULT_STABLE_KEY_NAME, NULL_CATEGORY_KEY, sanitizeUserMetadata, } from "./resource-metadata.js";
 export function normalizeKeyPart(value) {
     return (value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
@@ -69,10 +69,6 @@ export async function captureEnvSnapshot(client, envName, options = {}) {
         collisions,
     };
 }
-const PORTABLE_METADATA_FIELDS = ['name', 'category', 'desc', 'active', 'type', 'async'];
-function diffMetadataFields(source, target) {
-    return PORTABLE_METADATA_FIELDS.filter((field) => source[field] !== target[field]);
-}
 function diffElementKeys(source, target) {
     const sourceByKey = new Map(source.elements.map((element) => [element.key, element]));
     const targetByKey = new Map(target.elements.map((element) => [element.key, element]));
@@ -174,7 +170,7 @@ export function buildEnvSyncPlan(source, target, options) {
             items.push({ ...base, action: 'noop', reason: 'up to date' });
             continue;
         }
-        const changedFields = diffMetadataFields(sourceEntry.portable, targetEntry.portable);
+        const changedFields = diffPortableComponentSource(sourceEntry.component, targetEntry.component).configurationFields;
         const elementDiff = diffElementKeys(sourceEntry.portable, targetEntry.portable);
         items.push({
             ...base,
@@ -240,18 +236,6 @@ function buildCreatePayload(component) {
         elements: buildPortableElementPayload(component),
     };
 }
-function buildMetadataPayload(source, target, changedFields) {
-    if (!Number.isInteger(target.version)) {
-        throw new Error('target component version is required to update component metadata');
-    }
-    const payload = { version: target.version };
-    for (const field of PORTABLE_METADATA_FIELDS) {
-        if (changedFields.includes(field)) {
-            payload[field] = source[field];
-        }
-    }
-    return payload;
-}
 async function verifyAppliedComponent(targetClient, componentId, expectedHash) {
     const component = unwrapComponent(await targetClient.getComponent(componentId));
     return hashPortableComponentSource(component) === expectedHash;
@@ -300,7 +284,7 @@ async function applyPlanItem(targetClient, item, source, target, stableKeyName =
                 throw new Error('component disappeared from the snapshot');
             }
             if (item.changedFields && item.changedFields.length > 0) {
-                await targetClient.updateComponent(targetEntry.componentId, buildMetadataPayload(sourceEntry.portable, targetEntry.component, item.changedFields));
+                await targetClient.updateComponent(targetEntry.componentId, buildPortableComponentUpdatePayload(sourceEntry.component, targetEntry.component, item.changedFields));
             }
             const hasElementChanges = Boolean(item.addedElementKeys?.length || item.removedElementKeys?.length || item.changedElementKeys?.length);
             if (hasElementChanges) {

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

@@ -1,16 +1,20 @@
 import type { RevoClient } from './client.ts';
 import { type TrackedResource } from './tracked-resources.ts';
-import type { ComponentRecord } from './types.ts';
-export type MetadataBackfillAction = 'update' | 'skip' | 'failed';
+import type { ComponentRecord, DatabaseSchemaRecord, DatabaseViewRecord, EndpointRecord, EventRecord, GroupRecord, JobTemplateRecord, RoleGroupRecord, ScheduleRecord } from './types.ts';
+export type MetadataBackfillAction = 'update' | 'skip' | 'blocked' | 'failed';
+type MetadataBackfillResourceType = 'component' | 'endpoint' | 'group' | 'role-group' | 'job-template' | 'schedule' | 'event' | 'database-schema' | 'database-view';
+type MetadataResourceRecord = ComponentRecord | DatabaseSchemaRecord | DatabaseViewRecord | EndpointRecord | GroupRecord | RoleGroupRecord | JobTemplateRecord | ScheduleRecord | EventRecord;
 export type MetadataBackfillPlanItem = {
-    resourceType: 'component';
+    resourceType: MetadataBackfillResourceType;
     resourceId: string;
     name: string;
     category: string | null;
     action: Exclude<MetadataBackfillAction, 'failed'>;
-    metadataField: 'metadata';
+    metadataField: 'metadata' | 'definition[].metadata';
     stableKeyName: string;
     stableKey?: string;
+    columnName?: string;
+    columnDefinitionId?: string;
     reason: string;
 };
 export type MetadataBackfillPlan = {
@@ -21,26 +25,32 @@ export type MetadataBackfillPlan = {
     instance: string;
     stableKeyName: string;
     trackedResources: TrackedResource[];
+    force: boolean;
+    skipPartitions?: boolean;
     counts: Record<Exclude<MetadataBackfillAction, 'failed'>, number>;
+    blockers: string[];
     items: MetadataBackfillPlanItem[];
 };
 export type MetadataBackfillResult = {
-    resourceType: 'component';
+    resourceType: MetadataBackfillResourceType;
     resourceId: string;
     stableKey?: string;
+    columnName?: string;
     action: MetadataBackfillAction;
     error?: string;
 };
 export declare function generateStableKeySuffix(bytes?: number): string;
-export declare function buildGeneratedStableKey(component: ComponentRecord): string;
+export declare function buildGeneratedStableKey(resource: MetadataResourceRecord): string;
 export declare function buildMetadataBackfillPlan(input: {
     client: RevoClient;
     envName: string;
     stableKeyName: string;
     trackedResources: TrackedResource[];
     force?: boolean;
+    skipPartitions?: boolean;
 }): Promise<MetadataBackfillPlan>;
 export declare function applyMetadataBackfillPlan(input: {
     client: RevoClient;
     plan: MetadataBackfillPlan;
 }): Promise<MetadataBackfillResult[]>;
+export {};