@powerhousedao/reactor 4.1.0-dev.42 → 4.1.0-dev.43

package/dist/src/reactor.js

@@ -20,10 +20,20 @@ import { filterByParentId, filterByType } from "./utils.js";
  */
 export class Reactor {
     driveServer;
+    documentStorage;
     shutdownStatus;
     setShutdown;
-    constructor(driveServer) {
+    eventBus;
+    queue;
+    jobExecutor;
+    jobExecutorStarted = false;
+    constructor(driveServer, documentStorage, eventBus, queue, jobExecutor) {
+        // Store required dependencies
         this.driveServer = driveServer;
+        this.documentStorage = documentStorage;
+        this.eventBus = eventBus;
+        this.queue = queue;
+        this.jobExecutor = jobExecutor;
         // Create mutable shutdown status using factory method
         const [status, setter] = createMutableShutdownStatus(false);
         this.shutdownStatus = status;
@@ -83,12 +93,11 @@ export class Reactor {
      * Retrieves a specific PHDocument by id
      */
     async get(id, view, signal) {
-        const document = await this.driveServer.getDocument(id);
-        // this should be thrown by the storage layer
-        if (!document) {
-            throw new Error(`Document not found: ${id}`);
+        const document = await this.documentStorage.get(id);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        const childIds = await this.driveServer.getDocuments(id);
+        const childIds = await this.documentStorage.getChildren(id);
         if (signal?.aborted) {
             throw new AbortError();
         }
@@ -96,7 +105,6 @@ export class Reactor {
         // to the underlying store, but is here now for the interface.
         for (const scope in document.state) {
             if (!matchesScope(view, scope)) {
-                // eslint-disable-next-line
                 delete document.state[scope];
             }
         }
@@ -109,40 +117,30 @@ export class Reactor {
      * Retrieves a specific PHDocument by slug
      */
     async getBySlug(slug, view, signal) {
-        // Get all drives
-        const drives = await this.driveServer.getDrives();
-        // Search through drives to find a document with the matching slug
-        for (const driveId of drives) {
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const documentIds = await this.driveServer.getDocuments(driveId);
-            for (const docId of documentIds) {
-                const document = await this.driveServer.getDocument(docId);
-                if (document.header.slug === slug) {
-                    const childIds = await this.driveServer.getDocuments(docId);
-                    if (signal?.aborted) {
-                        throw new AbortError();
-                    }
-                    // Apply view filter - This will be removed when we pass the viewfilter along
-                    // to the underlying store, but is here now for the interface.
-                    for (const scope in document.state) {
-                        if (!matchesScope(view, scope)) {
-                            // eslint-disable-next-line
-                            delete document.state[scope];
-                        }
-                    }
-                    return { document, childIds };
-                }
+        // Use the storage layer to resolve slug to ID
+        let ids;
+        try {
+            ids = await this.documentStorage.resolveIds([slug], signal);
+        }
+        catch (error) {
+            // If the error is from resolveIds (document not found), wrap it with our message
+            if (error instanceof Error && error.message.includes("not found")) {
+                throw new Error(`Document not found with slug: ${slug}`);
             }
+            throw error;
         }
-        throw new Error(`Document not found with slug: ${slug}`);
+        if (ids.length === 0 || !ids[0]) {
+            throw new Error(`Document not found with slug: ${slug}`);
+        }
+        // Now get the document by its resolved ID
+        return await this.get(ids[0], view, signal);
     }
     /**
      * Retrieves the operations for a document
      */
     async getOperations(documentId, view, paging, signal) {
-        const document = await this.driveServer.getDocument(documentId);
+        // Use storage directly to get the document
+        const document = await this.documentStorage.get(documentId);
         if (signal?.aborted) {
             throw new AbortError();
         }
@@ -201,8 +199,7 @@ export class Reactor {
             results = await this.findByType(search.type, view, paging, signal);
         }
         else {
-            // Empty search filter - return all documents
-            results = await this.findAll(view, paging, signal);
+            throw new Error("No search criteria provided");
         }
         if (signal?.aborted) {
             throw new AbortError();
@@ -217,14 +214,17 @@ export class Reactor {
             // BaseDocumentDriveServer uses addDocument, not createDocument
             // addDocument adds an existing document to a drive
             await this.driveServer.addDocument(document);
-            // Return success status
-            // TODO: Phase 4 - This will return a job that goes through the queue
-            return JobStatus.COMPLETED;
         }
-        catch (error) {
+        catch {
             // TODO: Phase 4 - This will return a job that can be retried
             return JobStatus.FAILED;
         }
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // Return success status
+        // TODO: Phase 4 - This will return a job that goes through the queue
+        return JobStatus.COMPLETED;
     }
     /**
      * Deletes a document
@@ -235,12 +235,6 @@ export class Reactor {
             // Delete document using drive server
             await this.driveServer.deleteDocument(id);
             // TODO: Implement cascade deletion when propagate mode is CASCADE
-            // Return success job info
-            // TODO: Phase 4 - This will return a job that goes through the queue
-            return {
-                id: jobId,
-                status: JobStatus.COMPLETED,
-            };
         }
         catch (error) {
             // TODO: Phase 4 - This will return a job that can be retried
@@ -250,60 +244,63 @@ export class Reactor {
                 error: error instanceof Error ? error.message : "Unknown error",
             };
         }
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // Return success job info
+        // TODO: Phase 4 - This will return a job that goes through the queue
+        return {
+            id: jobId,
+            status: JobStatus.COMPLETED,
+        };
     }
     /**
      * Applies a list of actions to a document
      */
     async mutate(id, actions) {
-        const jobId = uuidv4();
-        try {
-            // BaseDocumentDriveServer expects Operations, not Actions
-            // We need to convert Actions to Operations
-            const operations = actions.map((action, index) => ({
+        // Ensure the job executor is running
+        await this.ensureJobExecutorRunning();
+        // Create jobs for each action/operation
+        const jobs = actions.map((action, index) => ({
+            id: uuidv4(),
+            documentId: id,
+            scope: action.scope || "global",
+            branch: "main", // Default to main branch
+            operation: {
                 index: index,
-                timestampUtcMs: action.timestampUtcMs,
-                hash: "", // Will be computed by the server
+                timestampUtcMs: String(action.timestampUtcMs || Date.now()),
+                hash: "", // Will be computed by the executor
                 skip: 0,
                 action: action,
-            }));
-            // Apply operations to document
-            await this.driveServer.addOperations(id, operations);
-            // Return success job info
-            // TODO: Phase 4 - This will return a job that goes through the queue
-            return {
-                id: jobId,
-                status: JobStatus.COMPLETED,
-            };
-        }
-        catch (error) {
-            // TODO: Phase 4 - This will return a job that can be retried
-            return {
-                id: jobId,
-                status: JobStatus.FAILED,
-                error: error instanceof Error ? error.message : "Unknown error",
-            };
+            },
+            createdAt: new Date().toISOString(),
+            maxRetries: 3,
+        }));
+        // Enqueue all jobs
+        for (const job of jobs) {
+            await this.queue.enqueue(job);
         }
+        // Return job info for the batch (using the first job's ID as the batch ID)
+        const batchJobId = jobs.length > 0 ? jobs[0].id : uuidv4();
+        return {
+            id: batchJobId,
+            status: JobStatus.PENDING,
+        };
     }
     /**
      * Adds multiple documents as children to another
      */
     async addChildren(parentId, documentIds, view, signal) {
         const jobId = uuidv4();
+        // Check abort signal before starting
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // TODO: Implement when drive server supports hierarchical documents
+        // For now, this is a placeholder implementation
+        // Verify parent exists
         try {
-            // TODO: Implement when drive server supports hierarchical documents
-            // For now, this is a placeholder implementation
-            // Verify parent exists
             await this.driveServer.getDocument(parentId);
-            // Verify all children exist
-            for (const childId of documentIds) {
-                await this.driveServer.getDocument(childId);
-            }
-            // TODO: Actually establish parent-child relationships
-            // Return success job info
-            return {
-                id: jobId,
-                status: JobStatus.COMPLETED,
-            };
         }
         catch (error) {
             return {
@@ -312,23 +309,48 @@ export class Reactor {
                 error: error instanceof Error ? error.message : "Unknown error",
             };
         }
+        // Check abort signal after parent verification
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // Verify all children exist
+        for (const childId of documentIds) {
+            try {
+                await this.driveServer.getDocument(childId);
+            }
+            catch (error) {
+                return {
+                    id: jobId,
+                    status: JobStatus.FAILED,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                };
+            }
+            // Check abort signal after each child verification
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+        }
+        // TODO: Actually establish parent-child relationships
+        // Return success job info
+        return {
+            id: jobId,
+            status: JobStatus.COMPLETED,
+        };
     }
     /**
      * Removes multiple documents as children from another
      */
     async removeChildren(parentId, documentIds, view, signal) {
         const jobId = uuidv4();
+        // Check abort signal before starting
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // TODO: Implement when drive server supports hierarchical documents
+        // For now, this is a placeholder implementation
+        // Verify parent exists
         try {
-            // TODO: Implement when drive server supports hierarchical documents
-            // For now, this is a placeholder implementation
-            // Verify parent exists
             await this.driveServer.getDocument(parentId);
-            // TODO: Actually remove parent-child relationships
-            // Return success job info
-            return {
-                id: jobId,
-                status: JobStatus.COMPLETED,
-            };
         }
         catch (error) {
             return {
@@ -337,6 +359,16 @@ export class Reactor {
                 error: error instanceof Error ? error.message : "Unknown error",
             };
         }
+        // Check abort signal after parent verification
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // TODO: Actually remove parent-child relationships
+        // Return success job info
+        return {
+            id: jobId,
+            status: JobStatus.COMPLETED,
+        };
     }
     /**
      * Retrieves the status of a job
@@ -350,36 +382,46 @@ export class Reactor {
             error: "Job tracking not yet implemented",
         };
     }
+    /**
+     * Starts the job executor if not already running.
+     * Called automatically when the first job is enqueued.
+     */
+    async ensureJobExecutorRunning() {
+        if (!this.jobExecutorStarted) {
+            await this.jobExecutor.start({
+                maxConcurrency: 5,
+                jobTimeout: 30000,
+            });
+            this.jobExecutorStarted = true;
+        }
+    }
     /**
      * Finds documents by their IDs
      */
     async findByIds(ids, view, paging, signal) {
         const documents = [];
-        // Fetch each document by ID
+        // Fetch each document by ID using storage directly
         for (const id of ids) {
             if (signal?.aborted) {
                 throw new AbortError();
             }
+            let document;
             try {
-                const document = await this.driveServer.getDocument(id);
-                if (!document) {
-                    continue; // Skip if document not found
-                }
-                // Apply view filter - This will be removed when we pass the viewfilter along
-                // to the underlying store, but is here now for the interface.
-                for (const scope in document.state) {
-                    if (!matchesScope(view, scope)) {
-                        // eslint-disable-next-line
-                        delete document.state[scope];
-                    }
-                }
-                documents.push(document);
+                document = await this.documentStorage.get(id);
             }
             catch {
                 // Skip documents that don't exist or can't be accessed
                 // This matches the behavior expected from a search operation
                 continue;
             }
+            // Apply view filter - This will be removed when we pass the viewfilter along
+            // to the underlying store, but is here now for the interface.
+            for (const scope in document.state) {
+                if (!matchesScope(view, scope)) {
+                    delete document.state[scope];
+                }
+            }
+            documents.push(document);
         }
         if (signal?.aborted) {
             throw new AbortError();
@@ -405,92 +447,43 @@ export class Reactor {
      */
     async findBySlugs(slugs, view, paging, signal) {
         const documents = [];
-        // Fetch each document by slug
-        for (const slug of slugs) {
+        // Use storage to resolve slugs to IDs
+        let ids;
+        try {
+            ids = await this.documentStorage.resolveIds(slugs, signal);
+        }
+        catch {
+            // If slug resolution fails, return empty results
+            // This matches the behavior expected from a search operation
+            ids = [];
+        }
+        // Fetch each document by resolved ID
+        for (const id of ids) {
             if (signal?.aborted) {
                 throw new AbortError();
             }
+            let document;
             try {
-                // Search through drives to find a document with the matching slug
-                const drives = await this.driveServer.getDrives();
-                let found = false;
-                for (const driveId of drives) {
-                    const documentIds = await this.driveServer.getDocuments(driveId);
-                    for (const docId of documentIds) {
-                        const document = await this.driveServer.getDocument(docId);
-                        if (document && document.header.slug === slug) {
-                            // Apply view filter - This will be removed when we pass the viewfilter along
-                            // to the underlying store, but is here now for the interface.
-                            for (const scope in document.state) {
-                                if (!matchesScope(view, scope)) {
-                                    // eslint-disable-next-line
-                                    delete document.state[scope];
-                                }
-                            }
-                            documents.push(document);
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (found)
-                        break;
-                }
+                document = await this.documentStorage.get(id);
             }
             catch {
                 // Skip documents that don't exist or can't be accessed
-                // This matches the behavior expected from a search operation
                 continue;
             }
-        }
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        // Apply paging
-        const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-        const limit = paging?.limit || documents.length;
-        const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-        // Create paged results
-        const hasMore = startIndex + limit < documents.length;
-        const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-        return {
-            results: pagedDocuments,
-            options: paging || { cursor: "0", limit: documents.length },
-            nextCursor,
-            next: hasMore
-                ? () => this.findBySlugs(slugs, view, { cursor: nextCursor, limit }, signal)
-                : undefined,
-        };
-    }
-    /**
-     * Finds all documents
-     */
-    async findAll(view, paging, signal) {
-        const documents = [];
-        // Get all drives
-        const drives = await this.driveServer.getDrives();
-        for (const driveId of drives) {
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const documentIds = await this.driveServer.getDocuments(driveId);
-            for (const docId of documentIds) {
-                const document = await this.driveServer.getDocument(docId);
-                if (document) {
-                    // Apply view filter
-                    for (const scope in document.state) {
-                        if (!matchesScope(view, scope)) {
-                            // eslint-disable-next-line
-                            delete document.state[scope];
-                        }
-                    }
-                    documents.push(document);
+            // Apply view filter - This will be removed when we pass the viewfilter along
+            // to the underlying store, but is here now for the interface.
+            for (const scope in document.state) {
+                if (!matchesScope(view, scope)) {
+                    delete document.state[scope];
                 }
             }
+            documents.push(document);
         }
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // Apply paging
+        // Apply paging - this will be removed when we pass the paging along
+        // to the underlying store, but is here now for the interface.
         const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
         const limit = paging?.limit || documents.length;
         const pagedDocuments = documents.slice(startIndex, startIndex + limit);
@@ -502,7 +495,7 @@ export class Reactor {
             options: paging || { cursor: "0", limit: documents.length },
             nextCursor,
             next: hasMore
-                ? async () => this.findAll(view, { cursor: nextCursor, limit }, signal)
+                ? () => this.findBySlugs(slugs, view, { cursor: nextCursor, limit }, signal)
                 : undefined,
         };
     }
@@ -510,8 +503,8 @@ export class Reactor {
      * Finds documents by parent ID
      */
     async findByParentId(parentId, view, paging, signal) {
-        // Get child document IDs from the drive server
-        const childIds = await this.driveServer.getDocuments(parentId);
+        // Get child document IDs from storage
+        const childIds = await this.documentStorage.getChildren(parentId);
         if (signal?.aborted) {
             throw new AbortError();
         }
@@ -521,23 +514,23 @@ export class Reactor {
             if (signal?.aborted) {
                 throw new AbortError();
             }
+            let document;
             try {
-                const document = await this.driveServer.getDocument(childId);
-                // Apply view filter - This will be removed when we pass the viewfilter along
-                // to the underlying store, but is here now for the interface.
-                for (const scope in document.state) {
-                    if (!matchesScope(view, scope)) {
-                        // eslint-disable-next-line
-                        delete document.state[scope];
-                    }
-                }
-                documents.push(document);
+                document = await this.documentStorage.get(childId);
             }
             catch {
                 // Skip documents that don't exist or can't be accessed
                 // This matches the behavior expected from a search operation
                 continue;
             }
+            // Apply view filter - This will be removed when we pass the viewfilter along
+            // to the underlying store, but is here now for the interface.
+            for (const scope in document.state) {
+                if (!matchesScope(view, scope)) {
+                    delete document.state[scope];
+                }
+            }
+            documents.push(document);
         }
         if (signal?.aborted) {
             throw new AbortError();
@@ -563,42 +556,44 @@ export class Reactor {
      */
     async findByType(type, view, paging, signal) {
         const documents = [];
-        // Get all drives
-        const drives = await this.driveServer.getDrives();
-        for (const driveId of drives) {
+        // Use storage's findByType method directly
+        const cursor = paging?.cursor;
+        const limit = paging?.limit || 100;
+        // Get document IDs of the specified type
+        const { documents: documentIds, nextCursor } = await this.documentStorage.findByType(type, limit, cursor);
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        // Fetch each document by its ID
+        for (const documentId of documentIds) {
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            const documentIds = await this.driveServer.getDocuments(driveId);
-            for (const docId of documentIds) {
-                const document = await this.driveServer.getDocument(docId);
-                if (document && document.header.documentType === type) {
-                    // Apply view filter
-                    for (const scope in document.state) {
-                        if (!matchesScope(view, scope)) {
-                            // eslint-disable-next-line
-                            delete document.state[scope];
-                        }
-                    }
-                    documents.push(document);
+            let document;
+            try {
+                document = await this.documentStorage.get(documentId);
+            }
+            catch {
+                // Skip documents that can't be retrieved
+                continue;
+            }
+            // Apply view filter
+            for (const scope in document.state) {
+                if (!matchesScope(view, scope)) {
+                    delete document.state[scope];
                 }
             }
+            documents.push(document);
         }
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // Apply paging
-        const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-        const limit = paging?.limit || documents.length;
-        const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-        // Create paged results
-        const hasMore = startIndex + limit < documents.length;
-        const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+        // Results are already paged from the storage layer
         return {
-            results: pagedDocuments,
-            options: paging || { cursor: "0", limit: documents.length },
+            results: documents,
+            options: paging || { cursor: cursor || "0", limit },
             nextCursor,
-            next: hasMore
+            next: nextCursor
                 ? async () => this.findByType(type, view, { cursor: nextCursor, limit }, signal)
                 : undefined,
         };