feat(konnect): move Konnect projects into a global Control Planes organization [INS-3148]

packages/insomnia-data/src/database/types.ts

@@ -27,6 +27,8 @@ export interface SpecificQuery {
   $in?: (string | null)[];
   $nin?: string[];
   $ne?: string | null;
+  // NeDB's `$ne` also matches documents where the field is absent, so optional keys need this too.
+  $exists?: boolean;
 }
 
 export type Query<T extends BaseModel = BaseModel> = {

packages/insomnia-data/src/models/organization.ts

@@ -1,8 +1,35 @@
-import type { PersonalPlanType } from 'insomnia-api';
+import type { Organization, PersonalPlanType } from 'insomnia-api';
 
 export const SCRATCHPAD_ORGANIZATION_ID = 'org_scratchpad';
 export const isScratchpadOrganizationId = (organizationId: string) => organizationId === SCRATCHPAD_ORGANIZATION_ID;
 
+export const KONNECT_ORGANIZATION_ID_PREFIX = 'org_konnect_';
+export const KONNECT_ORGANIZATION_NAME = 'Control Planes';
+
+// The Konnect organization is local-only, but the database is not partitioned per user, so the
+// account id is baked into the id to keep one account's Konnect data out of another's.
+export const getKonnectOrganizationId = (accountId: string) => `${KONNECT_ORGANIZATION_ID_PREFIX}${accountId}`;
+export const isKonnectOrganizationId = (organizationId: string) =>
+  organizationId.startsWith(KONNECT_ORGANIZATION_ID_PREFIX);
+
+/** Organizations that exist only on this machine and must never be used for organization-scoped API calls. */
+export const isLocalOrganizationId = (organizationId: string) =>
+  isScratchpadOrganizationId(organizationId) || isKonnectOrganizationId(organizationId);
+
+export const buildKonnectOrganization = (accountId: string): Organization => ({
+  id: getKonnectOrganizationId(accountId),
+  name: KONNECT_ORGANIZATION_NAME,
+  picture: null,
+  owner_first_name: null,
+  owner_last_name: null,
+  owner_email: null,
+  total_members: 1,
+  total_invites: 0,
+  // Every account owns at least one organization, and this one only exists on their machine.
+  is_owner: true,
+  can_leave: false,
+});
+
 export const formatCurrentPlanType = (type: PersonalPlanType) => {
   switch (type) {
     case 'free': {

packages/insomnia-smoke-test/playwright/pages/components/navigation-sidebar.ts

@@ -15,15 +15,16 @@
   }
 
   // ===========================================================================
-  // Tab controls
+  // Organization switching
   // ===========================================================================
 
-  async clickProjectsTab(): Promise<void> {
-    await this.root.getByTestId('sidebar-tab-projects').click();
+  async selectOrganization(name: string): Promise<void> {
+    await this.page.getByRole('button', { name: 'Organizations' }).click();
+    await this.page.getByRole('option', { name }).click();
   }
 
-  async clickKonnectTab(): Promise<void> {
-    await this.root.getByTestId('sidebar-tab-konnect').click();
+  async openControlPlanesOrganization(): Promise<void> {
+    await this.selectOrganization('Control Planes');
   }
 
   // ===========================================================================
@@ -186,7 +187,7 @@
     const actionsButton = requestRow.getByLabel('Request Group Actions');
     // Sometimes the dropdown button can be a bit tricky to click if the hover state isn't properly triggered, so we'll add some retries here to make it more robust
     for (let attempt = 0; attempt < 3; attempt++) {
       await requestRow.hover();
       if (attempt > 0) {
         console.log(`Retrying to open request group actions dropdown for "${requestName}", attempt ${attempt + 1}`);
       }

packages/insomnia-smoke-test/tests/smoke/konnect.test.ts

@@ -2,9 +2,10 @@
 
 import { test } from '../../playwright/test';
 
-test.describe('Konnect sidebar tab', () => {
-  test('shows intro card without a PAT, configure it, then sync', async ({ page, insomnia }) => {
-    await page.getByTestId('sidebar-tab-konnect').click();
+test.describe('Control Planes organization', () => {
+  test('shows intro card without a PAT, configure it, then sync', async ({ page }) => {
+    await page.getByRole('button', { name: 'Organizations' }).click();
+    await page.getByRole('option', { name: 'Control Planes' }).click();
     await expect.soft(page.getByText('Auto-sync your gateway service routes')).toBeVisible();
 
     await page.getByRole('button', { name: 'Configure' }).click();
@@ -12,10 +13,9 @@
     await page.getByRole('button', { name: 'Connect & Sync' }).click();
     await expect.soft(page.getByRole('heading', { name: 'Kong Konnect settings' })).toBeHidden();
 
     await expect.soft(page.getByRole('button', { name: 'Sync Konnect' })).toBeVisible();
-
-    await page.getByTestId('sidebar-tab-projects').click();
-    await expect.soft(page.getByRole('button', { name: 'Create new Project' })).toBeVisible();
+    // The Konnect organization never offers manual project creation.
+    await expect.soft(page.getByRole('button', { name: 'Create new Project' })).toBeHidden();
   });
 
   test.describe('with konnectSync feature flag disabled', () => {
@@ -31,9 +31,10 @@
       });
     });
 
-    test('hides the Konnect tab', async ({ page }) => {
+    test('hides the Control Planes organization', async ({ page }) => {
       await page.reload({ waitUntil: 'networkidle' });
-      await expect.soft(page.getByTestId('sidebar-tab-konnect')).toBeHidden();
+      await page.getByRole('button', { name: 'Organizations' }).click();
+      await expect.soft(page.getByRole('option', { name: 'Control Planes' })).toBeHidden();
     });
   });
 });

packages/insomnia/src/common/organization-storage-rules.ts

@@ -18,7 +18,7 @@ export async function fetchAndCacheOrganizationStorageRule(
 ): Promise<StorageRules> {
   invariant(organizationId, 'Organization ID is required');
 
-  if (models.organization.isScratchpadOrganizationId(organizationId)) {
+  if (models.organization.isLocalOrganizationId(organizationId)) {
     return {
       enableCloudSync: false,
       enableLocalVault: true,

packages/insomnia/src/entry.client.tsx

@@ -9,6 +9,7 @@ import { HydratedRouter } from 'react-router/dom';
 
 import { insomniaFetch } from '~/common/insomnia-fetch';
 import { setTemplatingDbAuthToken } from '~/common/templating/liquid-extension-worker';
+import { migrateKonnectProjectsIfUnambiguous } from '~/konnect/migrate-konnect-organization';
 import { initRuntime } from '~/runtimes';
 import { rendererRuntime } from '~/runtimes/runtime.renderer';
 import { migrateFromLocalStorage, type SessionData, setSessionData, setVaultSessionData } from '~/ui/account/session';
@@ -145,6 +146,17 @@ if (appSettings.clearOAuth2SessionOnRestart) {
 
 applyColorScheme(appSettings);
 
+// Runs before the router hydrates so every loader can assume Konnect projects already live under
+// the Konnect organization. The ambiguous case is left for the user to resolve in the UI.
+try {
+  const { accountId } = await services.userSession.get();
+  if (accountId) {
+    await migrateKonnectProjectsIfUnambiguous(accountId);
+  }
+} catch (e) {
+  console.log('[konnect] Failed to migrate Konnect projects', e);
+}
+
 const initialEntry = await getInitialEntry();
 
 if (typeof initialEntry === 'string' && window.location.pathname !== initialEntry) {

packages/insomnia/src/konnect/__tests__/migrate-konnect-organization.test.ts

@@ -0,0 +1,204 @@
+/**
+ * Tests run against the in-memory NeDB initialized by setup-vitest.ts.
+ * localStorage is stubbed per-test to supply the cached organization list.
+ */
+
+import { initDatabase, models, services } from 'insomnia-data';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { mainDatabase } from '../../main/database.main';
+import {
+  detectKonnectOrgMigration,
+  migrateKonnectProjectsIfUnambiguous,
+  runKonnectOrgMigration,
+} from '../migrate-konnect-organization';
+
+const ACCOUNT_ID = 'acct_1';
+const ORG_A = 'org_a';
+const ORG_B = 'org_b';
+const KONNECT_ORG_ID = models.organization.getKonnectOrganizationId(ACCOUNT_ID);
+
+function stubLocalStorage(initial: Record<string, string> = {}) {
+  const store = new Map(Object.entries(initial));
+  vi.stubGlobal('localStorage', {
+    getItem: (key: string) => store.get(key) ?? null,
+    setItem: (key: string, value: string) => void store.set(key, value),
+    removeItem: (key: string) => void store.delete(key),
+  });
+  return store;
+}
+
+async function createKonnectProject(parentId: string, controlPlaneId: string) {
+  const project = await services.project.create({
+    name: `CP ${controlPlaneId}`,
+    parentId,
+    konnectControlPlaneId: controlPlaneId,
+  });
+  await services.workspace.create({
+    name: `Service of ${controlPlaneId}`,
+    parentId: project._id,
+    scope: 'collection',
+    konnectServiceId: `svc-${controlPlaneId}`,
+  });
+  return project;
+}
+
+const listKonnectProjects = () => services.project.list({ konnectControlPlaneId: { $exists: true, $ne: null } });
+
+beforeEach(async () => {
+  await initDatabase(mainDatabase, { inMemoryOnly: true }, true);
+  stubLocalStorage({
+    [`${ACCOUNT_ID}:spaces`]: JSON.stringify([
+      { id: ORG_A, name: 'Org A' },
+      { id: ORG_B, name: 'Org B' },
+    ]),
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('detectKonnectOrgMigration', () => {
+  it('reports nothing to do when there are no Konnect projects', async () => {
+    expect(await detectKonnectOrgMigration({ accountId: ACCOUNT_ID })).toEqual({ status: 'none', groups: [] });
+  });
+
+  it('reports a single source organization as auto-migratable', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    await createKonnectProject(ORG_A, 'cp-2');
+
+    const plan = await detectKonnectOrgMigration({ accountId: ACCOUNT_ID });
+
+    expect(plan.status).toBe('auto');
+    expect(plan.groups).toEqual([
+      { organizationId: ORG_A, organizationName: 'Org A', projectCount: 2, workspaceCount: 2 },
+    ]);
+  });
+
+  it('reports multiple source organizations as a conflict', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    await createKonnectProject(ORG_B, 'cp-2');
+
+    const plan = await detectKonnectOrgMigration({ accountId: ACCOUNT_ID });
+
+    expect(plan.status).toBe('conflict');
+    expect(plan.groups.map(g => g.organizationId).sort()).toEqual([ORG_A, ORG_B]);
+  });
+
+  it('ignores Konnect projects owned by another account on the same machine', async () => {
+    await createKonnectProject('org_someone_else', 'cp-1');
+
+    expect(await detectKonnectOrgMigration({ accountId: ACCOUNT_ID })).toEqual({ status: 'none', groups: [] });
+  });
+
+  it('ignores Konnect projects that already live under the Konnect organization', async () => {
+    await createKonnectProject(KONNECT_ORG_ID, 'cp-1');
+
+    expect(await detectKonnectOrgMigration({ accountId: ACCOUNT_ID })).toEqual({ status: 'none', groups: [] });
+  });
+
+  it('ignores regular projects, which omit konnectControlPlaneId entirely', async () => {
+    await services.project.create({ name: 'Regular', parentId: ORG_A });
+
+    expect(await detectKonnectOrgMigration({ accountId: ACCOUNT_ID })).toEqual({ status: 'none', groups: [] });
+  });
+});
+
+describe('runKonnectOrgMigration', () => {
+  it('re-parents the chosen organization and deletes the rest with their descendants', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    const discarded = await createKonnectProject(ORG_B, 'cp-2');
+
+    await runKonnectOrgMigration({ accountId: ACCOUNT_ID, keepOrganizationId: ORG_A });
+
+    const projects = await listKonnectProjects();
+    expect(projects).toHaveLength(1);
+    expect(projects[0].parentId).toBe(KONNECT_ORG_ID);
+    expect(projects[0].konnectControlPlaneId).toBe('cp-1');
+
+    expect(await services.workspace.count({ parentId: discarded._id })).toBe(0);
+  });
+
+  it("leaves another account's Konnect projects untouched", async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    await createKonnectProject('org_someone_else', 'cp-other');
+
+    await runKonnectOrgMigration({ accountId: ACCOUNT_ID, keepOrganizationId: ORG_A });
+
+    const projects = await listKonnectProjects();
+    expect(projects.map(p => p.parentId).sort()).toEqual([KONNECT_ORG_ID, 'org_someone_else'].sort());
+  });
+
+  it('carries the last-synced timestamp over to the Konnect organization', async () => {
+    const store = stubLocalStorage({
+      [`${ACCOUNT_ID}:spaces`]: JSON.stringify([{ id: ORG_A, name: 'Org A' }]),
+      [`${ORG_A}:konnect-last-synced-at`]: '1700000000000',
+    });
+    await createKonnectProject(ORG_A, 'cp-1');
+
+    await runKonnectOrgMigration({ accountId: ACCOUNT_ID, keepOrganizationId: ORG_A });
+
+    expect(store.get(`${KONNECT_ORG_ID}:konnect-last-synced-at`)).toBe('1700000000000');
+    expect(store.get(`${ORG_A}:konnect-last-synced-at`)).toBeUndefined();
+  });
+
+  it('clears the last-synced timestamp of every source organization but leaves orphans alone', async () => {
+    const store = stubLocalStorage({
+      [`${ACCOUNT_ID}:spaces`]: JSON.stringify([
+        { id: ORG_A, name: 'Org A' },
+        { id: ORG_B, name: 'Org B' },
+      ]),
+      [`${ORG_A}:konnect-last-synced-at`]: '1700000000000',
+      [`${ORG_B}:konnect-last-synced-at`]: '1600000000000',
+      ['org_someone_else:konnect-last-synced-at']: '1500000000000',
+    });
+    await createKonnectProject(ORG_A, 'cp-1');
+    await createKonnectProject(ORG_B, 'cp-2');
+    await createKonnectProject('org_someone_else', 'cp-other');
+
+    await runKonnectOrgMigration({ accountId: ACCOUNT_ID, keepOrganizationId: ORG_A });
+
+    expect(store.get(`${KONNECT_ORG_ID}:konnect-last-synced-at`)).toBe('1700000000000');
+    expect(store.get(`${ORG_A}:konnect-last-synced-at`)).toBeUndefined();
+    expect(store.get(`${ORG_B}:konnect-last-synced-at`)).toBeUndefined();
+    expect(store.get('org_someone_else:konnect-last-synced-at')).toBe('1500000000000');
+  });
+
+  it('neither re-parents nor deletes regular projects', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    const keptRegular = await services.project.create({ name: 'Regular A', parentId: ORG_A });
+    const discardedRegular = await services.project.create({ name: 'Regular B', parentId: ORG_B });
+
+    await runKonnectOrgMigration({ accountId: ACCOUNT_ID, keepOrganizationId: ORG_A });
+
+    expect((await services.project.getById(keptRegular._id))?.parentId).toBe(ORG_A);
+    expect((await services.project.getById(discardedRegular._id))?.parentId).toBe(ORG_B);
+  });
+});
+
+describe('migrateKonnectProjectsIfUnambiguous', () => {
+  it('migrates automatically and is idempotent on a second run', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+
+    expect(await migrateKonnectProjectsIfUnambiguous(ACCOUNT_ID)).toEqual({ status: 'none', groups: [] });
+
+    const afterFirstRun = await listKonnectProjects();
+    expect(afterFirstRun.map(p => p.parentId)).toEqual([KONNECT_ORG_ID]);
+
+    expect(await migrateKonnectProjectsIfUnambiguous(ACCOUNT_ID)).toEqual({ status: 'none', groups: [] });
+    expect(await listKonnectProjects()).toHaveLength(1);
+  });
+
+  it('defers to the user when the source organization is ambiguous', async () => {
+    await createKonnectProject(ORG_A, 'cp-1');
+    await createKonnectProject(ORG_B, 'cp-2');
+
+    const plan = await migrateKonnectProjectsIfUnambiguous(ACCOUNT_ID);
+
+    expect(plan.status).toBe('conflict');
+    // Nothing moved until the user picks one.
+    const projects = await listKonnectProjects();
+    expect(projects.map(p => p.parentId).sort()).toEqual([ORG_A, ORG_B]);
+  });
+});