@frockbot/configuration-core 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/configuration-core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/connection-core": "0.2.2",
-    "@frockbot/kernel-composition": "0.2.2"
+    "@frockbot/connection-core": "0.2.4",
+    "@frockbot/kernel-composition": "0.2.4"
   },
   "devDependencies": {
     "@types/bun": "1.3.6",

package/src/index.test.ts

@@ -98,6 +98,137 @@ describe("stored configuration migrations", () => {
     );
   });
 
+  test("retires Catalog-orphaned platform state and disables inconsistent dependents", () => {
+    const stored = {
+      schemaVersion: 1,
+      revision: 12,
+      profile: { name: "Legacy User" },
+      packages: [
+        {
+          packageId: "retired-provider",
+          version: "0.0.1",
+          state: "installed" as const,
+        },
+        {
+          packageId: "current-provider",
+          version: "0.0.1",
+          state: "installed" as const,
+        },
+      ],
+      connections: [
+        {
+          connectionId: "retired-connection",
+          packageId: "retired-provider",
+          connectionTypeId: "retired-account",
+          displayName: "Retired",
+          state: "ready" as const,
+          safeMetadata: {},
+        },
+        {
+          connectionId: "current-connection",
+          packageId: "current-provider",
+          connectionTypeId: "current-account",
+          displayName: "Current",
+          state: "ready" as const,
+          safeMetadata: {},
+        },
+      ],
+      platformModel: {
+        connectionId: "retired-connection",
+        providerModelId: "retired-model",
+      },
+    };
+    const migrated = decodeUserSettingsViewV1(
+      migrateStoredUserSettingsV1(stored, [
+        {
+          packageId: "current-provider",
+          version: "0.0.1",
+          dependencies: { "model-choice": ">=0.0.1" },
+        },
+        { packageId: "model-choice", version: "0.0.1" },
+      ]),
+    );
+
+    expect(migrated.packages).toEqual([
+      {
+        packageId: "current-provider",
+        version: "0.0.1",
+        state: "disabled",
+      },
+    ]);
+    expect(migrated.connections).toEqual([stored.connections[1]]);
+    expect(migrated.platformModel).toBeUndefined();
+    expect(stored.packages).toHaveLength(2);
+    expect(stored.connections).toHaveLength(2);
+    expect(stored.platformModel).toBeDefined();
+  });
+
+  test("keeps version mismatches and malformed platform bindings visible", () => {
+    const versionMismatch = {
+      schemaVersion: 1,
+      revision: 0,
+      profile: { name: "Existing User" },
+      packages: [
+        {
+          packageId: "provider",
+          version: "0.0.1",
+          state: "installed" as const,
+        },
+      ],
+      connections: [],
+    };
+    expect(
+      migrateStoredUserSettingsV1(versionMismatch, [
+        { packageId: "provider", version: "0.0.2" },
+      ]),
+    ).toBe(versionMismatch);
+
+    const remoteCatalogInstall = {
+      ...versionMismatch,
+      packages: [
+        {
+          packageId: "remote-provider",
+          version: "1.2.3",
+          state: "installed" as const,
+          provenance: "catalog" as const,
+          catalogId: "remote-provider",
+          catalogGeneration: "generation-1",
+        },
+      ],
+      connections: [
+        {
+          connectionId: "remote-connection",
+          packageId: "remote-provider",
+          connectionTypeId: "remote-account",
+          displayName: "Remote",
+          state: "ready" as const,
+          safeMetadata: {},
+        },
+      ],
+    };
+    expect(
+      migrateStoredUserSettingsV1(remoteCatalogInstall, [
+        { packageId: "provider", version: "0.0.2" },
+      ]),
+    ).toBe(remoteCatalogInstall);
+
+    const malformedPlatform = {
+      ...versionMismatch,
+      platformModel: {
+        connectionId: "provider-connection",
+        providerModelId: "model",
+        unknown: true,
+      },
+    };
+    expect(() =>
+      decodeUserSettingsViewV1(
+        migrateStoredUserSettingsV1(malformedPlatform, [
+          { packageId: "provider", version: "0.0.1" },
+        ]),
+      ),
+    ).toThrow(ConfigurationDecodeError);
+  });
+
   test("keeps unknown User, Package, and Connection fields strict", () => {
     const current = {
       schemaVersion: 1,

package/src/index.ts

@@ -1861,6 +1861,177 @@ const PRE_ACCOUNT_WIDE_CONNECTION_METADATA_FIELDS_V1 = [
   "dependentAssignments",
 ] as const;
 
+/**
+ * The immutable Package facts the stored User-settings migration needs. The
+ * migration deliberately knows no Package names: absence from this Catalog is
+ * what retires an installation, and these dependency edges are what identify
+ * an enablement state an older writer could not have represented safely.
+ */
+export interface StoredUserSettingsPackageV1 {
+  packageId: string;
+  version: string;
+  dependencies?: Readonly<Record<string, string>>;
+}
+
+function migrateCatalogRelativeUserSettingsV1(
+  settings: Record<string, unknown>,
+  packages: readonly StoredUserSettingsPackageV1[],
+): Record<string, unknown> {
+  const availableVersions = new Map(
+    packages.map((pkg) => [`${pkg.packageId}\u0000${pkg.version}`, pkg]),
+  );
+  const availablePackageIds = new Set(packages.map((pkg) => pkg.packageId));
+  const storedPackages = storedDataValueV1(settings, "packages");
+  const storedConnections = storedDataValueV1(settings, "connections");
+  if (!Array.isArray(storedPackages) || !Array.isArray(storedConnections)) {
+    return settings;
+  }
+
+  let changed = false;
+  const retiredFirstPartyPackageIds = new Set<string>();
+  let installations = storedPackages.filter((storedInstallation) => {
+    const installation = storedPlainRecordV1(storedInstallation);
+    if (!installation) return true;
+    const packageId = storedDataValueV1(installation, "packageId");
+    const version = storedDataValueV1(installation, "version");
+    const provenance = storedDataValueV1(installation, "provenance");
+    if (typeof packageId !== "string" || typeof version !== "string") {
+      return true;
+    }
+    // The facts supplied here are the running application's first-party
+    // Catalog. Remote Catalog installations have a separate pinned authority
+    // and must never be inferred retired from absence here.
+    if (provenance === "catalog") return true;
+    // A different immutable version remains a visible, repairable Catalog
+    // mismatch. Only an id absent from the Catalog proves that the Package was
+    // retired and that its row is now orphaned durable state.
+    const retained = availablePackageIds.has(packageId);
+    if (!retained) retiredFirstPartyPackageIds.add(packageId);
+    changed ||= !retained;
+    return retained;
+  });
+
+  // Disable inconsistent installed dependents to the least-authority state.
+  // Iterate to a fixed point so A -> B -> missing C leaves both A and B off.
+  for (;;) {
+    const enabledIds = new Set(
+      installations.flatMap((storedInstallation) => {
+        const installation = storedPlainRecordV1(storedInstallation);
+        const packageId = installation
+          ? storedDataValueV1(installation, "packageId")
+          : undefined;
+        return typeof packageId === "string" &&
+          storedDataValueV1(installation!, "state") === "installed"
+          ? [packageId]
+          : [];
+      }),
+    );
+    let disabledInPass = false;
+    installations = installations.map((storedInstallation) => {
+      const installation = storedPlainRecordV1(storedInstallation);
+      if (
+        !installation ||
+        storedDataValueV1(installation, "state") !== "installed"
+      ) {
+        return storedInstallation;
+      }
+      const packageId = storedDataValueV1(installation, "packageId");
+      const version = storedDataValueV1(installation, "version");
+      if (typeof packageId !== "string" || typeof version !== "string") {
+        return storedInstallation;
+      }
+      const pkg = availableVersions.get(`${packageId}\u0000${version}`);
+      if (
+        !pkg ||
+        Object.keys(pkg.dependencies ?? {}).every((id) => enabledIds.has(id))
+      ) {
+        return storedInstallation;
+      }
+      changed = true;
+      disabledInPass = true;
+      return cloneStoredRecordV1(installation, {
+        state: "disabled",
+        failure: undefined,
+      });
+    });
+    if (!disabledInPass) break;
+  }
+
+  const connections = storedConnections.filter((storedConnection) => {
+    const connection = storedPlainRecordV1(storedConnection);
+    if (!connection) return true;
+    const packageId = storedDataValueV1(connection, "packageId");
+    if (typeof packageId !== "string") return true;
+    // Connections ordinarily outlive uninstalls. This one is removed only
+    // because the migration retired its first-party owning installation in
+    // the same pass, which is the evidence that it is the requested orphan.
+    const retained = !retiredFirstPartyPackageIds.has(packageId);
+    changed ||= !retained;
+    return retained;
+  });
+
+  let platformModel = storedDataValueV1(settings, "platformModel");
+  if (platformModel !== undefined) {
+    let binding: ModelBindingV1 | undefined;
+    try {
+      binding = decodeModelBindingV1(platformModel);
+    } catch {
+      // This migration only repairs a valid old binding that is unavailable
+      // against the current Catalog. Malformed current data must still reach
+      // the exact decoder and fail visibly instead of being laundered away.
+    }
+    const connectionId = binding?.connectionId;
+    const connection =
+      typeof connectionId === "string"
+        ? connections.find((storedConnection) => {
+            const candidate = storedPlainRecordV1(storedConnection);
+            return (
+              candidate &&
+              storedDataValueV1(candidate, "connectionId") === connectionId
+            );
+          })
+        : undefined;
+    const connectionRecord = storedPlainRecordV1(connection);
+    const ownerId = connectionRecord
+      ? storedDataValueV1(connectionRecord, "packageId")
+      : undefined;
+    const owner =
+      typeof ownerId === "string"
+        ? installations.find((storedInstallation) => {
+            const candidate = storedPlainRecordV1(storedInstallation);
+            return (
+              candidate &&
+              storedDataValueV1(candidate, "packageId") === ownerId &&
+              storedDataValueV1(candidate, "state") === "installed"
+            );
+          })
+        : undefined;
+    const ownerRecord = storedPlainRecordV1(owner);
+    const ownerVersion = ownerRecord
+      ? storedDataValueV1(ownerRecord, "version")
+      : undefined;
+    const resolvable =
+      connectionRecord !== undefined &&
+      storedDataValueV1(connectionRecord, "state") === "ready" &&
+      typeof ownerId === "string" &&
+      typeof ownerVersion === "string" &&
+      availableVersions.has(`${ownerId}\u0000${ownerVersion}`);
+    if (binding && !resolvable) {
+      changed = true;
+      platformModel = undefined;
+    }
+  }
+
+  if (!changed) return settings;
+  return cloneStoredRecordV1(
+    settings,
+    { packages: installations, connections },
+    platformModel === undefined && Object.hasOwn(settings, "platformModel")
+      ? ["platformModel"]
+      : [],
+  );
+}
+
 /**
  * Migrates one raw User settings record across known durable shapes before the
  * current exact-field decoder sees it. Commit 1571b62 removed the model
@@ -1868,7 +2039,10 @@ const PRE_ACCOUNT_WIDE_CONNECTION_METADATA_FIELDS_V1 = [
  * with the Assignment feature; migration drops those fields without
  * interpreting them.
  */
-export function migrateStoredUserSettingsV1(stored: unknown): unknown {
+export function migrateStoredUserSettingsV1(
+  stored: unknown,
+  packages?: readonly StoredUserSettingsPackageV1[],
+): unknown {
   const settings = storedPlainRecordV1(stored);
   if (!settings || storedDataValueV1(settings, "schemaVersion") !== 1) {
     return stored;
@@ -1909,12 +2083,16 @@ export function migrateStoredUserSettingsV1(stored: unknown): unknown {
     }
   }
 
-  if (!changed) return stored;
-  return cloneStoredRecordV1(
-    settings,
-    connections === storedConnections ? {} : { connections },
-    removedSettingsFields,
-  );
+  const migrated = changed
+    ? cloneStoredRecordV1(
+        settings,
+        connections === storedConnections ? {} : { connections },
+        removedSettingsFields,
+      )
+    : settings;
+  return packages
+    ? migrateCatalogRelativeUserSettingsV1(migrated, packages)
+    : migrated;
 }
 
 export function decodeUserSettingsViewV1(input: unknown): UserSettingsViewV1 {