add cleanup to auto-generated subscriptions. matching apiops behavior

Author: EMaher

.gitignore

@@ -40,7 +40,7 @@ Desktop.ini
 
 # Files for integration tests
 tests/integration/all-resource-types/logs/**
-tests/integration/all-resource-types/extracted-artifacts/**
+tests/integration/all-resource-types/extracted-artifacts*/**
 tests/integration/all-resource-types/target-apim.json
 tests/integration/all-resource-types/source-apim.json
 tests/integration/all-resource-types/source-apim-post-activation.bicep

src/services/product-publisher.ts

@@ -13,6 +13,7 @@ import { ResourceType } from '../models/resource-types.js';
 import { publishResource, type ResourcePublishResult } from './resource-publisher.js';
 import { logger } from '../lib/logger.js';
 import { getNamePart } from '../lib/resource-path.js';
+import { parseArmUri } from '../lib/resource-uri.js';
 
 /**
  * Publish a Product with all its associations (APIs, Groups, Tags).
@@ -27,13 +28,18 @@ export async function publishProduct(
 ): Promise<ResourcePublishResult> {
   try {
     const productName = getNamePart(descriptor.nameParts, 0);
+    const productExisted = (await client.getResource(context, descriptor)) !== undefined;
 
     // Step 1: Publish the Product itself
     const productResult = await publishResource(client, store, context, descriptor, config);
     if (productResult.status !== 'success') {
       return productResult;
     }
 
+    if (!productExisted) {
+      await cleanupAutoCreatedProductResources(client, context, descriptor);
+    }
+
     // Step 2: Publish ProductApi associations
     await publishProductAssociations(
       client,
@@ -88,6 +94,125 @@ export async function publishProduct(
   }
 }
 
+async function cleanupAutoCreatedProductResources(
+  client: IApimClient,
+  context: ApimServiceContext,
+  productDescriptor: ResourceDescriptor
+): Promise<void> {
+  await cleanupProductSubscriptions(client, context, productDescriptor);
+  await cleanupProductGroups(client, context, productDescriptor);
+}
+
+async function cleanupProductSubscriptions(
+  client: IApimClient,
+  context: ApimServiceContext,
+  productDescriptor: ResourceDescriptor
+): Promise<void> {
+  const productName = getNamePart(productDescriptor.nameParts, 0);
+  const expectedScopeSuffix = `/products/${productName}`;
+
+  let deleted = 0;
+
+  for await (const subscription of client.listResources(context, ResourceType.Subscription)) {
+    const descriptor = parseSubscriptionDescriptor(subscription, context);
+    if (!descriptor || descriptor.workspace !== productDescriptor.workspace) {
+      continue;
+    }
+
+    const props = subscription.properties as Record<string, unknown> | undefined;
+    const scope = typeof props?.scope === 'string' ? props.scope : '';
+    if (!scope.endsWith(expectedScopeSuffix)) {
+      continue;
+    }
+
+    try {
+      const removed = await client.deleteResource(context, descriptor);
+      if (removed) {
+        deleted++;
+        logger.debug(`Deleted APIM auto-created product subscription: ${descriptor.nameParts[0]}`);
+      }
+    } catch (error) {
+      logger.warn(
+        `Failed to delete APIM auto-created product subscription ${descriptor.nameParts[0]}: ${String(error)}`
+      );
+    }
+  }
+
+  if (deleted > 0) {
+    logger.info(`Deleted ${deleted} auto-created subscription(s) for product: ${productName}`);
+  }
+}
+
+async function cleanupProductGroups(
+  client: IApimClient,
+  context: ApimServiceContext,
+  productDescriptor: ResourceDescriptor
+): Promise<void> {
+  const productName = getNamePart(productDescriptor.nameParts, 0);
+  let deleted = 0;
+
+  for await (const productGroup of client.listResources(
+    context,
+    ResourceType.ProductGroup,
+    productDescriptor
+  )) {
+    const descriptor = parseProductGroupDescriptor(productGroup, context);
+    if (!descriptor || descriptor.workspace !== productDescriptor.workspace) {
+      continue;
+    }
+
+    try {
+      const removed = await client.deleteResource(context, descriptor);
+      if (removed) {
+        deleted++;
+      }
+    } catch (error) {
+      logger.warn(
+        `Failed to delete auto-created product group ${descriptor.nameParts.join('/')}: ${String(error)}`
+      );
+    }
+  }
+
+  if (deleted > 0) {
+    logger.info(`Deleted ${deleted} auto-created product group(s) for product: ${productName}`);
+  }
+}
+
+function parseSubscriptionDescriptor(
+  subscription: Record<string, unknown>,
+  context: ApimServiceContext
+): ResourceDescriptor | undefined {
+  if (typeof subscription.id === 'string') {
+    const parsed = parseArmUri(subscription.id, context);
+    if (parsed?.type === ResourceType.Subscription) {
+      return parsed;
+    }
+  }
+
+  if (typeof subscription.name === 'string' && subscription.name.length > 0) {
+    return {
+      type: ResourceType.Subscription,
+      nameParts: [subscription.name],
+    };
+  }
+
+  return undefined;
+}
+
+function parseProductGroupDescriptor(
+  productGroup: Record<string, unknown>,
+  context: ApimServiceContext
+): ResourceDescriptor | undefined {
+  if (typeof productGroup.id === 'string') {
+    const parsed = parseArmUri(productGroup.id, context);
+    if (parsed?.type === ResourceType.ProductGroup) {
+      return parsed;
+    }
+  }
+
+  return undefined;
+}
+
 /**
  * Publish associations (ProductApi or ProductGroup) for a product
  */

src/services/resource-publisher.ts

@@ -158,7 +158,7 @@ export async function publishResource(
           action: 'noop',
         };
       }
-      
+
       json = normalizeSubscriptionScope(json, context);
     }
 

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

@@ -22,9 +22,10 @@ function createMockClient() {
     listResources: async function* () {},
     getResource: vi.fn(),
     putResource: vi.fn().mockResolvedValue(undefined),
-    deleteResource: vi.fn(),
+    deleteResource: vi.fn().mockResolvedValue(true),
     listApiRevisions: async function* () {},
     getApiSpecification: vi.fn(),
+    validatePreFlight: vi.fn(),
   };
 }
 
@@ -62,6 +63,10 @@ const productDescriptor: ResourceDescriptor = {
   nameParts: ['my-product'],
 };
 
+function generatedSubscriptionId(fill: string): string {
+  return fill.repeat(24);
+}
+
 describe('product-publisher', () => {
   describe('publishProduct', () => {
     beforeEach(() => {
@@ -277,5 +282,90 @@ describe('product-publisher', () => {
       expect(result.error).toBeInstanceOf(Error);
       expect(result.error?.message).toBe('Unexpected store error');
     });
+
+    it('deletes auto-generated product subscriptions after product publish', async () => {
+      const client = createMockClient();
+      const store = createMockStore();
+      const autoGeneratedId = generatedSubscriptionId('c');
+      client.getResource.mockResolvedValue(undefined);
+      store.readAssociation.mockResolvedValue([]);
+      store.readContent.mockResolvedValue(undefined);
+
+      client.listResources = async function* () {
+        yield {
+          id: `${testContext.baseUrl}/subscriptions/${autoGeneratedId}`,
+          name: autoGeneratedId,
+          properties: {
+            scope: `${testContext.baseUrl}/products/my-product`,
+            displayName: null,
+          },
+        };
+      };
+
+      const result = await publishProduct(client, store, testContext, productDescriptor, testConfig);
+
+      expect(result.status).toBe('success');
+      expect(client.deleteResource).toHaveBeenCalledWith(
+        testContext,
+        expect.objectContaining({
+          type: ResourceType.Subscription,
+          nameParts: [autoGeneratedId],
+        })
+      );
+    });
+
+    it('deletes product-scoped subscriptions on first product creation regardless of displayName', async () => {
+      const client = createMockClient();
+      const store = createMockStore();
+      client.getResource.mockResolvedValue(undefined);
+      store.readAssociation.mockResolvedValue([]);
+      store.readContent.mockResolvedValue(undefined);
+
+      client.listResources = async function* () {
+        yield {
+          id: `${testContext.baseUrl}/subscriptions/src-sub-product`,
+          name: 'src-sub-product',
+          properties: {
+            scope: `${testContext.baseUrl}/products/my-product`,
+            displayName: 'Kitchen Sink Product Subscription',
+          },
+        };
+      };
+
+      const result = await publishProduct(client, store, testContext, productDescriptor, testConfig);
+
+      expect(result.status).toBe('success');
+      expect(client.deleteResource).toHaveBeenCalledWith(
+        testContext,
+        expect.objectContaining({
+          type: ResourceType.Subscription,
+          nameParts: ['src-sub-product'],
+        })
+      );
+    });
+
+    it('does not run cleanup when product already exists', async () => {
+      const client = createMockClient();
+      const store = createMockStore();
+      client.getResource.mockResolvedValue({ name: 'my-product' });
+      store.readAssociation.mockResolvedValue([]);
+      store.readContent.mockResolvedValue(undefined);
+
+      client.listResources = async function* () {
+        yield {
+          id: `${testContext.baseUrl}/subscriptions/${generatedSubscriptionId('d')}`,
+          name: generatedSubscriptionId('d'),
+          properties: {
+            scope: `${testContext.baseUrl}/products/my-product`,
+            displayName: null,
+          },
+        };
+      };
+
+      const result = await publishProduct(client, store, testContext, productDescriptor, testConfig);
+
+      expect(result.status).toBe('success');
+      expect(client.deleteResource).not.toHaveBeenCalled();
+    });
   });
 });

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

@@ -64,6 +64,10 @@ const testConfig: PublishConfig = {
   logLevel: LogLevel.INFO,
 };
 
+function generatedSubscriptionId(fill: string): string {
+  return fill.repeat(24);
+}
+
 describe('resource-publisher', () => {
   describe('publishResource', () => {
     beforeEach(() => {
@@ -641,6 +645,67 @@ describe('resource-publisher', () => {
       expect(client.putResource).not.toHaveBeenCalled();
     });
 
+    it('should publish product subscription with empty displayName', async () => {
+      const client = createMockClient();
+      const store = createMockStore();
+      const autoGeneratedId = generatedSubscriptionId('a');
+
+      const armScopePrefix =
+        '/subscriptions/sub-1/resourceGroups/rg-1/providers/Microsoft.ApiManagement/service/apim-1';
+
+      const subscriptionJson = {
+        name: autoGeneratedId,
+        properties: {
+          ownerId: `${armScopePrefix}/users/1`,
+          scope: `${armScopePrefix}/products/starter`,
+          displayName: null,
+          state: 'active',
+        },
+      };
+      store.readResource.mockResolvedValue(subscriptionJson);
+
+      const descriptor: ResourceDescriptor = {
+        type: ResourceType.Subscription,
+        nameParts: [autoGeneratedId],
+      };
+
+      const result = await publishResource(client, store, testContext, descriptor, testConfig);
+
+      expect(result.status).toBe('success');
+      expect(result.action).toBe('put');
+      expect(client.putResource).toHaveBeenCalledTimes(1);
+    });
+
+    it('should publish product subscription when displayName is set', async () => {
+      const client = createMockClient();
+      const store = createMockStore();
+      const autoGeneratedId = generatedSubscriptionId('b');
+
+      const armScopePrefix =
+        '/subscriptions/sub-1/resourceGroups/rg-1/providers/Microsoft.ApiManagement/service/apim-1';
+
+      const subscriptionJson = {
+        name: autoGeneratedId,
+        properties: {
+          scope: `${armScopePrefix}/products/starter`,
+          displayName: 'Starter access',
+          state: 'active',
+        },
+      };
+      store.readResource.mockResolvedValue(subscriptionJson);
+
+      const descriptor: ResourceDescriptor = {
+        type: ResourceType.Subscription,
+        nameParts: [autoGeneratedId],
+      };
+
+      const result = await publishResource(client, store, testContext, descriptor, testConfig);
+
+      expect(result.status).toBe('success');
+      expect(result.action).toBe('put');
+      expect(client.putResource).toHaveBeenCalledTimes(1);
+    });
+
     describe('API revision handling', () => {
       it('injects sourceApiId for revision APIs', async () => {
         const client = createMockClient();