@opengeni/db 1.0.1 → 3.2.0-canary.0

package/src/integration-facets.ts

@@ -13,8 +13,10 @@ import {
   IntegrationFacetBindingOwnershipConflictError,
   IntegrationFacetBindingVersionConflictError,
   listIntegrationFacetBindingOwners,
+  listIntegrationFacetBindingOwnersForBindings,
   removeIntegrationFacetBindingOwner,
   upsertIntegrationFacetBinding,
+  type IntegrationFacetBindingOwner,
 } from "./integration-bindings";
 import * as schema from "./schema";
 
@@ -39,6 +41,8 @@ export type IntegrationFacetBindingSummary = {
   lastErrorCode: string | null;
   createdAt: string;
   updatedAt: string;
+  directlyOwned: boolean;
+  owners: IntegrationFacetBindingOwner[];
 };
 
 export type IntegrationFacetDefinitionSummary = {
@@ -96,6 +100,72 @@ export class IntegrationFacetOperationIdempotencyError extends Error {
   readonly name = "IntegrationFacetOperationIdempotencyError";
 }
 
+type IntegrationFacetOperationKind = "configure" | "update" | "disconnect";
+
+type IntegrationFacetOperationIdentity = {
+  accountId: string;
+  workspaceId: string;
+  subjectId: string;
+  capabilityId: string;
+  instanceKey: string;
+  facetKey: string;
+  idempotencyKey: string;
+};
+
+export function integrationFacetConfigureRequestDigest(input: {
+  capabilityId: string;
+  instanceKey: string;
+  facetKey: string;
+  displayName: string;
+  config: Record<string, unknown>;
+  expectedVersion?: number;
+}): string {
+  return sha256(
+    stableJson({
+      action: "configure",
+      capabilityId: input.capabilityId,
+      instanceKey: input.instanceKey,
+      facetKey: input.facetKey,
+      displayName: input.displayName,
+      config: input.config,
+      expectedVersion: input.expectedVersion ?? null,
+    }),
+  );
+}
+
+/**
+ * Replays only an exact completed Integration Facet receipt. This intentionally
+ * runs before mutable instance/Connection/provider validation at HTTP edges.
+ */
+export async function replayCompletedIntegrationFacetOperation<T extends Record<string, unknown>>(
+  db: Database,
+  input: IntegrationFacetOperationIdentity & {
+    kind: IntegrationFacetOperationKind;
+    expectedRequestDigest: string | ((result: T) => string);
+  },
+): Promise<T | null> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      await setSubjectRlsContext(scopedDb, input.subjectId);
+      return await scopedDb.transaction(async (txRaw) => {
+        const tx = txRaw as unknown as Database;
+        await lockFacetOperation(tx, input);
+        const existing = await loadFacetOperation(tx, input);
+        if (!existing) return null;
+        const result = replayFacetOperation<T>(
+          existing,
+          input,
+          input.kind,
+          input.expectedRequestDigest,
+        );
+        return await hydrateFacetOperationResult(tx, input, result);
+      });
+    },
+  );
+}
+
 type IntegrationInstanceContext = {
   accountId: string;
   integrationFacetInstallationId: string;
@@ -164,6 +234,10 @@ export async function listIntegrationInstanceFacets(
         asc(schema.integrationFacetDefinitions.kind),
         asc(schema.integrationFacetDefinitions.facetKey),
       );
+    const ownersByBindingId = await listIntegrationFacetBindingOwnersForBindings(
+      scopedDb,
+      rows.flatMap((row) => (row.bindingId ? [row.bindingId] : [])),
+    );
     return {
       capabilityId,
       instanceKey,
@@ -177,22 +251,26 @@ export async function listIntegrationInstanceFacets(
           capabilities: row.capabilities,
         },
         binding: row.bindingId
-          ? bindingSummary({
-              id: row.bindingId,
-              facetKey: row.facetKey,
-              kind: row.kind,
-              bindingKey: row.bindingKey!,
-              displayName: row.displayName!,
-              connectionId: row.connectionId ?? null,
-              status: row.status!,
-              config: row.config!,
-              cursor: row.cursor!,
-              version: row.version!,
-              lastSuccessAt: row.lastSuccessAt ?? null,
-              lastErrorCode: row.lastErrorCode ?? null,
-              createdAt: row.createdAt!,
-              updatedAt: row.updatedAt!,
-            })
+          ? bindingSummary(
+              {
+                id: row.bindingId,
+                facetKey: row.facetKey,
+                kind: row.kind,
+                bindingKey: row.bindingKey!,
+                displayName: row.displayName!,
+                connectionId: row.connectionId ?? null,
+                status: row.status!,
+                config: row.config!,
+                cursor: row.cursor!,
+                version: row.version!,
+                lastSuccessAt: row.lastSuccessAt ?? null,
+                lastErrorCode: row.lastErrorCode ?? null,
+                createdAt: row.createdAt!,
+                updatedAt: row.updatedAt!,
+              },
+              ownersByBindingId.get(row.bindingId) ?? [],
+              { capabilityId, instanceKey, facetKey: row.facetKey },
+            )
           : null,
       })),
     };
@@ -214,17 +292,7 @@ export async function configureIntegrationFacet(
     idempotencyKey: string;
   },
 ): Promise<IntegrationFacetMutationResult> {
-  const requestDigest = sha256(
-    stableJson({
-      action: "configure",
-      capabilityId: input.capabilityId,
-      instanceKey: input.instanceKey,
-      facetKey: input.facetKey,
-      displayName: input.displayName,
-      config: input.config,
-      expectedVersion: input.expectedVersion ?? null,
-    }),
-  );
+  const requestDigest = integrationFacetConfigureRequestDigest(input);
   return await withFacetOperation(db, input, requestDigest, "configure", async (tx) => {
     const context = await requireMutationContext(tx, input);
     const definition = await requireFacetDefinition(tx, context, input.facetKey);
@@ -244,16 +312,21 @@ export async function configureIntegrationFacet(
       owner: facetOwner(input.capabilityId, input.instanceKey, input.facetKey),
       ...(input.expectedVersion !== undefined ? { expectedVersion: input.expectedVersion } : {}),
     });
+    const owners = await listIntegrationFacetBindingOwners(tx, result.row.id);
     return {
       capabilityId: input.capabilityId,
       instanceKey: input.instanceKey,
       facetKey: input.facetKey,
       status: "configured",
-      binding: bindingSummary({
-        ...result.row,
-        facetKey: definition.facetKey,
-        kind: definition.kind,
-      }),
+      binding: bindingSummary(
+        {
+          ...result.row,
+          facetKey: definition.facetKey,
+          kind: definition.kind,
+        },
+        owners,
+        input,
+      ),
     };
   });
 }
@@ -312,16 +385,21 @@ export async function setIntegrationFacetLifecycle(
       if (!updated) throw new Error("Failed to update Integration facet lifecycle");
       row = updated;
     }
+    const owners = await listIntegrationFacetBindingOwners(tx, row.id);
     return {
       capabilityId: input.capabilityId,
       instanceKey: input.instanceKey,
       facetKey: input.facetKey,
       status: input.action === "pause" ? "paused" : "active",
-      binding: bindingSummary({
-        ...row,
-        facetKey: definition.facetKey,
-        kind: definition.kind,
-      }),
+      binding: bindingSummary(
+        {
+          ...row,
+          facetKey: definition.facetKey,
+          kind: definition.kind,
+        },
+        owners,
+        input,
+      ),
     };
   });
 }
@@ -377,11 +455,15 @@ export async function removeIntegrationFacet(
         instanceKey: input.instanceKey,
         facetKey: input.facetKey,
         status: "not_configured",
-        binding: bindingSummary({
-          ...binding,
-          facetKey: definition.facetKey,
-          kind: definition.kind,
-        }),
+        binding: bindingSummary(
+          {
+            ...binding,
+            facetKey: definition.facetKey,
+            kind: definition.kind,
+          },
+          owners,
+          input,
+        ),
         remainingOwners: owners,
       };
     }
@@ -391,17 +473,24 @@ export async function removeIntegrationFacet(
       owner,
       expectedVersion: input.expectedVersion,
     });
+    const effectiveRemainingOwners = removed.binding
+      ? await listIntegrationFacetBindingOwners(tx, removed.binding.id)
+      : [];
     return {
       capabilityId: input.capabilityId,
       instanceKey: input.instanceKey,
       facetKey: input.facetKey,
       status: removed.remainingOwners.length > 0 ? "retained_by_other_owners" : "removed",
       binding: removed.binding
-        ? bindingSummary({
-            ...removed.binding,
-            facetKey: definition.facetKey,
-            kind: definition.kind,
-          })
+        ? bindingSummary(
+            {
+              ...removed.binding,
+              facetKey: definition.facetKey,
+              kind: definition.kind,
+            },
+            effectiveRemainingOwners,
+            input,
+          )
         : null,
       remainingOwners: removed.remainingOwners,
     };
@@ -410,17 +499,9 @@ export async function removeIntegrationFacet(
 
 async function withFacetOperation<T extends Record<string, unknown>>(
   db: Database,
-  input: {
-    accountId: string;
-    workspaceId: string;
-    subjectId: string;
-    capabilityId: string;
-    instanceKey: string;
-    facetKey: string;
-    idempotencyKey: string;
-  },
+  input: IntegrationFacetOperationIdentity,
   requestDigest: string,
-  kind: string,
+  kind: IntegrationFacetOperationKind,
   execute: (tx: Database) => Promise<T>,
 ): Promise<T> {
   return await withRlsContext(
@@ -430,30 +511,11 @@ async function withFacetOperation<T extends Record<string, unknown>>(
       await setSubjectRlsContext(scopedDb, input.subjectId);
       return await scopedDb.transaction(async (txRaw) => {
         const tx = txRaw as unknown as Database;
-        await tx.execute(
-          sql`select pg_advisory_xact_lock(hashtextextended(${`capability-operation:${input.workspaceId}:${input.idempotencyKey}`}, 0))`,
-        );
-        const [existing] = await tx
-          .select()
-          .from(schema.capabilityOperations)
-          .where(
-            and(
-              eq(schema.capabilityOperations.workspaceId, input.workspaceId),
-              eq(schema.capabilityOperations.idempotencyKey, input.idempotencyKey),
-            ),
-          )
-          .for("update")
-          .limit(1);
+        await lockFacetOperation(tx, input);
+        const existing = await loadFacetOperation(tx, input);
         if (existing) {
-          if (existing.requestDigest !== requestDigest) {
-            throw new IntegrationFacetOperationIdempotencyError(
-              "Integration facet idempotency key was reused",
-            );
-          }
-          if (existing.status === "completed" && existing.result) return existing.result as T;
-          throw new IntegrationFacetOperationIdempotencyError(
-            "Integration facet operation is already in progress",
-          );
+          const result = replayFacetOperation<T>(existing, input, kind, requestDigest);
+          return await hydrateFacetOperationResult(tx, input, result);
         }
         const result = await execute(tx);
         await tx.insert(schema.capabilityOperations).values({
@@ -463,9 +525,7 @@ async function withFacetOperation<T extends Record<string, unknown>>(
           requestDigest,
           kind,
           targetKind: "facet_binding",
-          targetId: `facet:${sha256(
-            `${input.capabilityId}\0${input.instanceKey}\0${input.facetKey}`,
-          )}`,
+          targetId: facetOperationTargetId(input),
           status: "completed",
           phase: "completed",
           result,
@@ -478,6 +538,140 @@ async function withFacetOperation<T extends Record<string, unknown>>(
   );
 }
 
+async function lockFacetOperation(
+  db: Database,
+  input: Pick<IntegrationFacetOperationIdentity, "workspaceId" | "idempotencyKey">,
+): Promise<void> {
+  await db.execute(
+    sql`select pg_advisory_xact_lock(hashtextextended(${`capability-operation:${input.workspaceId}:${input.idempotencyKey}`}, 0))`,
+  );
+}
+
+async function loadFacetOperation(
+  db: Database,
+  input: Pick<IntegrationFacetOperationIdentity, "accountId" | "workspaceId" | "idempotencyKey">,
+) {
+  const [existing] = await db
+    .select()
+    .from(schema.capabilityOperations)
+    .where(
+      and(
+        eq(schema.capabilityOperations.accountId, input.accountId),
+        eq(schema.capabilityOperations.workspaceId, input.workspaceId),
+        eq(schema.capabilityOperations.idempotencyKey, input.idempotencyKey),
+      ),
+    )
+    .for("update")
+    .limit(1);
+  return existing;
+}
+
+function replayFacetOperation<T extends Record<string, unknown>>(
+  existing: typeof schema.capabilityOperations.$inferSelect,
+  input: IntegrationFacetOperationIdentity,
+  kind: IntegrationFacetOperationKind,
+  expectedRequestDigest: string | ((result: T) => string),
+): T {
+  if (
+    existing.createdBySubjectId !== input.subjectId ||
+    existing.kind !== kind ||
+    existing.targetKind !== "facet_binding" ||
+    existing.targetId !== facetOperationTargetId(input)
+  ) {
+    throw new IntegrationFacetOperationIdempotencyError(
+      "Integration facet idempotency key was reused",
+    );
+  }
+  if (
+    typeof expectedRequestDigest === "string" &&
+    existing.requestDigest !== expectedRequestDigest
+  ) {
+    throw new IntegrationFacetOperationIdempotencyError(
+      "Integration facet idempotency key was reused",
+    );
+  }
+  if (existing.status !== "completed" || !existing.result) {
+    throw new IntegrationFacetOperationIdempotencyError(
+      "Integration facet operation is already in progress",
+    );
+  }
+  const result = existing.result as T;
+  const requestDigest =
+    typeof expectedRequestDigest === "string"
+      ? expectedRequestDigest
+      : expectedRequestDigest(result);
+  if (existing.requestDigest !== requestDigest) {
+    throw new IntegrationFacetOperationIdempotencyError(
+      "Integration facet idempotency key was reused",
+    );
+  }
+  return result;
+}
+
+function facetOperationTargetId(
+  input: Pick<IntegrationFacetOperationIdentity, "capabilityId" | "instanceKey" | "facetKey">,
+): string {
+  return `facet:${sha256(`${input.capabilityId}\0${input.instanceKey}\0${input.facetKey}`)}`;
+}
+
+async function hydrateFacetOperationResult<T extends Record<string, unknown>>(
+  db: Database,
+  input: { capabilityId: string; instanceKey: string; facetKey: string },
+  result: T,
+): Promise<T> {
+  const binding = recordValue(result.binding);
+  if (!binding) return result;
+  if (typeof binding.directlyOwned === "boolean" && Array.isArray(binding.owners)) return result;
+
+  const expectedOwner = facetOwner(input.capabilityId, input.instanceKey, input.facetKey);
+  let owners =
+    typeof binding.id === "string" ? await listIntegrationFacetBindingOwners(db, binding.id) : [];
+  if (owners.length === 0) {
+    owners = capabilityComponentOwners(result.remainingOwners);
+  }
+  if (
+    owners.length === 0 &&
+    (result.status === "configured" || result.status === "paused" || result.status === "active")
+  ) {
+    owners = [expectedOwner];
+  }
+  return {
+    ...result,
+    binding: {
+      ...binding,
+      directlyOwned: owners.some(
+        (owner) => owner.kind === expectedOwner.kind && owner.id === expectedOwner.id,
+      ),
+      owners,
+    },
+  } as T;
+}
+
+function capabilityComponentOwners(value: unknown): IntegrationFacetBindingOwner[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const owner = recordValue(entry);
+    if (
+      !owner ||
+      (owner.kind !== "direct" &&
+        owner.kind !== "plugin" &&
+        owner.kind !== "pack" &&
+        owner.kind !== "migration") ||
+      typeof owner.id !== "string" ||
+      typeof owner.removable !== "boolean"
+    ) {
+      return [];
+    }
+    return [{ kind: owner.kind, id: owner.id, removable: owner.removable }];
+  });
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
 async function requireMutationContext(
   db: Database,
   input: {
@@ -705,7 +899,12 @@ type BindingSummaryRow = Pick<
   kind: string;
 };
 
-function bindingSummary(row: BindingSummaryRow): IntegrationFacetBindingSummary {
+function bindingSummary(
+  row: BindingSummaryRow,
+  owners: IntegrationFacetBindingOwner[],
+  identity: { capabilityId: string; instanceKey: string; facetKey: string },
+): IntegrationFacetBindingSummary {
+  const expectedOwner = facetOwner(identity.capabilityId, identity.instanceKey, identity.facetKey);
   return {
     id: row.id,
     facetKey: row.facetKey,
@@ -721,6 +920,10 @@ function bindingSummary(row: BindingSummaryRow): IntegrationFacetBindingSummary
     lastErrorCode: row.lastErrorCode,
     createdAt: row.createdAt.toISOString(),
     updatedAt: row.updatedAt.toISOString(),
+    directlyOwned: owners.some(
+      (owner) => owner.kind === expectedOwner.kind && owner.id === expectedOwner.id,
+    ),
+    owners,
   };
 }