feat(core): clearSuspensionRecord helper, cleared after CLI creates

packages/ai/package.json

@@ -25,7 +25,7 @@
     "test": "jest --passWithNoTests"
   },
   "dependencies": {
-    "@osaas/client-core": "^0.26.0",
+    "@osaas/client-core": "^0.28.0",
     "chalk": "4.1.2"
   },
   "publishConfig": {

packages/cli/package.json

@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@osaas/client-ai": "^0.5.5",
-    "@osaas/client-core": "^0.26.0",
+    "@osaas/client-core": "^0.28.0",
     "@osaas/client-db": "^0.7.6",
     "@osaas/client-intercom": "^0.4.5",
     "@osaas/client-transcode": "^0.29.4",

packages/cli/src/user/cmd.ts

@@ -1,4 +1,5 @@
 import {
+  clearSuspensionRecord,
   Context,
   createInstance,
   deleteSecret,
@@ -85,6 +86,7 @@ export function cmdCreate() {
           serviceAccessToken,
           payload
         );
+        await clearSuspensionRecord(ctx, serviceId, payload['name']);
         const isJson = command.optsWithGlobals().json;
         if (isJson) {
           process.stdout.write(JSON.stringify(instance) + '\n');

packages/cli/src/web/cmd.ts

@@ -1,4 +1,5 @@
 import {
+  clearSuspensionRecord,
   Context,
   createInstance,
   getInstance,
@@ -119,6 +120,7 @@ export function cmdWeb() {
                 name
               }
             );
+            await clearSuspensionRecord(ctx, 'valkey-io-valkey', name);
             await waitForInstanceReady('valkey-io-valkey', name, ctx);
           }
           const ports = await getPortsForInstance(
@@ -140,6 +142,7 @@ export function cmdWeb() {
               RedisUrl: `redis://${redisPort.externalIp}:${redisPort.externalPort}`
             }
           );
+          await clearSuspensionRecord(ctx, 'eyevinn-app-config-svc', name);
           await waitForInstanceReady('eyevinn-app-config-svc', name, ctx);
         }
         console.log(

packages/cli/src/web/config-create.test.ts

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import { cmdWeb } from './cmd';
+
+jest.mock('@osaas/client-web', () => ({
+  publishToMyPages: jest.fn(),
+  createCloudfrontDistribution: jest.fn()
+}));
+
+jest.mock('@osaas/client-core', () => ({
+  Context: jest.fn().mockImplementation(() => ({
+    getServiceAccessToken: jest.fn().mockResolvedValue('sat')
+  })),
+  clearSuspensionRecord: jest.fn().mockResolvedValue(undefined),
+  createInstance: jest.fn(),
+  getInstance: jest.fn(),
+  getPortsForInstance: jest.fn(),
+  removeInstance: jest.fn(),
+  waitForInstanceReady: jest.fn()
+}));
+
+import {
+  clearSuspensionRecord,
+  createInstance,
+  getInstance,
+  getPortsForInstance
+} from '@osaas/client-core';
+
+const mockClear = clearSuspensionRecord as jest.Mock;
+const mockCreate = createInstance as jest.Mock;
+const mockGetInstance = getInstance as jest.Mock;
+const mockGetPorts = getPortsForInstance as jest.Mock;
+
+describe('web config-create command', () => {
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  function createTestCli(): Command {
+    const cli = new Command();
+    cli.option('--env <environment>', 'Environment to use', 'prod');
+    cli.addCommand(cmdWeb());
+    return cli;
+  }
+
+  test('clears suspension records after each successful create', async () => {
+    mockGetInstance.mockResolvedValue(undefined);
+    mockGetPorts.mockResolvedValue([
+      { internalPort: 6379, externalIp: '1.2.3.4', externalPort: 1234 }
+    ]);
+    mockCreate.mockImplementation(async (_ctx, serviceId, _token, body) => ({
+      name: body.name,
+      url: `https://${serviceId}.example`
+    }));
+
+    await createTestCli().parseAsync([
+      'node',
+      'test',
+      'web',
+      'config-create',
+      'myconfig'
+    ]);
+
+    expect(mockCreate).toHaveBeenCalledTimes(2);
+    expect(mockClear).toHaveBeenCalledTimes(2);
+    expect(mockClear).toHaveBeenCalledWith(
+      expect.anything(),
+      'valkey-io-valkey',
+      'myconfig'
+    );
+    expect(mockClear).toHaveBeenCalledWith(
+      expect.anything(),
+      'eyevinn-app-config-svc',
+      'myconfig'
+    );
+  });
+
+  test('does not clear when the instance already exists', async () => {
+    mockGetInstance.mockResolvedValue({
+      name: 'myconfig',
+      url: 'https://existing.example'
+    });
+
+    await createTestCli().parseAsync([
+      'node',
+      'test',
+      'web',
+      'config-create',
+      'myconfig'
+    ]);
+
+    expect(mockCreate).not.toHaveBeenCalled();
+    expect(mockClear).not.toHaveBeenCalled();
+  });
+
+  test('does not clear when createInstance fails', async () => {
+    mockGetInstance.mockResolvedValue(undefined);
+    mockCreate.mockRejectedValue(new Error('create failed'));
+
+    await createTestCli().parseAsync([
+      'node',
+      'test',
+      'web',
+      'config-create',
+      'myconfig'
+    ]);
+
+    expect(mockClear).not.toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith('create failed');
+  });
+});

packages/core/src/index.ts

@@ -46,3 +46,4 @@ export {
 export * from './platform/maker';
 export * from './errors';
 export * from './myapp';
+export { clearSuspensionRecord } from './suspension';

packages/core/src/suspension.test.ts

@@ -0,0 +1,60 @@
+import { Context } from './context';
+import { createFetch, FetchError } from './fetch';
+import { clearSuspensionRecord } from './suspension';
+
+jest.mock('./fetch', () => ({
+  ...jest.requireActual('./fetch'),
+  createFetch: jest.fn()
+}));
+
+describe('clearSuspensionRecord', () => {
+  const ctx = new Context({
+    personalAccessToken: 'dummy',
+    environment: 'dev'
+  });
+  const mockFetch = createFetch as jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('sends DELETE with PAT and no Content-Type on success', async () => {
+    mockFetch.mockResolvedValueOnce({ message: 'deleted' });
+    await expect(
+      clearSuspensionRecord(ctx, 'svc-id', 'myname')
+    ).resolves.toBeUndefined();
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const [url, options] = mockFetch.mock.calls[0];
+    expect(url.toString()).toEqual(
+      'https://deploy.svc.dev.osaas.io/mysuspended/svc-id/myname'
+    );
+    expect(options.method).toEqual('DELETE');
+    expect(options.headers['x-pat-jwt']).toEqual('Bearer dummy');
+    expect(options.headers['Content-Type']).toBeUndefined();
+  });
+
+  test('treats 404 as a no-op', async () => {
+    mockFetch.mockRejectedValueOnce(
+      new FetchError({ message: 'not found', httpCode: 404 })
+    );
+    await expect(
+      clearSuspensionRecord(ctx, 'svc-id', 'myname')
+    ).resolves.toBeUndefined();
+  });
+
+  test('swallows a 500 error', async () => {
+    mockFetch.mockRejectedValueOnce(
+      new FetchError({ message: 'boom', httpCode: 500 })
+    );
+    await expect(
+      clearSuspensionRecord(ctx, 'svc-id', 'myname')
+    ).resolves.toBeUndefined();
+  });
+
+  test('swallows a network error', async () => {
+    mockFetch.mockRejectedValueOnce(new TypeError('fetch failed'));
+    await expect(
+      clearSuspensionRecord(ctx, 'svc-id', 'myname')
+    ).resolves.toBeUndefined();
+  });
+});