@powerhousedao/reactor 6.0.0-dev.25 → 6.0.0-dev.251

package/dist/src/core/reactor.js

@@ -1,986 +0,0 @@
-import { addRelationshipAction, createDocumentAction, deleteDocumentAction, removeRelationshipAction, upgradeDocumentAction, } from "#actions/index.js";
-import { AbortError } from "document-drive";
-import { v4 as uuidv4 } from "uuid";
-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";
-/**
- * This class implements the IReactor interface and serves as the main entry point
- * for the new Reactor architecture.
- */
-export class Reactor {
-    logger;
-    documentModelRegistry;
-    documentStorage;
-    shutdownStatus;
-    setShutdown;
-    queue;
-    jobTracker;
-    readModelCoordinator;
-    features;
-    documentView;
-    _documentIndexer;
-    operationStore;
-    constructor(logger, documentModelRegistry, documentStorage, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore) {
-        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.operationStore = operationStore;
-        const [status, setter] = createMutableShutdownStatus(false);
-        this.shutdownStatus = status;
-        this.setShutdown = setter;
-        this.logger.verbose("Reactor({ legacyStorage: @legacy })", features.legacyStorageEnabled);
-        this.readModelCoordinator.start();
-    }
-    /**
-     * Signals that the reactor should shutdown.
-     */
-    kill() {
-        this.logger.verbose("kill()");
-        // Mark the reactor as shutdown
-        this.setShutdown(true);
-        // Stop the read model coordinator
-        this.readModelCoordinator.stop();
-        // Stop the job tracker
-        this.jobTracker.shutdown();
-        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
-        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 },
-            nextCursor,
-            next: hasMore
-                ? () => this.getDocumentModels(namespace, { cursor: nextCursor, limit }, signal)
-                : 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,
-            };
-        }
-    }
-    /**
-     * 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);
-        }
-    }
-    /**
-     * 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}`);
-                }
-            }
-        }
-        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,
-            };
-        }
-    }
-    /**
-     * 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);
-        }
-        else {
-            const branch = view?.branch || "main";
-            const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
-            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;
-        }
-    }
-    /**
-     * 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;
-        if (search.ids) {
-            if (search.slugs && search.slugs.length > 0) {
-                throw new Error("Cannot use both ids and slugs in the same search");
-            }
-            results = await this.findByIds(search.ids, view, paging, consistencyToken, signal);
-            if (search.type) {
-                results = filterByType(results, search.type);
-            }
-        }
-        else if (search.slugs) {
-            results = await this.findBySlugs(search.slugs, view, paging, consistencyToken, signal);
-            if (search.type) {
-                results = filterByType(results, search.type);
-            }
-        }
-        else if (search.parentId) {
-            results = await this.findByParentId(search.parentId, view, paging, signal);
-            if (search.type) {
-                results = filterByType(results, search.type);
-            }
-        }
-        else if (search.type) {
-            results = await this.findByType(search.type, view, paging, consistencyToken, signal);
-        }
-        else {
-            throw new Error("No search criteria provided");
-        }
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        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();
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        const createInput = {
-            model: document.header.documentType,
-            version: 0,
-            documentId: document.header.id,
-            signing: {
-                signature: document.header.id,
-                publicKey: document.header.sig.publicKey,
-                nonce: document.header.sig.nonce,
-                createdAtUtcIso: document.header.createdAtUtcIso,
-                documentType: document.header.documentType,
-            },
-            slug: document.header.slug,
-            name: document.header.name,
-            branch: document.header.branch,
-            meta: document.header.meta,
-            protocolVersions: document.header.protocolVersions ?? {
-                "base-reducer": 2,
-            },
-        };
-        const createAction = createDocumentAction(createInput);
-        const upgradeAction = upgradeDocumentAction({
-            documentId: document.header.id,
-            model: document.header.documentType,
-            fromVersion: 0,
-            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",
-            documentId: document.header.id,
-            scope: "document",
-            branch: "main",
-            actions,
-            operations: [],
-            createdAt: new Date().toISOString(),
-            queueHint: [],
-            maxRetries: 3,
-            errorHistory: [],
-            meta,
-        };
-        // Create job info and register with tracker
-        const jobInfo = {
-            id: job.id,
-            status: JobStatus.PENDING,
-            createdAtUtcIso,
-            consistencyToken: {
-                version: 1,
-                createdAtUtcIso,
-                coordinates: [],
-            },
-            meta,
-        };
-        this.jobTracker.registerJob(jobInfo);
-        // 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();
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        let action = deleteDocumentAction(id);
-        // Sign action if signer is provided
-        if (signer) {
-            action = await signAction(action, signer, signal);
-        }
-        const job = {
-            id: uuidv4(),
-            kind: "mutation",
-            documentId: id,
-            scope: "document",
-            branch: "main",
-            actions: [action],
-            operations: [],
-            createdAt: new Date().toISOString(),
-            queueHint: [],
-            maxRetries: 3,
-            errorHistory: [],
-            meta,
-        };
-        const jobInfo = {
-            id: job.id,
-            status: JobStatus.PENDING,
-            createdAtUtcIso,
-            consistencyToken: {
-                version: 1,
-                createdAtUtcIso,
-                coordinates: [],
-            },
-            meta,
-        };
-        this.jobTracker.registerJob(jobInfo);
-        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 job = {
-            id: uuidv4(),
-            kind: "mutation",
-            documentId: docId,
-            scope: scope,
-            branch: branch,
-            actions: actions,
-            operations: [],
-            createdAt: new Date().toISOString(),
-            queueHint: [],
-            maxRetries: 3,
-            errorHistory: [],
-            meta,
-        };
-        // Create job info and register with tracker
-        const jobInfo = {
-            id: job.id,
-            status: JobStatus.PENDING,
-            createdAtUtcIso,
-            consistencyToken: {
-                version: 1,
-                createdAtUtcIso,
-                coordinates: [],
-            },
-            meta,
-        };
-        this.jobTracker.registerJob(jobInfo);
-        // 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) {
-            throw new AbortError();
-        }
-        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 createdAtUtcIso = new Date().toISOString();
-        const job = {
-            id: uuidv4(),
-            kind: "load",
-            documentId: docId,
-            scope,
-            branch,
-            actions: [],
-            operations,
-            createdAt: createdAtUtcIso,
-            queueHint: [],
-            maxRetries: 3,
-            errorHistory: [],
-            meta,
-        };
-        const jobInfo = {
-            id: job.id,
-            status: JobStatus.PENDING,
-            createdAtUtcIso,
-            consistencyToken: {
-                version: 1,
-                createdAtUtcIso,
-                coordinates: [],
-            },
-            meta,
-        };
-        this.jobTracker.registerJob(jobInfo);
-        await this.queue.enqueue(job);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        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) {
-            throw new AbortError();
-        }
-        validateBatchRequest(request.jobs);
-        for (const jobPlan of request.jobs) {
-            validateActionScopes(jobPlan);
-        }
-        const createdAtUtcIso = new Date().toISOString();
-        const planKeyToJobId = new Map();
-        for (const jobPlan of request.jobs) {
-            planKeyToJobId.set(jobPlan.key, uuidv4());
-        }
-        const jobInfos = new Map();
-        for (const jobPlan of request.jobs) {
-            const jobId = planKeyToJobId.get(jobPlan.key);
-            const jobInfo = {
-                id: jobId,
-                status: JobStatus.PENDING,
-                createdAtUtcIso,
-                consistencyToken: {
-                    version: 1,
-                    createdAtUtcIso,
-                    coordinates: [],
-                },
-                meta,
-            };
-            this.jobTracker.registerJob(jobInfo);
-            jobInfos.set(jobPlan.key, jobInfo);
-        }
-        const sortedKeys = topologicalSort(request.jobs);
-        const enqueuedKeys = [];
-        try {
-            for (const key of sortedKeys) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                const jobPlan = request.jobs.find((j) => j.key === key);
-                const jobId = planKeyToJobId.get(key);
-                const queueHint = jobPlan.dependsOn.map((depKey) => planKeyToJobId.get(depKey));
-                const job = {
-                    id: jobId,
-                    kind: "mutation",
-                    documentId: jobPlan.documentId,
-                    scope: jobPlan.scope,
-                    branch: jobPlan.branch,
-                    actions: jobPlan.actions,
-                    operations: [],
-                    createdAt: createdAtUtcIso,
-                    queueHint,
-                    maxRetries: 3,
-                    errorHistory: [],
-                    meta,
-                };
-                await this.queue.enqueue(job);
-                enqueuedKeys.push(key);
-            }
-        }
-        catch (error) {
-            for (const key of enqueuedKeys) {
-                const jobId = planKeyToJobId.get(key);
-                try {
-                    await this.queue.remove(jobId);
-                }
-                catch {
-                    // Ignore removal errors during cleanup
-                }
-            }
-            for (const jobInfo of jobInfos.values()) {
-                this.jobTracker.markFailed(jobInfo.id, toErrorInfo("Batch enqueue failed"));
-            }
-            throw error;
-        }
-        const result = {
-            jobs: Object.fromEntries(jobInfos),
-        };
-        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) {
-            throw new AbortError();
-        }
-        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,
-                status: JobStatus.FAILED,
-                createdAtUtcIso: now,
-                completedAtUtcIso: now,
-                error: toErrorInfo("Job not found"),
-                consistencyToken: {
-                    version: 1,
-                    createdAtUtcIso: now,
-                    coordinates: [],
-                },
-            });
-        }
-        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,
-            };
-        }
-    }
-    /**
-     * 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,
-            };
-        }
-    }
-    /**
-     * Finds documents by parent ID
-     */
-    async findByParentId(parentId, view, paging, 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,
-        };
-    }
-    /**
-     * 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,
-            };
-        }
-    }
-}
-//# sourceMappingURL=reactor.js.map