@powerhousedao/reactor-api 6.0.2-staging.2 → 6.0.2-staging.3

package/dist/src/graphql/reactor/resolvers.js

@@ -1,682 +0,0 @@
-import { consolidateSyncOperations, envelopesToSyncOperations, sortEnvelopesByFirstOperationTimestamp, trimMailboxFromAckOrdinal, } from "@powerhousedao/reactor";
-import { GraphQLError } from "graphql";
-const DRIVE_DOCUMENT_TYPE = "powerhouse/document-drive";
-import { fromInputMaybe, serializeOperationForGraphQL, toDocumentModelResultPage, toGqlJobInfo, toGqlPhDocument, toMutableArray, toOperationResultPage, toPhDocumentResultPage, validateActions, } from "./adapters.js";
-export async function documentModels(reactorClient, args) {
-    const namespace = fromInputMaybe(args.namespace);
-    let paging;
-    if (args.paging) {
-        const cursor = fromInputMaybe(args.paging.cursor);
-        const limit = fromInputMaybe(args.paging.limit);
-        if (cursor || limit) {
-            paging = {
-                cursor: cursor || "",
-                limit: limit || 10,
-            };
-        }
-    }
-    let result;
-    try {
-        result = await reactorClient.getDocumentModelModules(namespace, paging);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch document models: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toDocumentModelResultPage(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document models to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function document(reactorClient, args) {
-    let view;
-    if (args.view) {
-        view = {
-            branch: fromInputMaybe(args.view.branch),
-            scopes: toMutableArray(fromInputMaybe(args.view.scopes)),
-        };
-    }
-    let result;
-    try {
-        result = await reactorClient.get(args.identifier, view);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    let children;
-    try {
-        children = await reactorClient.getChildren(args.identifier, view);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch children: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return {
-            document: toGqlPhDocument(result),
-            childIds: children.results.map((child) => child.header.id),
-        };
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function documentChildren(reactorClient, args) {
-    let view;
-    if (args.view) {
-        view = {
-            branch: fromInputMaybe(args.view.branch),
-            scopes: toMutableArray(fromInputMaybe(args.view.scopes)),
-        };
-    }
-    let paging;
-    if (args.paging) {
-        const cursor = fromInputMaybe(args.paging.cursor);
-        const limit = fromInputMaybe(args.paging.limit);
-        if (cursor || limit) {
-            paging = {
-                cursor: cursor || "",
-                limit: limit || 10,
-            };
-        }
-    }
-    let result;
-    try {
-        result = await reactorClient.getChildren(args.parentIdentifier, view, paging);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch document children: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toPhDocumentResultPage(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document children to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function documentParents(reactorClient, args) {
-    let view;
-    if (args.view) {
-        view = {
-            branch: fromInputMaybe(args.view.branch),
-            scopes: toMutableArray(fromInputMaybe(args.view.scopes)),
-        };
-    }
-    let paging;
-    if (args.paging) {
-        const cursor = fromInputMaybe(args.paging.cursor);
-        const limit = fromInputMaybe(args.paging.limit);
-        if (cursor || limit) {
-            paging = {
-                cursor: cursor || "",
-                limit: limit || 10,
-            };
-        }
-    }
-    let result;
-    try {
-        result = await reactorClient.getParents(args.childIdentifier, view, paging);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch document parents: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toPhDocumentResultPage(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document parents to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function findDocuments(reactorClient, args) {
-    let view;
-    if (args.view) {
-        view = {
-            branch: fromInputMaybe(args.view.branch),
-            scopes: toMutableArray(fromInputMaybe(args.view.scopes)),
-        };
-    }
-    let paging;
-    if (args.paging) {
-        const cursor = fromInputMaybe(args.paging.cursor);
-        const limit = fromInputMaybe(args.paging.limit);
-        if (cursor || limit) {
-            paging = {
-                cursor: cursor || "",
-                limit: limit || 10,
-            };
-        }
-    }
-    const search = {
-        type: fromInputMaybe(args.search.type),
-        parentId: fromInputMaybe(args.search.parentId),
-    };
-    let result;
-    try {
-        result = await reactorClient.find(search, view, paging);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to find documents: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toPhDocumentResultPage(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert documents to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function jobStatus(reactorClient, args) {
-    let result;
-    try {
-        result = await reactorClient.getJobStatus(args.jobId);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch job status: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlJobInfo(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert job status to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function documentOperations(reactorClient, args) {
-    let view;
-    const branch = fromInputMaybe(args.filter.branch);
-    const scopes = toMutableArray(fromInputMaybe(args.filter.scopes));
-    if (branch || scopes) {
-        view = { branch, scopes };
-    }
-    const actionTypes = toMutableArray(fromInputMaybe(args.filter.actionTypes));
-    const sinceRevision = fromInputMaybe(args.filter.sinceRevision);
-    const timestampFrom = fromInputMaybe(args.filter.timestampFrom);
-    const timestampTo = fromInputMaybe(args.filter.timestampTo);
-    let operationFilter;
-    if ((actionTypes && actionTypes.length > 0) ||
-        sinceRevision !== undefined ||
-        timestampFrom ||
-        timestampTo) {
-        operationFilter = {
-            actionTypes: actionTypes && actionTypes.length > 0 ? actionTypes : undefined,
-            sinceRevision,
-            timestampFrom: timestampFrom || undefined,
-            timestampTo: timestampTo || undefined,
-        };
-    }
-    let paging;
-    if (args.paging) {
-        const cursor = fromInputMaybe(args.paging.cursor);
-        const limit = fromInputMaybe(args.paging.limit);
-        if (cursor || limit) {
-            paging = {
-                cursor: cursor || "",
-                limit: limit || 100,
-            };
-        }
-    }
-    let result;
-    try {
-        result = await reactorClient.getOperations(args.filter.documentId, view, operationFilter, paging);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to fetch document operations: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toOperationResultPage(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert operations to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function createDocument(reactorClient, args) {
-    // Validate that document is a PHDocument
-    if (!args.document || typeof args.document !== "object") {
-        throw new GraphQLError("Invalid document: must be an object");
-    }
-    const document = args.document;
-    // Validate required fields
-    if (!document.header || typeof document.header !== "object") {
-        throw new GraphQLError("Invalid document: missing or invalid header");
-    }
-    const parentIdentifier = fromInputMaybe(args.parentIdentifier);
-    let result;
-    try {
-        if (parentIdentifier) {
-            const parent = await reactorClient.get(parentIdentifier);
-            if (parent.header.documentType === DRIVE_DOCUMENT_TYPE) {
-                result = await reactorClient.createDocumentInDrive(parentIdentifier, document);
-            }
-            else {
-                result = await reactorClient.create(document, parentIdentifier);
-            }
-        }
-        else {
-            result = await reactorClient.create(document);
-        }
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to create document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert created document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function createEmptyDocument(reactorClient, args) {
-    const parentIdentifier = fromInputMaybe(args.parentIdentifier);
-    const name = fromInputMaybe(args.name);
-    let result;
-    try {
-        if (parentIdentifier) {
-            const parent = await reactorClient.get(parentIdentifier);
-            if (parent.header.documentType === DRIVE_DOCUMENT_TYPE) {
-                const module = await reactorClient.getDocumentModelModule(args.documentType);
-                const document = module.utils.createDocument();
-                if (name) {
-                    document.header.name = name;
-                }
-                result = await reactorClient.createDocumentInDrive(parentIdentifier, document);
-            }
-            else {
-                result = await reactorClient.createEmpty(args.documentType, {
-                    parentIdentifier,
-                });
-            }
-        }
-        else {
-            result = await reactorClient.createEmpty(args.documentType, {});
-        }
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to create empty document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert created document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function createDocumentWithInitialState(reactorClient, args) {
-    const parentIdentifier = fromInputMaybe(args.parentIdentifier);
-    const name = fromInputMaybe(args.name);
-    const slug = fromInputMaybe(args.slug);
-    const preferredEditor = fromInputMaybe(args.preferredEditor);
-    let module;
-    try {
-        module = await reactorClient.getDocumentModelModule(args.documentType);
-    }
-    catch (error) {
-        throw new GraphQLError(`Document model not found for type ${args.documentType}: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    const document = module.utils.createDocument();
-    // Only merge specification-defined scopes (e.g., global, local).
-    // Protected scopes like "auth" and "document" are excluded.
-    const allowedScopes = new Set(Object.keys(module.documentModel.global.specifications.at(-1)?.state ?? {}));
-    const state = document.state;
-    for (const [scope, scopeState] of Object.entries(args.initialState)) {
-        if (allowedScopes.has(scope) && scope in state) {
-            state[scope] = { ...state[scope], ...scopeState };
-        }
-    }
-    if (name) {
-        document.header.name = name;
-    }
-    if (slug) {
-        document.header.slug = slug;
-    }
-    if (preferredEditor) {
-        document.header.meta = { ...document.header.meta, preferredEditor };
-    }
-    let result;
-    if (parentIdentifier) {
-        let parent;
-        try {
-            parent = await reactorClient.get(parentIdentifier);
-        }
-        catch (error) {
-            throw new GraphQLError(`Parent document not found: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-        if (parent.header.documentType === DRIVE_DOCUMENT_TYPE) {
-            try {
-                result = await reactorClient.createDocumentInDrive(parentIdentifier, document);
-            }
-            catch (error) {
-                throw new GraphQLError(`Failed to create document in drive: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        else {
-            try {
-                result = await reactorClient.create(document, parentIdentifier);
-            }
-            catch (error) {
-                throw new GraphQLError(`Failed to create document with parent: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-    }
-    else {
-        try {
-            result = await reactorClient.create(document);
-        }
-        catch (error) {
-            throw new GraphQLError(`Failed to create document: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert created document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function mutateDocument(reactorClient, args) {
-    // Validate actions
-    let validatedActions;
-    try {
-        validatedActions = validateActions(args.actions);
-    }
-    catch (error) {
-        if (error instanceof GraphQLError) {
-            throw error;
-        }
-        throw new GraphQLError(`Action validation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    // Extract branch from view filter (default to "main")
-    const branch = args.view?.branch ?? "main";
-    let result;
-    try {
-        result = await reactorClient.execute(args.documentIdentifier, branch, validatedActions);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to mutate document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert mutated document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function mutateDocumentAsync(reactorClient, args) {
-    // Validate actions
-    let validatedActions;
-    try {
-        validatedActions = validateActions(args.actions);
-    }
-    catch (error) {
-        if (error instanceof GraphQLError) {
-            throw error;
-        }
-        throw new GraphQLError(`Action validation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    // Extract branch from view filter (default to "main")
-    const branch = args.view?.branch ?? "main";
-    let result;
-    try {
-        result = await reactorClient.executeAsync(args.documentIdentifier, branch, validatedActions);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to submit document mutation: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    return result.id;
-}
-export async function renameDocument(reactorClient, args, signal) {
-    const branch = fromInputMaybe(args.branch);
-    let result;
-    try {
-        result = await reactorClient.rename(args.documentIdentifier, args.name, branch, signal);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to rename document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert renamed document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function addChildren(reactorClient, args) {
-    const branch = fromInputMaybe(args.branch);
-    const documentIdentifiers = [...args.documentIdentifiers];
-    let result;
-    try {
-        result = await reactorClient.addChildren(args.parentIdentifier, documentIdentifiers, branch);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to add children: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function removeChildren(reactorClient, args) {
-    const branch = fromInputMaybe(args.branch);
-    const documentIdentifiers = [...args.documentIdentifiers];
-    let result;
-    try {
-        result = await reactorClient.removeChildren(args.parentIdentifier, documentIdentifiers, branch);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to remove children: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return toGqlPhDocument(result);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert document to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function moveChildren(reactorClient, args) {
-    const branch = fromInputMaybe(args.branch);
-    const documentIdentifiers = [...args.documentIdentifiers];
-    let result;
-    try {
-        result = await reactorClient.moveChildren(args.sourceParentIdentifier, args.targetParentIdentifier, documentIdentifiers, branch);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to move children: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        return {
-            source: toGqlPhDocument(result.source),
-            target: toGqlPhDocument(result.target),
-        };
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to convert documents to GraphQL: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function deleteDocument(reactorClient, args) {
-    const propagate = fromInputMaybe(args.propagate);
-    try {
-        await reactorClient.deleteDocument(args.identifier, propagate);
-        return true;
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to delete document: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function deleteDocuments(reactorClient, args) {
-    const propagate = fromInputMaybe(args.propagate);
-    const identifiers = [...args.identifiers];
-    try {
-        await reactorClient.deleteDocuments(identifiers, propagate);
-        return true;
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to delete documents: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-export async function touchChannel(syncManager, args) {
-    try {
-        const remote = syncManager.getById(args.input.id);
-        return {
-            success: true,
-            ackOrdinal: remote.channel.inbox.ackOrdinal,
-        };
-    }
-    catch {
-        // getById will throw if the remote does not exist
-    }
-    const filter = {
-        documentId: [...args.input.filter.documentId],
-        scope: [...args.input.filter.scope],
-        branch: args.input.filter.branch,
-    };
-    const options = {
-        sinceTimestampUtcMs: args.input.sinceTimestampUtcMs,
-    };
-    try {
-        await syncManager.add(args.input.name, args.input.collectionId, {
-            type: "polling",
-            parameters: {},
-        }, filter, options, args.input.id);
-    }
-    catch (error) {
-        throw new GraphQLError(`Failed to create channel: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    return { success: true, ackOrdinal: 0 };
-}
-/**
- * Polls the switchboard for new sync envelopes and acknowledges previously
- * received operations.
- *
- * Ordinal frames of reference:
- * - `outboxAck` / `outboxLatest`: switchboard's ordinals (used to trim/filter
- *   the switchboard's outbox)
- * - `ackOrdinal` in the response: the pushing client's ordinals (highest
- *   client ordinal the switchboard has successfully applied, so the client
- *   can trim its own outbox)
- */
-export function pollSyncEnvelopes(syncManager, args) {
-    let remote;
-    try {
-        remote = syncManager.getById(args.channelId);
-    }
-    catch (error) {
-        throw new GraphQLError(`Channel not found: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    const deadLetters = remote.channel.deadLetter.items.map((syncOp) => ({
-        documentId: syncOp.documentId,
-        error: syncOp.error?.message ?? "Unknown error",
-        jobId: syncOp.jobId,
-        branch: syncOp.branch,
-        scopes: syncOp.scopes,
-        operationCount: syncOp.operations.length,
-    }));
-    // trim outbox
-    if (args.outboxAck > 0) {
-        trimMailboxFromAckOrdinal(remote.channel.outbox, args.outboxAck);
-    }
-    let operations = remote.channel.outbox.items;
-    // filter remaining outbox operations by outboxLatest
-    operations = operations.filter((syncOp) => {
-        let maxOrdinal = 0;
-        for (const op of syncOp.operations) {
-            maxOrdinal = Math.max(maxOrdinal, op.context.ordinal);
-        }
-        if (maxOrdinal > args.outboxLatest) {
-            return true;
-        }
-        return false;
-    });
-    if (operations.length === 0) {
-        return {
-            envelopes: [],
-            ackOrdinal: remote.channel.inbox.ackOrdinal,
-            deadLetters,
-        };
-    }
-    let maxOrdinal = args.outboxLatest;
-    for (const syncOp of operations) {
-        for (const op of syncOp.operations) {
-            const opOrdinal = op.context.ordinal;
-            if (opOrdinal > maxOrdinal) {
-                maxOrdinal = opOrdinal;
-            }
-        }
-    }
-    const envelopes = operations.map((syncOp) => ({
-        type: "OPERATIONS",
-        channelMeta: {
-            id: args.channelId,
-        },
-        operations: syncOp.operations.map((op) => ({
-            operation: serializeOperationForGraphQL(op.operation),
-            context: op.context,
-        })),
-        cursor: {
-            remoteName: remote.name,
-            cursorOrdinal: maxOrdinal,
-            lastSyncedAtUtcMs: Date.now().toString(),
-        },
-        key: syncOp.jobId || undefined,
-        dependsOn: syncOp.jobDependencies.filter(Boolean).length > 0
-            ? syncOp.jobDependencies.filter(Boolean)
-            : undefined,
-    }));
-    return {
-        envelopes: sortEnvelopesByFirstOperationTimestamp(envelopes),
-        ackOrdinal: remote.channel.inbox.ackOrdinal,
-        deadLetters,
-    };
-}
-/**
- * Receives sync envelopes pushed by a client and adds them to the
- * appropriate channel inboxes.
- *
- * The `ordinal` in each operation's context is the client's local ordinal.
- * It must be preserved because the inbox mailbox tracks applied ordinals
- * and returns the highest one as `ackOrdinal` in pollSyncEnvelopes.
- */
-export function pushSyncEnvelopes(syncManager, args) {
-    const sortedEnvelopes = sortEnvelopesByFirstOperationTimestamp(args.envelopes);
-    const remoteSyncOps = new Map();
-    for (const envelope of sortedEnvelopes) {
-        let remote;
-        try {
-            remote = syncManager.getById(envelope.channelMeta.id);
-        }
-        catch (error) {
-            throw new GraphQLError(`Channel not found: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-        if (!envelope.operations || envelope.operations.length === 0) {
-            continue;
-        }
-        const syncOps = envelopesToSyncOperations(envelope, remote.name);
-        if (!remoteSyncOps.has(remote)) {
-            remoteSyncOps.set(remote, []);
-        }
-        remoteSyncOps.get(remote).push(...syncOps);
-    }
-    for (const [remote, syncOps] of remoteSyncOps) {
-        const consolidated = consolidateSyncOperations(syncOps);
-        const validKeys = new Set(consolidated.map((op) => op.jobId).filter(Boolean));
-        for (const syncOp of consolidated) {
-            syncOp.jobDependencies = syncOp.jobDependencies.filter((dep) => validKeys.has(dep));
-        }
-        remote.channel.inbox.add(...consolidated);
-    }
-    return Promise.resolve(true);
-}
-/**
- * Create a getParentIds function using the reactor client
- */
-export function createGetParentIdsFn(reactorClient) {
-    return async (documentId) => {
-        try {
-            const result = await reactorClient.getParents(documentId);
-            return result.results.map((doc) => doc.header.id);
-        }
-        catch {
-            // If document has no parents or error, return empty array
-            return [];
-        }
-    };
-}
-//# sourceMappingURL=resolvers.js.map