@opengeni/db 6.0.1 → 6.0.3

package/src/browser-sessions.ts

@@ -266,6 +266,11 @@ function associationFromRow(row: BrowserAssociationRow) {
   } as const;
 }
 
+/** Legacy resources predate permission control; absence must never advertise support. */
+export function readStoredBrowserCapabilities(value: Record<string, unknown>) {
+  return BrowserSessionCapabilities.parse({ permissions: false, ...value });
+}
+
 function browserSessionFromRows(
   row: BrowserSessionRow,
   associations: readonly BrowserAssociationRow[],
@@ -286,7 +291,7 @@ function browserSessionFromRows(
     baseRevisionId: row.baseRevisionId,
     networkRouteId: row.networkRouteId,
     linkedComputerSessionId: row.linkedComputerSessionId,
-    capabilities: row.capabilities,
+    capabilities: readStoredBrowserCapabilities(row.capabilities),
     associations: associations.map(associationFromRow),
     createdBySubjectId: row.createdBySubjectId,
     createdAt: iso(row.createdAt),
@@ -1463,6 +1468,71 @@ export async function prepareBrowserSessionSuspend(
   });
 }
 
+/** Restore the active controller when placement fails before a suspend was dispatched. */
+export async function failPreparedBrowserSessionSuspend(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    error: InteractionErrorValue;
+  },
+): Promise<BrowserSessionMutationResponseValue | null> {
+  const error = InteractionError.parse(input.error);
+  return await withRlsContext(
+    db,
+    input,
+    async (scopedDb) =>
+      await scopedDb.transaction(async (txRaw) => {
+        const tx = txRaw as unknown as Database;
+        await lockOperation(tx, input.workspaceId, input.operationId);
+        const operation = await loadOperation(tx, input.workspaceId, input.operationId);
+        assertOperationResource(operation, input.browserSessionId, "suspend");
+        if (operation.state !== "prepared" || operation.dispatchedAt) return null;
+
+        await lockBrowserSession(tx, input.workspaceId, input.browserSessionId);
+        const now = new Date();
+        const [sessionRow] = await tx
+          .update(schema.browserSessions)
+          .set({ lifecycle: "active", failureCode: null, updatedAt: now })
+          .where(
+            and(
+              eq(schema.browserSessions.workspaceId, input.workspaceId),
+              eq(schema.browserSessions.id, input.browserSessionId),
+              eq(schema.browserSessions.lifecycle, "suspending"),
+            ),
+          )
+          .returning();
+        if (!sessionRow) {
+          throw new BrowserSessionStateError("Prepared BrowserSession suspension changed state");
+        }
+        const [operationRow] = await tx
+          .update(schema.interactionOperations)
+          .set({
+            state: "failed",
+            errorCode: error.code,
+            errorMessage: error.message,
+            errorRetryable: error.retryable,
+            errorDetails: error.details ?? null,
+            settledAt: now,
+            updatedAt: now,
+          })
+          .where(eq(schema.interactionOperations.operationId, input.operationId))
+          .returning();
+        if (!operationRow) throw new Error("BrowserSession failure receipt was lost");
+        const associations = await loadAssociations(tx, input.workspaceId, [
+          input.browserSessionId,
+        ]);
+        await advanceWorkspaceInteractionRevision(tx, input.accountId, input.workspaceId);
+        return BrowserSessionMutationResponse.parse({
+          session: browserSessionFromRows(sessionRow, associations),
+          operation: operationReceipt(operationRow, false),
+        });
+      }),
+  );
+}
+
 export async function prepareBrowserSessionResume(
   db: Database,
   input: PrepareBrowserSessionLifecycleInput,

package/src/database.ts

@@ -67,6 +67,24 @@ export function currentSessionAttachmentReadAccess(): SessionAttachmentReadAcces
   return sessionRlsActorContext.getStore()?.sessionAttachmentReadAccess;
 }
 
+/**
+ * Stable identity of the ambient session RLS actor: every field that
+ * `setRlsContext` turns into database-visible GUCs or that scoped reads
+ * consult. Two callers with equal keys see exactly the same rows, so the key
+ * is safe for sharing a read result between them; `null` means no actor, in
+ * which case the subject GUC stays empty for every such caller.
+ */
+export function currentSessionRlsActorIdentityKey(): string | null {
+  const actor = sessionRlsActorContext.getStore();
+  if (!actor) return null;
+  return JSON.stringify([
+    actor.subjectId,
+    actor.initiatingHumanSubjectId ?? null,
+    actor.privateFileOwnerSubjectId ?? null,
+    actor.sessionAttachmentReadAccess ?? null,
+  ]);
+}
+
 export async function withSessionRlsActorContext<T>(
   actor: SessionRlsActorContext,
   fn: () => Promise<T>,