@highstate/backend 0.19.1 → 0.20.0

package/src/business/index.ts

@@ -1,8 +1,11 @@
 export * from "./api-key"
 export * from "./artifact"
 export * from "./backend-unlock"
+export * from "./entity-snapshot"
+export * from "./global-search"
 export * from "./instance-lock"
 export * from "./instance-state"
+export * from "./object-ref-index"
 export * from "./operation"
 export * from "./project"
 export * from "./project-model"
@@ -11,4 +14,5 @@ export * from "./secret"
 export * from "./settings"
 export * from "./terminal-session"
 export * from "./unit-extra"
+export * from "./unit-output"
 export * from "./worker"

package/src/business/instance-lock.ts

@@ -260,79 +260,59 @@ export class InstanceLockService {
     let remainingStateIds = [...stateIds]
     const lockedStateIds: string[] = []
 
-    // create abort controller for managing event subscription
-    const subscriptionController = new AbortController()
+    while (remainingStateIds.length > 0) {
+      if (abortSignal?.aborted) {
+        throw new Error("Lock operation was aborted")
+      }
 
-    // set up event subscription first before attempting any locks to reduce probability of missing events
-    const eventIterable = await this.pubsubManager.subscribe(
-      ["instance-lock", projectId],
-      subscriptionController.signal,
-    )
+      this.logger.debug(
+        {
+          projectId,
+          remainingCount: remainingStateIds.length,
+          lockedCount: lockedStateIds.length,
+        },
+        "attempting to lock %s remaining instances",
+        remainingStateIds.length,
+      )
 
-    try {
-      while (remainingStateIds.length > 0) {
-        if (abortSignal?.aborted) {
-          throw new Error("Lock operation was aborted")
-        }
+      // try to acquire locks on remaining instances using the same token
+      const [_, newlyLockedStateIds] = await this.tryLockInstances(
+        projectId,
+        remainingStateIds,
+        lockMeta,
+        action,
+        allowPartialLock,
+        token,
+      )
 
+      if (newlyLockedStateIds.length === 0) {
+        // no instances were locked, wait for unlock events
         this.logger.debug(
-          {
-            projectId,
-            remainingCount: remainingStateIds.length,
-            lockedCount: lockedStateIds.length,
-          },
-          "attempting to lock %s remaining instances",
+          { projectId, remainingCount: remainingStateIds.length },
+          "waiting for unlock events for %s remaining instances",
           remainingStateIds.length,
         )
 
-        // try to acquire locks on remaining instances using the same token
-        const [_, newlyLockedStateIds] = await this.tryLockInstances(
-          projectId,
-          remainingStateIds,
-          lockMeta,
-          action,
-          allowPartialLock,
-          token,
-        )
+        await this.waitForUnlockEvent(projectId, remainingStateIds, abortSignal, eventWaitTime)
+        continue
+      }
 
-        if (newlyLockedStateIds.length === 0) {
-          // no instances were locked, wait for unlock events
-          this.logger.debug(
-            { projectId, remainingCount: remainingStateIds.length },
-            "waiting for unlock events for %s remaining instances",
-            remainingStateIds.length,
-          )
+      // remove newly locked instances from remaining list
+      remainingStateIds = remainingStateIds.filter(id => !newlyLockedStateIds.includes(id))
+      lockedStateIds.push(...newlyLockedStateIds)
 
-          await this.waitForUnlockEvent(
-            projectId,
-            remainingStateIds,
-            eventIterable,
-            abortSignal,
-            eventWaitTime,
-          )
-          continue
-        }
-
-        // remove newly locked instances from remaining list
-        remainingStateIds = remainingStateIds.filter(id => !newlyLockedStateIds.includes(id))
-        lockedStateIds.push(...newlyLockedStateIds)
-
-        // if partial locking is not allowed, we should have all instances by now
-        if (!allowPartialLock && remainingStateIds.length > 0) {
-          this.logger.error(
-            { projectId, remaining: remainingStateIds.length },
-            "partial lock not allowed but %s instances remain unlocked",
-            remainingStateIds.length,
-          )
-          throw new Error("Failed to acquire all required locks")
-        }
+      // if partial locking is not allowed, we should have all instances by now
+      if (!allowPartialLock && remainingStateIds.length > 0) {
+        this.logger.error(
+          { projectId, remaining: remainingStateIds.length },
+          "partial lock not allowed but %s instances remain unlocked",
+          remainingStateIds.length,
+        )
+        throw new Error("Failed to acquire all required locks")
       }
-
-      return [token, lockedStateIds]
-    } finally {
-      // clean up event subscription
-      subscriptionController.abort()
     }
+
+    return [token, lockedStateIds]
   }
 
   /**
@@ -341,32 +321,36 @@ export class InstanceLockService {
    *
    * @param projectId The project ID to monitor for events.
    * @param stateIds The state IDs we're waiting to become available.
-   * @param eventIterable The async iterable for event subscription.
    * @param abortSignal Optional abort signal to interrupt waiting.
    * @param eventWaitTime Time in milliseconds to wait before timing out and retrying.
    */
   private async waitForUnlockEvent(
     projectId: string,
     stateIds: string[],
-    eventIterable: AsyncIterable<InstanceLockEvent>,
     abortSignal?: AbortSignal,
     eventWaitTime = 60000,
   ): Promise<void> {
-    const eventController = new AbortController()
+    const waitController = new AbortController()
+    const eventIterable = await this.pubsubManager.subscribe(
+      ["instance-lock", projectId],
+      waitController.signal,
+    )
 
     // combine abort signals
     if (abortSignal?.aborted) {
       throw new Error("Lock operation was aborted")
     }
 
-    const abortHandler = () => eventController.abort()
+    const abortHandler = () => waitController.abort()
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+
     abortSignal?.addEventListener("abort", abortHandler)
 
     try {
       await Promise.race([
         // timeout promise - triggers retry attempt, does not abort
         new Promise<void>(resolve => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             this.logger.debug(
               { projectId, eventWaitTime },
               "unlock wait timed out after %s ms, will retry",
@@ -377,7 +361,7 @@ export class InstanceLockService {
         }),
 
         // event listener promise
-        this.listenForUnlockEvents(projectId, stateIds, eventIterable, eventController.signal),
+        this.listenForUnlockEvents(projectId, stateIds, eventIterable),
 
         // abort promise - only this can interrupt the operation
         new Promise<void>((_, reject) => {
@@ -389,7 +373,12 @@ export class InstanceLockService {
         }),
       ])
     } finally {
-      eventController.abort()
+      waitController.abort()
+
+      if (timeoutId) {
+        clearTimeout(timeoutId)
+      }
+
       abortSignal?.removeEventListener("abort", abortHandler)
     }
   }
@@ -400,18 +389,13 @@ export class InstanceLockService {
    * @param projectId The project ID to monitor for events.
    * @param stateIds The state IDs we're waiting to become available.
    * @param eventIterable The async iterable for event subscription.
-   * @param signal Abort signal to stop listening.
    */
   private async listenForUnlockEvents(
     projectId: string,
     stateIds: string[],
     eventIterable: AsyncIterable<InstanceLockEvent>,
-    signal: AbortSignal,
   ): Promise<void> {
     for await (const event of eventIterable) {
-      if (signal.aborted) {
-        break
-      }
       if (event.type !== "unlocked") {
         continue // only interested in unlock events
       }

package/src/business/instance-state.test.ts

@@ -2,6 +2,7 @@ import type { InstanceId, InstanceModel } from "@highstate/contract"
 import type { ArtifactService } from "../artifact"
 import type { PubSubManager } from "../pubsub"
 import type { RunnerBackend } from "../runner"
+import type { ObjectRefIndexService } from "./object-ref-index"
 import type { ProjectService } from "./project"
 import type { SecretService } from "./secret"
 import type { UnitExtraService } from "./unit-extra"
@@ -21,6 +22,7 @@ const instanceStateTest = test.extend<{
   artifactService: MockedObject<ArtifactService>
   unitExtraService: MockedObject<UnitExtraService>
   secretService: MockedObject<SecretService>
+  objectRefIndexService: MockedObject<ObjectRefIndexService>
   instanceStateService: InstanceStateService
 }>({
   pubsubManager: async ({}, use) => {
@@ -52,6 +54,7 @@ const instanceStateTest = test.extend<{
   workerService: async ({}, use) => {
     const workerService = vi.mockObject({
       cleanupWorkerUsageAndSync: vi.fn().mockResolvedValue(undefined),
+      updateUnitRegistrations: vi.fn().mockResolvedValue([]),
     } as unknown as WorkerService)
 
     await use(workerService)
@@ -76,10 +79,19 @@ const instanceStateTest = test.extend<{
   },
 
   secretService: async ({}, use) => {
-    const secretService = vi.mockObject({} as unknown as SecretService)
+    const secretService = vi.mockObject({
+      updateInstanceSecretsCore: vi.fn().mockResolvedValue({ secretNames: [], secretIds: [] }),
+    } as unknown as SecretService)
     await use(secretService)
   },
 
+  objectRefIndexService: async ({}, use) => {
+    const objectRefIndexService = vi.mockObject({
+      track: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ObjectRefIndexService)
+    await use(objectRefIndexService)
+  },
+
   instanceStateService: async (
     {
       database,
@@ -89,6 +101,7 @@ const instanceStateTest = test.extend<{
       artifactService,
       unitExtraService,
       secretService,
+      objectRefIndexService,
       logger,
     },
     use,
@@ -101,6 +114,7 @@ const instanceStateTest = test.extend<{
       artifactService,
       unitExtraService,
       secretService,
+      objectRefIndexService,
       logger.child({ service: "InstanceStateService" }),
     )
 

package/src/business/instance-state.ts

@@ -10,6 +10,7 @@ import type { ArtifactService } from "../artifact"
 import type { SecretService, UnitExtraService, WorkerService } from "../business"
 import type { PubSubManager } from "../pubsub"
 import type { RunnerBackend } from "../runner"
+import type { ObjectRefIndexService } from "./object-ref-index"
 import { type InstanceId, parseInstanceId } from "@highstate/contract"
 import { isNonNullish, omit } from "remeda"
 import {
@@ -103,6 +104,7 @@ export type InstanceStatePatch = Pick<
   | "resolvedInputs"
   | "currentResourceCount"
   | "exportedArtifactIds"
+  | "hasResourceHooks"
 >
 
 export type UpdateOperationStateOptions = {
@@ -220,6 +222,7 @@ export class InstanceStateService {
     private readonly artifactService: ArtifactService,
     private readonly unitExtraService: UnitExtraService,
     private readonly secretService: SecretService,
+    private readonly objectRefIndexService: ObjectRefIndexService,
     private readonly logger: Logger,
   ) {}
 
@@ -667,6 +670,7 @@ export class InstanceStateService {
 
     const result = await database.$transaction(async tx => {
       let unitExtraData = null
+      let unitExtraTrackingIds: string[] = []
 
       // update operation state
       const updatedOperationState = await tx.instanceOperationState.update({
@@ -690,20 +694,35 @@ export class InstanceStateService {
 
       // update unit-specific data if provided
       if (unitExtra) {
-        const [pageIds, terminalIds, triggerIds, secretNames] = await Promise.all([
-          this.unitExtraService.processUnitPages(tx, stateId, unitExtra.pages),
-          this.unitExtraService.processUnitTerminals(tx, stateId, unitExtra.terminals),
-          this.unitExtraService.processUnitTriggers(tx, stateId, unitExtra.triggers),
-          this.secretService.updateInstanceSecretsCore(
-            tx,
-            project.libraryId,
-            stateId,
-            unitExtra.secrets,
-          ),
-          this.workerService.updateUnitRegistrations(tx, projectId, stateId, unitExtra.workers),
-        ])
+        const [pageIds, terminalIds, triggerIds, secretUpdate, workerObjectIds] = await Promise.all(
+          [
+            this.unitExtraService.processUnitPages(tx, stateId, unitExtra.pages),
+            this.unitExtraService.processUnitTerminals(tx, stateId, unitExtra.terminals),
+            this.unitExtraService.processUnitTriggers(tx, stateId, unitExtra.triggers),
+            this.secretService.updateInstanceSecretsCore(
+              tx,
+              project.libraryId,
+              stateId,
+              unitExtra.secrets,
+            ),
+            this.workerService.updateUnitRegistrations(tx, projectId, stateId, unitExtra.workers),
+          ],
+        )
+
+        unitExtraData = {
+          pageIds,
+          terminalIds,
+          triggerIds,
+          secretNames: secretUpdate.secretNames,
+        }
 
-        unitExtraData = { pageIds, terminalIds, triggerIds, secretNames }
+        unitExtraTrackingIds = [
+          ...pageIds,
+          ...terminalIds,
+          ...triggerIds,
+          ...secretUpdate.secretIds,
+          ...workerObjectIds,
+        ]
 
         if (unitExtra.artifactIds !== undefined) {
           await this.unitExtraService.pruneInstanceArtifacts(tx, stateId, unitExtra.artifactIds)
@@ -718,9 +737,13 @@ export class InstanceStateService {
         })
       }
 
-      return { updatedOperationState, unitExtraData }
+      return { updatedOperationState, unitExtraData, unitExtraTrackingIds }
     })
 
+    if (result.unitExtraTrackingIds.length > 0) {
+      await this.objectRefIndexService.track(projectId, result.unitExtraTrackingIds)
+    }
+
     if (options.unitExtra?.artifactIds !== undefined) {
       await this.artifactService.collectGarbage(projectId)
     }

package/src/business/object-ref-index.test.ts

@@ -0,0 +1,140 @@
+import { createId } from "@paralleldrive/cuid2"
+import { describe, expect } from "vitest"
+import { test } from "../test-utils/services"
+import { ObjectRefIndexService } from "./object-ref-index"
+
+describe(ObjectRefIndexService.name, () => {
+  test("track inserts unique ids and ignores blanks", async ({ database, project, logger }) => {
+    const service = new ObjectRefIndexService(database, logger)
+
+    const id1 = createId()
+    const id2 = createId()
+
+    await service.track(project.id, [id1, `  ${id1}  `, "", "   ", id2])
+    await service.track(project.id, [id1, id2])
+
+    const refs = await database.backend.object.findMany({
+      where: { projectId: project.id },
+      select: { id: true },
+    })
+
+    expect(refs.map(r => r.id).sort()).toEqual([id1, id2].sort())
+  })
+
+  test("syncProject indexes curated object ids", async ({
+    database,
+    projectDatabase,
+    project,
+    logger,
+  }) => {
+    const service = new ObjectRefIndexService(database, logger)
+
+    const operation = await projectDatabase.operation.create({
+      data: {
+        meta: { title: "op" },
+        type: "update",
+        options: {},
+        requestedInstanceIds: [],
+      },
+      select: { id: true },
+    })
+
+    const state = await projectDatabase.instanceState.create({
+      data: {
+        instanceId: `component.v1:${createId()}`,
+        kind: "unit",
+        status: "undeployed",
+        source: "resident",
+      },
+      select: { id: true },
+    })
+
+    const artifact = await projectDatabase.artifact.create({
+      data: {
+        meta: { title: "artifact" },
+        hash: `sha256:${createId()}`,
+        size: 1,
+        chunkSize: 1,
+      },
+      select: { id: true },
+    })
+
+    const page = await projectDatabase.page.create({
+      data: {
+        meta: { title: "page" },
+        content: [],
+      },
+      select: { id: true },
+    })
+
+    const secret = await projectDatabase.secret.create({
+      data: {
+        meta: { title: "secret" },
+        content: { value: "x" },
+      },
+      select: { id: true },
+    })
+
+    const serviceAccount = await projectDatabase.serviceAccount.create({
+      data: {
+        meta: { title: "sa" },
+      },
+      select: { id: true },
+    })
+
+    const apiKey = await projectDatabase.apiKey.create({
+      data: {
+        meta: { title: "key" },
+        serviceAccountId: serviceAccount.id,
+        token: createId(),
+      },
+      select: { id: true },
+    })
+
+    await service.syncProject(project.id)
+
+    const refs = await database.backend.object.findMany({
+      where: { projectId: project.id },
+      select: { id: true },
+    })
+
+    const refIds = new Set(refs.map(r => r.id))
+    expect(refIds).toContain(operation.id)
+    expect(refIds).toContain(state.id)
+    expect(refIds).toContain(artifact.id)
+    expect(refIds).toContain(page.id)
+    expect(refIds).toContain(secret.id)
+    expect(refIds).toContain(serviceAccount.id)
+    expect(refIds).toContain(apiKey.id)
+  })
+
+  test("syncProject prunes stale object ids", async ({
+    database,
+    projectDatabase,
+    project,
+    logger,
+  }) => {
+    const service = new ObjectRefIndexService(database, logger)
+
+    const operation = await projectDatabase.operation.create({
+      data: {
+        meta: { title: "op" },
+        type: "update",
+        options: {},
+        requestedInstanceIds: [],
+      },
+      select: { id: true },
+    })
+
+    await service.syncProject(project.id)
+    await projectDatabase.operation.delete({ where: { id: operation.id } })
+    await service.syncProject(project.id)
+
+    const refs = await database.backend.object.findMany({
+      where: { projectId: project.id, id: operation.id },
+      select: { id: true },
+    })
+
+    expect(refs).toHaveLength(0)
+  })
+})