@powerhousedao/reactor 6.0.0-dev.26 → 6.0.0-dev.28

package/dist/src/core/reactor.js

@@ -5,7 +5,7 @@ import { ReactorEventTypes } from "../events/types.js";
 import { createMutableShutdownStatus } from "../shared/factories.js";
 import { JobStatus } from "../shared/types.js";
 import { matchesScope } from "../shared/utils.js";
-import { filterByType, getSharedScope, signAction, signActions, toErrorInfo, topologicalSort, validateActionScopes, validateBatchRequest, } from "./utils.js";
+import { filterByType, getSharedActionScope, getSharedOperationScope, signAction, signActions, toErrorInfo, topologicalSort, validateActionScopes, validateBatchRequest, } from "./utils.js";
 /**
  * This class implements the IReactor interface and serves as the main entry point
  * for the new Reactor architecture.
@@ -13,67 +13,62 @@ import { filterByType, getSharedScope, signAction, signActions, toErrorInfo, top
 export class Reactor {
     logger;
     documentModelRegistry;
-    documentStorage;
     shutdownStatus;
     setShutdown;
+    setCompleted;
     queue;
     jobTracker;
     readModelCoordinator;
     features;
     documentView;
-    _documentIndexer;
+    documentIndexer;
     operationStore;
     eventBus;
-    constructor(logger, documentModelRegistry, documentStorage, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore, eventBus) {
+    executorManager;
+    constructor(logger, documentModelRegistry, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore, eventBus, executorManager) {
         this.logger = logger;
         this.documentModelRegistry = documentModelRegistry;
-        this.documentStorage = documentStorage;
         this.queue = queue;
         this.jobTracker = jobTracker;
         this.readModelCoordinator = readModelCoordinator;
         this.features = features;
         this.documentView = documentView;
-        this._documentIndexer = documentIndexer;
+        this.documentIndexer = documentIndexer;
         this.operationStore = operationStore;
         this.eventBus = eventBus;
-        const [status, setter] = createMutableShutdownStatus(false);
+        this.executorManager = executorManager;
+        const [status, setShutdown, setCompleted] = createMutableShutdownStatus(false);
         this.shutdownStatus = status;
-        this.setShutdown = setter;
-        this.logger.verbose("Reactor({ legacyStorage: @legacy })", features.legacyStorageEnabled);
+        this.setShutdown = setShutdown;
+        this.setCompleted = setCompleted;
         this.readModelCoordinator.start();
     }
-    /**
-     * Signals that the reactor should shutdown.
-     */
     kill() {
         this.logger.verbose("kill()");
-        // Mark the reactor as shutdown
+        if (this.shutdownStatus.isShutdown) {
+            return this.shutdownStatus;
+        }
         this.setShutdown(true);
-        // Stop the read model coordinator
-        this.readModelCoordinator.stop();
-        // Stop the job tracker
-        this.jobTracker.shutdown();
+        const shutdownAsync = async () => {
+            await this.executorManager.stop(true);
+            this.readModelCoordinator.stop();
+            this.jobTracker.shutdown();
+        };
+        this.setCompleted(shutdownAsync());
         return this.shutdownStatus;
     }
-    /**
-     * Retrieves a list of document model specifications
-     */
     getDocumentModels(namespace, paging, signal) {
         this.logger.verbose("getDocumentModels(@namespace, @paging)", namespace, paging);
-        // Get document model modules from the registry + filter
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
         const modules = this.documentModelRegistry.getAllModules();
         const filteredModels = modules.filter((module) => !namespace || module.documentModel.global.id.startsWith(namespace));
-        // Apply paging
         const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
         const limit = paging?.limit || filteredModels.length;
         const pagedModels = filteredModels.slice(startIndex, startIndex + limit);
-        // Create paged results
         const hasMore = startIndex + limit < filteredModels.length;
         const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-        // even thought this is currently synchronous, they could have passed in an already-aborted signal
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
         return Promise.resolve({
             results: pagedModels,
             options: paging || { cursor: "0", limit: filteredModels.length },
@@ -83,197 +78,70 @@ export class Reactor {
                 : undefined,
         });
     }
-    /**
-     * Retrieves a specific PHDocument by id
-     */
     async get(id, view, consistencyToken, signal) {
         this.logger.verbose("get(@id, @view)", id, view);
-        if (this.features.legacyStorageEnabled) {
-            const document = await this.documentStorage.get(id, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = await this.documentStorage.getChildren(id, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            for (const scope in document.state) {
-                if (!matchesScope(view, scope)) {
-                    delete document.state[scope];
-                }
-            }
-            return {
-                document,
-                childIds,
-            };
-        }
-        else {
-            const document = await this.documentView.get(id, view, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const relationships = await this._documentIndexer.getOutgoing(id, ["child"], consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = relationships.map((rel) => rel.targetId);
-            return {
-                document,
-                childIds,
-            };
-        }
+        return await this.documentView.get(id, view, consistencyToken, signal);
     }
-    /**
-     * Retrieves a specific PHDocument by slug
-     */
     async getBySlug(slug, view, consistencyToken, signal) {
         this.logger.verbose("getBySlug(@slug, @view)", slug, view);
-        if (this.features.legacyStorageEnabled) {
-            let ids;
-            try {
-                ids = await this.documentStorage.resolveIds([slug], consistencyToken, signal);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes("not found")) {
-                    throw new Error(`Document not found with slug: ${slug}`);
-                }
-                throw error;
-            }
-            if (ids.length === 0 || !ids[0]) {
-                throw new Error(`Document not found with slug: ${slug}`);
-            }
-            return await this.get(ids[0], view, consistencyToken, signal);
-        }
-        else {
-            const documentId = await this.documentView.resolveSlug(slug, view, consistencyToken, signal);
-            if (!documentId) {
-                throw new Error(`Document not found with slug: ${slug}`);
-            }
-            return await this.get(documentId, view, consistencyToken, signal);
+        const documentId = await this.documentView.resolveSlug(slug, view, consistencyToken, signal);
+        if (!documentId) {
+            throw new Error(`Document not found with slug: ${slug}`);
         }
+        return await this.get(documentId, view, consistencyToken, signal);
     }
-    /**
-     * Retrieves a specific PHDocument by identifier (either id or slug)
-     */
     async getByIdOrSlug(identifier, view, consistencyToken, signal) {
         this.logger.verbose("getByIdOrSlug(@identifier, @view)", identifier, view);
-        if (this.features.legacyStorageEnabled) {
-            try {
-                return await this.get(identifier, view, consistencyToken, signal);
-            }
-            catch {
-                try {
-                    const ids = await this.documentStorage.resolveIds([identifier], consistencyToken, signal);
-                    if (ids.length === 0 || !ids[0]) {
-                        throw new Error(`Document not found: ${identifier}`);
-                    }
-                    return await this.get(ids[0], view, consistencyToken, signal);
-                }
-                catch {
-                    throw new Error(`Document not found: ${identifier}`);
-                }
-            }
+        return await this.documentView.getByIdOrSlug(identifier, view, consistencyToken, signal);
+    }
+    async getChildren(documentId, consistencyToken, signal) {
+        const relationships = await this.documentIndexer.getOutgoing(documentId, ["child"], undefined, consistencyToken, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        else {
-            const document = await this.documentView.getByIdOrSlug(identifier, view, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const relationships = await this._documentIndexer.getOutgoing(document.header.id, ["child"], consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = relationships.map((rel) => rel.targetId);
-            return {
-                document,
-                childIds,
-            };
+        return relationships.results.map((rel) => rel.targetId);
+    }
+    async getParents(childId, consistencyToken, signal) {
+        const relationships = await this.documentIndexer.getIncoming(childId, ["parent"], undefined, consistencyToken, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
+        return relationships.results.map((rel) => rel.sourceId);
     }
-    /**
-     * Retrieves the operations for a document
-     */
     async getOperations(documentId, view, filter, paging, consistencyToken, signal) {
         this.logger.verbose("getOperations(@documentId, @view, @filter, @paging)", documentId, view, filter, paging);
-        if (this.features.legacyStorageEnabled) {
-            const document = await this.documentStorage.get(documentId, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const operations = document.operations;
-            const result = {};
-            for (const scope in operations) {
-                if (matchesScope(view, scope)) {
-                    let scopeOperations = operations[scope];
-                    if (filter) {
-                        if (filter.actionTypes && filter.actionTypes.length > 0) {
-                            scopeOperations = scopeOperations.filter((op) => filter.actionTypes.includes(op.action.type));
-                        }
-                        if (filter.sinceRevision !== undefined) {
-                            scopeOperations = scopeOperations.filter((op) => op.index >= filter.sinceRevision);
-                        }
-                        if (filter.timestampFrom) {
-                            const fromMs = new Date(filter.timestampFrom).getTime();
-                            scopeOperations = scopeOperations.filter((op) => new Date(op.timestampUtcMs).getTime() >= fromMs);
-                        }
-                        if (filter.timestampTo) {
-                            const toMs = new Date(filter.timestampTo).getTime();
-                            scopeOperations = scopeOperations.filter((op) => new Date(op.timestampUtcMs).getTime() <= toMs);
-                        }
-                    }
-                    const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-                    const limit = paging?.limit || scopeOperations.length;
-                    const pagedOperations = scopeOperations.slice(startIndex, startIndex + limit);
-                    result[scope] = {
-                        results: pagedOperations,
-                        options: { cursor: String(startIndex + limit), limit },
-                    };
-                }
-            }
-            return Promise.resolve(result);
+        const branch = view?.branch || "main";
+        const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        else {
-            const branch = view?.branch || "main";
-            const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+        const allScopes = Object.keys(revisions.revision);
+        const result = {};
+        for (const scope of allScopes) {
+            if (!matchesScope(view, scope)) {
+                continue;
+            }
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            const allScopes = Object.keys(revisions.revision);
-            const result = {};
-            for (const scope of allScopes) {
-                if (!matchesScope(view, scope)) {
-                    continue;
-                }
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                const scopeResult = await this.operationStore.getSince(documentId, scope, branch, -1, filter, paging, signal);
-                const currentCursor = paging?.cursor ? parseInt(paging.cursor) : 0;
-                const currentLimit = paging?.limit || 100;
-                result[scope] = {
-                    results: scopeResult.items,
-                    options: {
-                        cursor: scopeResult.nextCursor || String(currentCursor),
-                        limit: currentLimit,
-                    },
-                    nextCursor: scopeResult.nextCursor,
-                    next: scopeResult.hasMore
-                        ? async () => {
-                            const nextPage = await this.getOperations(documentId, view, filter, {
-                                cursor: scopeResult.nextCursor,
-                                limit: currentLimit,
-                            }, consistencyToken, signal);
-                            return nextPage[scope];
-                        }
-                        : undefined,
-                };
-            }
-            return result;
+            const scopeResult = await this.operationStore.getSince(documentId, scope, branch, -1, filter, paging, signal);
+            result[scope] = {
+                results: scopeResult.results,
+                options: scopeResult.options,
+                nextCursor: scopeResult.nextCursor,
+                next: scopeResult.next
+                    ? async () => {
+                        const nextPage = await this.getOperations(documentId, view, filter, {
+                            cursor: scopeResult.nextCursor,
+                            limit: scopeResult.options.limit,
+                        }, consistencyToken, signal);
+                        return nextPage[scope];
+                    }
+                    : undefined,
+            };
         }
+        return result;
     }
-    /**
-     * Filters documents by criteria and returns a list of them
-     */
     async find(search, view, paging, consistencyToken, signal) {
         this.logger.verbose("find(@search, @view, @paging)", search, view, paging);
         let results;
@@ -293,7 +161,7 @@ export class Reactor {
             }
         }
         else if (search.parentId) {
-            results = await this.findByParentId(search.parentId, view, paging, signal);
+            results = await this.findByParentId(search.parentId, view, paging, consistencyToken, signal);
             if (search.type) {
                 results = filterByType(results, search.type);
             }
@@ -309,9 +177,6 @@ export class Reactor {
         }
         return results;
     }
-    /**
-     * Creates a document
-     */
     async create(document, signer, signal, meta) {
         this.logger.verbose("create(@id, @type, @slug)", document.header.id, document.header.documentType, document.header.slug);
         const createdAtUtcIso = new Date().toISOString();
@@ -345,12 +210,10 @@ export class Reactor {
             toVersion: document.state.document.version,
             initialState: document.state,
         });
-        // Sign actions if signer is provided
         let actions = [createAction, upgradeAction];
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
-        // Create a single job with both CREATE_DOCUMENT and UPGRADE_DOCUMENT actions
         const job = {
             id: uuidv4(),
             kind: "mutation",
@@ -365,7 +228,6 @@ export class Reactor {
             errorHistory: [],
             meta,
         };
-        // Create job info and register with tracker
         const jobInfo = {
             id: job.id,
             status: JobStatus.PENDING,
@@ -379,13 +241,9 @@ export class Reactor {
         };
         this.jobTracker.registerJob(jobInfo);
         this.emitJobPending(jobInfo.id, meta);
-        // Enqueue the job
         await this.queue.enqueue(job);
         return jobInfo;
     }
-    /**
-     * Deletes a document
-     */
     async deleteDocument(id, signer, signal, meta) {
         this.logger.verbose("deleteDocument(@id)", id);
         const createdAtUtcIso = new Date().toISOString();
@@ -393,7 +251,6 @@ export class Reactor {
             throw new AbortError();
         }
         let action = deleteDocumentAction(id);
-        // Sign action if signer is provided
         if (signer) {
             action = await signAction(action, signer, signal);
         }
@@ -427,18 +284,13 @@ export class Reactor {
         await this.queue.enqueue(job);
         return jobInfo;
     }
-    /**
-     * Applies a list of actions to a document
-     */
     async execute(docId, branch, actions, signal, meta) {
         this.logger.verbose("execute(@docId, @branch, @actions)", docId, branch, actions);
         if (signal?.aborted) {
             throw new AbortError();
         }
         const createdAtUtcIso = new Date().toISOString();
-        // Determine scope from first action (all actions should have the same scope)
-        const scope = actions.length > 0 ? actions[0].scope || "global" : "global";
-        // Create a single job with all actions
+        const scope = getSharedActionScope(actions);
         const job = {
             id: uuidv4(),
             kind: "mutation",
@@ -453,7 +305,6 @@ export class Reactor {
             errorHistory: [],
             meta,
         };
-        // Create job info and register with tracker
         const jobInfo = {
             id: job.id,
             status: JobStatus.PENDING,
@@ -467,18 +318,12 @@ export class Reactor {
         };
         this.jobTracker.registerJob(jobInfo);
         this.emitJobPending(jobInfo.id, meta);
-        // Enqueue the job
         await this.queue.enqueue(job);
         if (signal?.aborted) {
             throw new AbortError();
         }
         return jobInfo;
     }
-    /**
-     * Imports pre-existing operations that were produced by another reactor.
-     * This function may cause a reshuffle, which will generate additional
-     * operations.
-     */
     async load(docId, branch, operations, signal, meta) {
         this.logger.verbose("load(@docId, @branch, @count, @operations)", docId, branch, operations.length, operations);
         if (signal?.aborted) {
@@ -487,13 +332,7 @@ export class Reactor {
         if (operations.length === 0) {
             throw new Error("load requires at least one operation");
         }
-        // validate the operations
-        const scope = getSharedScope(operations);
-        operations.forEach((operation, index) => {
-            if (!operation.timestampUtcMs) {
-                throw new Error(`Operation at position ${index} is missing timestampUtcMs`);
-            }
-        });
+        const scope = getSharedOperationScope(operations);
         const createdAtUtcIso = new Date().toISOString();
         const job = {
             id: uuidv4(),
@@ -528,9 +367,6 @@ export class Reactor {
         }
         return jobInfo;
     }
-    /**
-     * Applies multiple mutations across documents with dependency management
-     */
     async executeBatch(request, signal, meta) {
         this.logger.verbose("executeBatch(@count jobs)", request.jobs.length);
         if (signal?.aborted) {
@@ -611,39 +447,28 @@ export class Reactor {
         };
         return result;
     }
-    /**
-     * Adds multiple documents as children to another
-     */
     async addChildren(parentId, documentIds, branch = "main", signer, signal) {
         this.logger.verbose("addChildren(@parentId, @count children, @branch)", parentId, documentIds.length, branch);
         if (signal?.aborted) {
             throw new AbortError();
         }
         let actions = documentIds.map((childId) => addRelationshipAction(parentId, childId, "child"));
-        // Sign actions if signer is provided
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
         return await this.execute(parentId, branch, actions, signal);
     }
-    /**
-     * Removes multiple documents as children from another
-     */
     async removeChildren(parentId, documentIds, branch = "main", signer, signal) {
         this.logger.verbose("removeChildren(@parentId, @count children, @branch)", parentId, documentIds.length, branch);
         if (signal?.aborted) {
             throw new AbortError();
         }
         let actions = documentIds.map((childId) => removeRelationshipAction(parentId, childId, "child"));
-        // Sign actions if signer is provided
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
         return await this.execute(parentId, branch, actions, signal);
     }
-    /**
-     * Retrieves the status of a job
-     */
     getJobStatus(jobId, signal) {
         this.logger.verbose("getJobStatus(@jobId)", jobId);
         if (signal?.aborted) {
@@ -651,7 +476,6 @@ export class Reactor {
         }
         const jobInfo = this.jobTracker.getJobStatus(jobId);
         if (!jobInfo) {
-            // Job not found - return FAILED status with appropriate error
             const now = new Date().toISOString();
             return Promise.resolve({
                 id: jobId,
@@ -668,327 +492,34 @@ export class Reactor {
         }
         return Promise.resolve(jobInfo);
     }
-    /**
-     * Finds documents by their IDs
-     */
     async findByIds(ids, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByIds(@count ids)", ids.length);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // Fetch each document by ID using storage directly
-            for (const id of ids) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                let document;
-                try {
-                    document = await this.documentStorage.get(id, consistencyToken, signal);
-                }
-                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();
-            }
-            // 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.findByIds(ids, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const documents = [];
-            // Fetch each document by ID using documentView
-            for (const id of ids) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                try {
-                    const document = await this.documentView.get(id, view, undefined, signal);
-                    documents.push(document);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    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.findByIds(ids, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        const startIndex = paging?.cursor ? parseInt(paging.cursor) || 0 : 0;
+        const limit = paging?.limit || ids.length;
+        const pagedIds = ids.slice(startIndex, startIndex + limit);
+        const results = await this.documentView.getMany(pagedIds, view, consistencyToken, signal);
+        const hasMore = startIndex + limit < ids.length;
+        const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+        return {
+            results,
+            options: paging || { cursor: "0", limit: ids.length },
+            nextCursor,
+        };
     }
-    /**
-     * Finds documents by their slugs
-     */
     async findBySlugs(slugs, view, paging, consistencyToken, signal) {
         this.logger.verbose("findBySlugs(@count slugs)", slugs.length);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // Use storage to resolve slugs to IDs
-            let ids;
-            try {
-                ids = await this.documentStorage.resolveIds(slugs, consistencyToken, 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 {
-                    document = await this.documentStorage.get(id, consistencyToken, signal);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    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();
-            }
-            // 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);
-            // 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 }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const documents = [];
-            // Resolve each slug to a document ID
-            const documentIds = [];
-            for (const slug of slugs) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                const documentId = await this.documentView.resolveSlug(slug, view, undefined, signal);
-                if (documentId) {
-                    documentIds.push(documentId);
-                }
-            }
-            // Fetch each document
-            for (const documentId of documentIds) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                try {
-                    const document = await this.documentView.get(documentId, view, undefined, signal);
-                    documents.push(document);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    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 }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        const ids = await this.documentView.resolveSlugs(slugs, view, consistencyToken, signal);
+        return await this.findByIds(ids, view, paging, consistencyToken, signal);
     }
-    /**
-     * Finds documents by parent ID
-     */
-    async findByParentId(parentId, view, paging, signal) {
+    async findByParentId(parentId, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByParentId(@parentId)", parentId);
-        // Get child relationships from indexer
-        const relationships = await this._documentIndexer.getOutgoing(parentId, ["child"], undefined, signal);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        const documents = [];
-        // Fetch each child document using the appropriate storage method
-        for (const relationship of relationships) {
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            try {
-                let document;
-                if (this.features.legacyStorageEnabled) {
-                    document = await this.documentStorage.get(relationship.targetId);
-                    // Apply view filter for legacy storage
-                    for (const scope in document.state) {
-                        if (!matchesScope(view, scope)) {
-                            delete document.state[scope];
-                        }
-                    }
-                }
-                else {
-                    document = await this.documentView.get(relationship.targetId, view, undefined, signal);
-                }
-                documents.push(document);
-            }
-            catch {
-                // Skip documents that don't exist or can't be accessed
-                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.findByParentId(parentId, view, { cursor: nextCursor, limit }, signal)
-                : undefined,
-        };
+        const relationships = await this.documentIndexer.getOutgoing(parentId, ["child"], paging, consistencyToken, signal);
+        const ids = relationships.results.map((rel) => rel.targetId);
+        return await this.findByIds(ids, view, paging, undefined, signal);
     }
-    /**
-     * Finds documents by type
-     */
     async findByType(type, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByType(@type)", type);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // 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, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Fetch each document by its ID
-            for (const documentId of documentIds) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                let document;
-                try {
-                    document = await this.documentStorage.get(documentId, consistencyToken, signal);
-                }
-                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();
-            }
-            // Results are already paged from the storage layer
-            return {
-                results: documents,
-                options: paging || { cursor: cursor || "0", limit },
-                nextCursor,
-                next: nextCursor
-                    ? async () => this.findByType(type, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const result = await this.documentView.findByType(type, view, paging, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const cursor = paging?.cursor;
-            const limit = paging?.limit || 100;
-            return {
-                results: result.items,
-                options: paging || { cursor: cursor || "0", limit },
-                nextCursor: result.nextCursor,
-                next: result.nextCursor
-                    ? async () => this.findByType(type, view, { cursor: result.nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        return await this.documentView.findByType(type, view, paging, consistencyToken, signal);
     }
     emitJobPending(jobId, meta) {
         const event = {