Fixing isActive bug with api revisions

Author: EMaher

src/services/api-publisher.ts

@@ -57,7 +57,22 @@ export async function publishApi(
     }
 
     // Step 2: Find and publish revisions in numeric order
-    await publishApiRevisions(client, store, context, descriptor, config);
+    const publishedRevisionCount = await publishApiRevisions(client, store, context, descriptor, config);
+
+    // Step 2b: Align root API only when source marks it as current.
+    // Source of truth is properties.isCurrent in root apiInformation.json.
+    if (publishedRevisionCount > 0 && rootResult.isCurrent === true) {
+      const alignResult = await alignActiveRevisionWithSource(
+        client,
+        store,
+        context,
+        descriptor,
+        config
+      );
+      if (alignResult.status !== 'success') {
+        return alignResult;
+      }
+    }
 
     // Step 3: Publish child resources in parallel
     // When a spec was imported, operations and schemas are auto-created by APIM
@@ -105,6 +120,11 @@ function getImportFormat(specFormat: string, _apiType?: string): string | undefi
 interface RootApiResult {
   status: 'success' | 'skipped';
   specImported: boolean;
+  isCurrent?: boolean;
+}
+
+interface PublishRootApiOptions {
+  includeSpecification?: boolean;
 }
 
 /**
@@ -118,7 +138,8 @@ async function publishRootApi(
   store: IArtifactStore,
   context: ApimServiceContext,
   descriptor: ResourceDescriptor,
-  config: PublishConfig
+  config: PublishConfig,
+  options?: PublishRootApiOptions
 ): Promise<RootApiResult & ResourcePublishResult> {
   let json = await store.readResource(config.sourceDir, descriptor);
   if (!json) {
@@ -132,10 +153,14 @@ async function publishRootApi(
 
   // Apply overrides
   json = applyOverrides(descriptor, json, config.overrides);
+  const isCurrent = getApiIsCurrent(json);
 
   // Try to read the specification file for this API
   let specImported = false;
-  const specResult = await store.readContent(config.sourceDir, descriptor, 'specification');
+  const includeSpecification = options?.includeSpecification ?? true;
+  const specResult = includeSpecification
+    ? await store.readContent(config.sourceDir, descriptor, 'specification')
+    : undefined;
   if (specResult) {
     const properties = json.properties as Record<string, unknown> | undefined;
     const apiType = properties?.type as string | undefined;
@@ -180,9 +205,26 @@ async function publishRootApi(
     status: 'success',
     action: 'put',
     specImported,
+    isCurrent,
   };
 }
 
+async function alignActiveRevisionWithSource(
+  client: IApimClient,
+  store: IArtifactStore,
+  context: ApimServiceContext,
+  descriptor: ResourceDescriptor,
+  config: PublishConfig
+): Promise<RootApiResult & ResourcePublishResult> {
+  logger.debug(
+    `Source marks "${getNamePart(descriptor.nameParts, 0)}" as current; re-applying root metadata to align active revision`
+  );
+
+  return publishRootApi(client, store, context, descriptor, config, {
+    includeSpecification: false,
+  });
+}
+
 /**
  * Find and publish API revisions in numeric order
  */
@@ -192,7 +234,7 @@ async function publishApiRevisions(
   context: ApimServiceContext,
   apiDescriptor: ResourceDescriptor,
   config: PublishConfig
-): Promise<void> {
+): Promise<number> {
   // List all resources from store
   const allDescriptors = await store.listResources(config.sourceDir);
 
@@ -214,6 +256,8 @@ async function publishApiRevisions(
   for (const revDescriptor of sortedRevisions) {
     await publishResource(client, store, context, revDescriptor, config);
   }
+
+  return sortedRevisions.length;
 }
 
 /**
@@ -398,3 +442,9 @@ function extractRevisionNumber(apiName: string): number {
   const match = /;rev=(\d+)/.exec(apiName);
   return match ? parseInt(match[1], 10) : 0;
 }
+
+function getApiIsCurrent(json: Record<string, unknown>): boolean | undefined {
+  const properties = json.properties as Record<string, unknown> | undefined;
+  const isCurrent = properties?.isCurrent;
+  return typeof isCurrent === 'boolean' ? isCurrent : undefined;
+}

tests/unit/services/api-publisher.test.ts

@@ -207,6 +207,107 @@ describe('api-publisher', () => {
       expect(calls[0][3].nameParts[0]).toBe('orders-api;rev=1');
       expect(calls[1][3].nameParts[0]).toBe('orders-api;rev=2');
       expect(calls[2][3].nameParts[0]).toBe('orders-api;rev=3');
+
+      // Root API is only replayed when source marks it current (isCurrent=true).
+      // Default mock root payload has no isCurrent flag, so only the initial PUT runs.
+      expect(client.putResource).toHaveBeenCalledTimes(1);
+    });
+
+    it('should replay root API without re-importing specification after revisions', async () => {
+      const client = createMockClient();
+      const revisions = [{ type: ResourceType.Api, nameParts: ['orders-api;rev=2'] }];
+      const store = createMockStore(revisions);
+      store.readResource.mockResolvedValue({
+        name: 'orders-api',
+        properties: { path: 'orders', isCurrent: true },
+      });
+      store.readContent.mockResolvedValue({
+        content: 'openapi: "3.0.0"',
+        format: 'yaml',
+      });
+
+      const apiDescriptor: ResourceDescriptor = {
+        type: ResourceType.Api,
+        nameParts: ['orders-api'],
+      };
+
+      await publishApi(client, store, testContext, apiDescriptor, testConfig);
+
+      // Spec is only read/injected on the first root publish.
+      expect(store.readContent).toHaveBeenCalledTimes(1);
+      expect(client.putResource).toHaveBeenCalledTimes(2);
+
+      const firstPayload = client.putResource.mock.calls[0][2] as Record<string, unknown>;
+      const secondPayload = client.putResource.mock.calls[1][2] as Record<string, unknown>;
+      const firstProps = firstPayload.properties as Record<string, unknown>;
+      const secondProps = secondPayload.properties as Record<string, unknown>;
+
+      expect(firstProps).toHaveProperty('format', 'openapi');
+      expect(firstProps).toHaveProperty('value', 'openapi: "3.0.0"');
+      expect(secondProps).not.toHaveProperty('format');
+      expect(secondProps).not.toHaveProperty('value');
+    });
+
+    it('should not replay root API when source root is not current', async () => {
+      const client = createMockClient();
+      const revisions = [{ type: ResourceType.Api, nameParts: ['orders-api;rev=2'] }];
+      const store = createMockStore(revisions);
+      store.readResource.mockResolvedValue({
+        name: 'orders-api',
+        properties: {
+          isCurrent: false,
+          apiRevision: '2',
+          serviceUrl: 'https://src-revisioned-backend-v2.example.com/api',
+        },
+      });
+
+      const apiDescriptor: ResourceDescriptor = {
+        type: ResourceType.Api,
+        nameParts: ['orders-api'],
+      };
+
+      await publishApi(client, store, testContext, apiDescriptor, testConfig);
+
+      // Root is not current in source, so no root alignment replay is performed.
+      expect(client.putResource).toHaveBeenCalledTimes(1);
+      const alignedPayload = client.putResource.mock.calls[0][2] as Record<string, unknown>;
+      const alignedProps = alignedPayload.properties as Record<string, unknown>;
+
+      expect(alignedProps).toHaveProperty('apiRevision', '2');
+      expect(alignedProps).toHaveProperty('serviceUrl', 'https://src-revisioned-backend-v2.example.com/api');
+      expect(alignedProps).not.toHaveProperty('format');
+      expect(alignedProps).not.toHaveProperty('value');
+    });
+
+    it('should align active revision from source when active revision is 1', async () => {
+      const client = createMockClient();
+      const revisions = [{ type: ResourceType.Api, nameParts: ['orders-api;rev=2'] }];
+      const store = createMockStore(revisions);
+      store.readResource.mockResolvedValue({
+        name: 'orders-api',
+        properties: {
+          isCurrent: true,
+          apiRevision: '1',
+          serviceUrl: 'https://src-revisioned-backend.example.com/api',
+        },
+      });
+
+      const apiDescriptor: ResourceDescriptor = {
+        type: ResourceType.Api,
+        nameParts: ['orders-api'],
+      };
+
+      await publishApi(client, store, testContext, apiDescriptor, testConfig);
+
+      // Second root PUT is the explicit active-revision alignment pass.
+      expect(client.putResource).toHaveBeenCalledTimes(2);
+      const alignedPayload = client.putResource.mock.calls[1][2] as Record<string, unknown>;
+      const alignedProps = alignedPayload.properties as Record<string, unknown>;
+
+      expect(alignedProps).toHaveProperty('apiRevision', '1');
+      expect(alignedProps).toHaveProperty('serviceUrl', 'https://src-revisioned-backend.example.com/api');
+      expect(alignedProps).not.toHaveProperty('format');
+      expect(alignedProps).not.toHaveProperty('value');
     });
 
     it('should skip non-matching revisions when filtering by API name', async () => {