@powerhousedao/reactor-api 6.0.0-dev.1 → 6.0.0-dev.100

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

@@ -18,183 +18,119 @@ export class ReactorSubgraph extends BaseSubgraph {
         super(args);
         this.logger.verbose(`constructor()`);
     }
-    name = "r/:reactor";
+    name = "r";
     hasSubscriptions = true;
     /**
-     * Check if user has global read access (admin, user, or guest)
-     */
-    hasGlobalReadAccess(ctx) {
-        const isGlobalAdmin = ctx.isAdmin?.(ctx.user?.address ?? "");
-        const isGlobalUser = ctx.isUser?.(ctx.user?.address ?? "");
-        const isGlobalGuest = ctx.isGuest?.(ctx.user?.address ?? "") ||
-            process.env.FREE_ENTRY === "true";
-        return !!(isGlobalAdmin || isGlobalUser || isGlobalGuest);
-    }
-    /**
-     * Check if user has global write access (admin or user, not guest)
-     */
-    hasGlobalWriteAccess(ctx) {
-        const isGlobalAdmin = ctx.isAdmin?.(ctx.user?.address ?? "");
-        const isGlobalUser = ctx.isUser?.(ctx.user?.address ?? "");
-        return !!(isGlobalAdmin || isGlobalUser);
-    }
-    /**
-     * Get the parent IDs function for hierarchical permission checks
-     */
-    getParentIdsFn() {
-        return resolvers.createGetParentIdsFn(this.reactorClient);
-    }
-    /**
-     * Check if user can read a document (with hierarchy)
-     */
-    async canReadDocument(documentId, ctx) {
-        // Global access allows reading
-        if (this.hasGlobalReadAccess(ctx)) {
-            return true;
-        }
-        // Check document-level permissions with hierarchy
-        if (this.documentPermissionService) {
-            return this.documentPermissionService.canRead(documentId, ctx.user?.address, this.getParentIdsFn());
-        }
-        return false;
-    }
-    /**
-     * Check if user can write to a document (with hierarchy)
-     */
-    async canWriteDocument(documentId, ctx) {
-        // Global write access allows writing
-        if (this.hasGlobalWriteAccess(ctx)) {
-            return true;
-        }
-        // Check document-level permissions with hierarchy
-        if (this.documentPermissionService) {
-            return this.documentPermissionService.canWrite(documentId, ctx.user?.address, this.getParentIdsFn());
-        }
-        return false;
-    }
-    /**
-     * Throw an error if user cannot read the document
-     */
-    async assertCanRead(documentId, ctx) {
-        const canRead = await this.canReadDocument(documentId, ctx);
-        if (!canRead) {
-            throw new GraphQLError("Forbidden: insufficient permissions to read this document");
-        }
-    }
-    /**
-     * Throw an error if user cannot write to the document
-     */
-    async assertCanWrite(documentId, ctx) {
-        const canWrite = await this.canWriteDocument(documentId, ctx);
-        if (!canWrite) {
-            throw new GraphQLError("Forbidden: insufficient permissions to write to this document");
-        }
-    }
-    /**
-     * Check if user can execute specific operations on a document.
-     * Only checks operations that have restrictions set.
-     * Throws an error if any operation is restricted and user lacks permission.
+     * Check operation-level permissions for an array of actions.
+     * Delegates to base assertCanExecuteOperation for each action.
      */
     async assertCanExecuteOperations(documentId, actions, ctx) {
-        // Skip if no permission service
-        if (!this.documentPermissionService) {
-            return;
-        }
-        // Global admins bypass operation-level restrictions
-        if (ctx.isAdmin?.(ctx.user?.address ?? "")) {
-            return;
-        }
         for (const action of actions) {
-            if (!action || typeof action !== "object") {
+            if (!action || typeof action !== "object")
                 continue;
-            }
             const actionObj = action;
             const operationType = actionObj.type;
-            if (typeof operationType !== "string") {
+            if (typeof operationType !== "string")
                 continue;
-            }
-            // Check if this operation has any restrictions set
-            const isRestricted = await this.documentPermissionService.isOperationRestricted(documentId, operationType);
-            if (isRestricted) {
-                // Operation is restricted, check if user has permission
-                const canExecute = await this.documentPermissionService.canExecuteOperation(documentId, operationType, ctx.user?.address);
-                if (!canExecute) {
-                    throw new GraphQLError(`Forbidden: insufficient permissions to execute operation "${operationType}" on this document`);
-                }
-            }
+            await this.assertCanExecuteOperation(documentId, operationType, ctx);
         }
     }
     // Load schema from file
     typeDefs = gql(fs.readFileSync(path.join(__dirname, "schema.graphql"), "utf-8"));
     resolvers = {
+        // Field resolver for PHDocument.operations - fetches operations on demand
+        PHDocument: {
+            operations: async (parent, args, ctx) => {
+                this.logger.debug("PHDocument.operations(@parent.id, @args)", parent.id, args);
+                await this.assertCanRead(parent.id, ctx);
+                try {
+                    // Build the filter using the document's id
+                    const filter = {
+                        documentId: parent.id,
+                        branch: args.filter?.branch,
+                        scopes: args.filter?.scopes,
+                        actionTypes: args.filter?.actionTypes,
+                        sinceRevision: args.filter?.sinceRevision,
+                        timestampFrom: args.filter?.timestampFrom,
+                        timestampTo: args.filter?.timestampTo,
+                    };
+                    return await resolvers.documentOperations(this.reactorClient, {
+                        filter,
+                        paging: args.paging,
+                    });
+                }
+                catch (error) {
+                    this.logger.error("Error in PHDocument.operations: @Error", error);
+                    throw error;
+                }
+            },
+        },
         Query: {
             documentModels: async (_parent, args) => {
-                this.logger.debug("documentModels", args);
+                this.logger.debug("documentModels(@args)", args);
                 try {
                     return await resolvers.documentModels(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in documentModels:", error);
+                    this.logger.error("Error in documentModels: @Error", error);
                     throw error;
                 }
             },
             document: async (_parent, args, ctx) => {
-                this.logger.debug("document", args);
+                this.logger.debug("document(@args)", args);
                 try {
-                    // Resolve the document ID first
-                    const doc = await resolvers.document(this.reactorClient, args);
-                    if (doc) {
-                        await this.assertCanRead(doc.document.id, ctx);
-                    }
-                    return doc;
+                    await this.assertCanRead(args.identifier, ctx);
+                    return await resolvers.document(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in document:", error);
+                    this.logger.error("Error in document: @Error", error);
                     throw error;
                 }
             },
             documentChildren: async (_parent, args, ctx) => {
-                this.logger.debug("documentChildren", args);
+                this.logger.debug("documentChildren(@args)", args);
                 try {
-                    // First resolve the parent to get its ID and check permission
-                    const parent = await resolvers.document(this.reactorClient, {
-                        identifier: args.parentIdentifier,
-                        view: args.view,
-                    });
-                    if (parent) {
-                        await this.assertCanRead(parent.document.id, ctx);
-                    }
+                    await this.assertCanRead(args.parentIdentifier, ctx);
                     return await resolvers.documentChildren(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in documentChildren:", error);
+                    this.logger.error("Error in documentChildren: @Error", error);
                     throw error;
                 }
             },
             documentParents: async (_parent, args, ctx) => {
-                this.logger.debug("documentParents", args);
+                this.logger.debug("documentParents(@args)", args);
                 try {
-                    // First resolve the child to get its ID and check permission
-                    const child = await resolvers.document(this.reactorClient, {
-                        identifier: args.childIdentifier,
-                        view: args.view,
-                    });
-                    if (child) {
-                        await this.assertCanRead(child.document.id, ctx);
+                    await this.assertCanRead(args.childIdentifier, ctx);
+                    const result = await resolvers.documentParents(this.reactorClient, args);
+                    // Filter results to only include documents the user can read
+                    if (!this.hasGlobalAdminAccess(ctx) &&
+                        this.documentPermissionService) {
+                        const filteredItems = [];
+                        for (const item of result.items) {
+                            const canRead = await this.canReadDocument(item.id, ctx);
+                            if (canRead) {
+                                filteredItems.push(item);
+                            }
+                        }
+                        return {
+                            ...result,
+                            items: filteredItems,
+                        };
                     }
-                    return await resolvers.documentParents(this.reactorClient, args);
+                    return result;
                 }
                 catch (error) {
-                    this.logger.error("Error in documentParents:", error);
+                    this.logger.error("Error in documentParents: @Error", error);
                     throw error;
                 }
             },
             findDocuments: async (_parent, args, ctx) => {
-                this.logger.debug("findDocuments", args);
+                this.logger.debug("findDocuments(@args)", args);
                 try {
                     const result = await resolvers.findDocuments(this.reactorClient, args);
                     // Filter results to only include documents the user can read
-                    if (!this.hasGlobalReadAccess(ctx) &&
+                    if (!this.hasGlobalAdminAccess(ctx) &&
                         this.documentPermissionService) {
                         const filteredItems = [];
                         for (const item of result.items) {
@@ -206,275 +142,262 @@ export class ReactorSubgraph extends BaseSubgraph {
                         return {
                             ...result,
                             items: filteredItems,
-                            totalCount: filteredItems.length,
                         };
                     }
                     return result;
                 }
                 catch (error) {
-                    this.logger.error("Error in findDocuments:", error);
+                    this.logger.error("Error in findDocuments: @Error", error);
                     throw error;
                 }
             },
             jobStatus: async (_parent, args) => {
-                this.logger.debug("jobStatus", args);
+                this.logger.debug("jobStatus(@args)", args);
                 try {
                     return await resolvers.jobStatus(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in jobStatus:", error);
+                    this.logger.error("Error in jobStatus: @Error", error);
                     throw error;
                 }
             },
-            pollSyncEnvelopes: async (_parent, args) => {
-                this.logger.debug("pollSyncEnvelopes", args);
+            documentOperations: async (_parent, args, ctx) => {
+                this.logger.debug("documentOperations(@args)", args);
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                    return await resolvers.pollSyncEnvelopes(this.syncManager, args);
+                    await this.assertCanRead(args.filter.documentId, ctx);
+                    return await resolvers.documentOperations(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in pollSyncEnvelopes: @Error", error);
+                    this.logger.error("Error in documentOperations: @Error", error);
+                    throw error;
+                }
+            },
+            pollSyncEnvelopes: (_parent, args) => {
+                this.logger.debug("pollSyncEnvelopes(@args)", args);
+                try {
+                    const { envelopes, ackOrdinal, deadLetters } = resolvers.pollSyncEnvelopes(this.syncManager, args);
+                    return {
+                        envelopes,
+                        ackOrdinal,
+                        deadLetters,
+                    };
+                }
+                catch (error) {
+                    this.logger.error("Error in pollSyncEnvelopes(@args): @Error", error);
                     throw error;
                 }
             },
         },
         Mutation: {
             createDocument: async (_parent, args, ctx) => {
-                this.logger.debug("createDocument", args);
+                this.logger.debug("createDocument(@args)", args);
                 try {
                     // If creating under a parent, check write permission on parent
                     if (args.parentIdentifier) {
                         const parent = await resolvers.document(this.reactorClient, {
                             identifier: args.parentIdentifier,
                         });
-                        if (parent) {
-                            await this.assertCanWrite(parent.document.id, ctx);
+                        await this.assertCanWrite(parent.document.id, ctx);
+                    }
+                    else if (this.authorizationService) {
+                        if (!ctx.user?.address) {
+                            throw new GraphQLError("Forbidden: authentication required to create documents");
                         }
                     }
-                    else if (!this.hasGlobalWriteAccess(ctx)) {
+                    else if (!this.hasGlobalAdminAccess(ctx)) {
                         throw new GraphQLError("Forbidden: insufficient permissions to create documents");
                     }
-                    return await resolvers.createDocument(this.reactorClient, args);
+                    const result = await resolvers.createDocument(this.reactorClient, args);
+                    // Auto-ownership: set creator as document owner
+                    if (this.authorizationService && ctx.user?.address && result?.id) {
+                        await this.documentPermissionService?.initializeDocumentProtection(result.id, ctx.user.address, this.authorizationService.config.defaultProtection);
+                    }
+                    return result;
                 }
                 catch (error) {
-                    this.logger.error("Error in createDocument:", error);
+                    this.logger.error("Error in createDocument(@args): @Error", error);
                     throw error;
                 }
             },
             createEmptyDocument: async (_parent, args, ctx) => {
-                this.logger.debug("createEmptyDocument", args);
+                this.logger.debug("createEmptyDocument(@args)", args);
                 try {
                     // If creating under a parent, check write permission on parent
                     if (args.parentIdentifier) {
                         const parent = await resolvers.document(this.reactorClient, {
                             identifier: args.parentIdentifier,
                         });
-                        if (parent) {
-                            await this.assertCanWrite(parent.document.id, ctx);
+                        await this.assertCanWrite(parent.document.id, ctx);
+                    }
+                    else if (this.authorizationService) {
+                        if (!ctx.user?.address) {
+                            throw new GraphQLError("Forbidden: authentication required to create documents");
                         }
                     }
-                    else if (!this.hasGlobalWriteAccess(ctx)) {
+                    else if (!this.hasGlobalAdminAccess(ctx)) {
                         throw new GraphQLError("Forbidden: insufficient permissions to create documents");
                     }
-                    return await resolvers.createEmptyDocument(this.reactorClient, args);
+                    const result = await resolvers.createEmptyDocument(this.reactorClient, args);
+                    // Auto-ownership: set creator as document owner
+                    if (this.authorizationService && ctx.user?.address && result?.id) {
+                        await this.documentPermissionService?.initializeDocumentProtection(result.id, ctx.user.address, this.authorizationService.config.defaultProtection);
+                    }
+                    return result;
                 }
                 catch (error) {
-                    this.logger.error("Error in createEmptyDocument:", error);
+                    this.logger.error("Error in createEmptyDocument(@args): @Error", error);
                     throw error;
                 }
             },
             mutateDocument: async (_parent, args, ctx) => {
-                this.logger.debug("mutateDocument", args);
+                this.logger.debug("mutateDocument(@args)", args);
                 try {
-                    // Resolve document and check write permission
-                    const doc = await resolvers.document(this.reactorClient, {
-                        identifier: args.documentIdentifier,
-                        view: args.view,
-                    });
-                    if (doc) {
-                        await this.assertCanWrite(doc.document.id, ctx);
-                        // Check operation-level permissions for each action
-                        await this.assertCanExecuteOperations(doc.document.id, args.actions, ctx);
+                    // assertCanExecuteOperations uses canMutate (which combines write + operation checks)
+                    // when authorizationService is available. For legacy fallback, assertCanWrite is needed.
+                    if (!this.authorizationService) {
+                        await this.assertCanWrite(args.documentIdentifier, ctx);
                     }
+                    // Check operation-level permissions for each action
+                    await this.assertCanExecuteOperations(args.documentIdentifier, args.actions, ctx);
                     return await resolvers.mutateDocument(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in mutateDocument:", error);
+                    this.logger.error("Error in mutateDocument(@args): @Error", error);
                     throw error;
                 }
             },
             mutateDocumentAsync: async (_parent, args, ctx) => {
-                this.logger.debug("mutateDocumentAsync", args);
+                this.logger.debug("mutateDocumentAsync(@args)", args);
                 try {
-                    // Resolve document and check write permission
-                    const doc = await resolvers.document(this.reactorClient, {
-                        identifier: args.documentIdentifier,
-                        view: args.view,
-                    });
-                    if (doc) {
-                        await this.assertCanWrite(doc.document.id, ctx);
-                        // Check operation-level permissions for each action
-                        await this.assertCanExecuteOperations(doc.document.id, args.actions, ctx);
+                    if (!this.authorizationService) {
+                        await this.assertCanWrite(args.documentIdentifier, ctx);
                     }
+                    // Check operation-level permissions for each action
+                    await this.assertCanExecuteOperations(args.documentIdentifier, args.actions, ctx);
                     return await resolvers.mutateDocumentAsync(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in mutateDocumentAsync:", error);
+                    this.logger.error("Error in mutateDocumentAsync(@args): @Error", error);
                     throw error;
                 }
             },
             renameDocument: async (_parent, args, ctx) => {
-                this.logger.debug("renameDocument", args);
+                this.logger.debug("renameDocument(@args)", args);
                 try {
-                    // Resolve document and check write permission
-                    const doc = await resolvers.document(this.reactorClient, {
-                        identifier: args.documentIdentifier,
-                    });
-                    if (doc) {
-                        await this.assertCanWrite(doc.document.id, ctx);
-                    }
+                    await this.assertCanWrite(args.documentIdentifier, ctx);
                     return await resolvers.renameDocument(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in renameDocument:", error);
+                    this.logger.error("Error in renameDocument(@args): @Error", error);
                     throw error;
                 }
             },
             addChildren: async (_parent, args, ctx) => {
-                this.logger.debug("addChildren", args);
+                this.logger.debug("addChildren(@args)", args);
                 try {
-                    // Check write permission on parent
-                    const parent = await resolvers.document(this.reactorClient, {
-                        identifier: args.parentIdentifier,
-                    });
-                    if (parent) {
-                        await this.assertCanWrite(parent.document.id, ctx);
-                    }
+                    await this.assertCanWrite(args.parentIdentifier, ctx);
                     return await resolvers.addChildren(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in addChildren:", error);
+                    this.logger.error("Error in addChildren(@args): @Error", error);
                     throw error;
                 }
             },
             removeChildren: async (_parent, args, ctx) => {
-                this.logger.debug("removeChildren", args);
+                this.logger.debug("removeChildren(@args)", args);
                 try {
-                    // Check write permission on parent
-                    const parent = await resolvers.document(this.reactorClient, {
-                        identifier: args.parentIdentifier,
-                    });
-                    if (parent) {
-                        await this.assertCanWrite(parent.document.id, ctx);
-                    }
+                    await this.assertCanWrite(args.parentIdentifier, ctx);
                     return await resolvers.removeChildren(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in removeChildren:", error);
+                    this.logger.error("Error in removeChildren(@args): @Error", error);
                     throw error;
                 }
             },
             moveChildren: async (_parent, args, ctx) => {
-                this.logger.debug("moveChildren", args);
+                this.logger.debug("moveChildren(@args)", args);
                 try {
-                    // Check write permission on both source and target parents
-                    const sourceParent = await resolvers.document(this.reactorClient, {
-                        identifier: args.sourceParentIdentifier,
-                    });
-                    if (sourceParent) {
-                        await this.assertCanWrite(sourceParent.document.id, ctx);
-                    }
-                    const targetParent = await resolvers.document(this.reactorClient, {
-                        identifier: args.targetParentIdentifier,
-                    });
-                    if (targetParent) {
-                        await this.assertCanWrite(targetParent.document.id, ctx);
-                    }
+                    await this.assertCanWrite(args.sourceParentIdentifier, ctx);
+                    await this.assertCanWrite(args.targetParentIdentifier, ctx);
                     return await resolvers.moveChildren(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in moveChildren:", error);
+                    this.logger.error("Error in moveChildren(@args): @Error @args", error, args);
                     throw error;
                 }
             },
             deleteDocument: async (_parent, args, ctx) => {
-                this.logger.debug("deleteDocument", args);
+                this.logger.debug("deleteDocument(@args)", args);
                 try {
-                    // Check write permission on document
-                    const doc = await resolvers.document(this.reactorClient, {
-                        identifier: args.identifier,
-                    });
-                    if (doc) {
-                        await this.assertCanWrite(doc.document.id, ctx);
-                    }
+                    await this.assertCanWrite(args.identifier, ctx);
                     return await resolvers.deleteDocument(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in deleteDocument:", error);
+                    this.logger.error("Error in deleteDocument(@args): @Error", error);
                     throw error;
                 }
             },
             deleteDocuments: async (_parent, args, ctx) => {
-                this.logger.debug("deleteDocuments", args);
+                this.logger.debug("deleteDocuments(@args)", args);
                 try {
                     // Check write permission on each document
                     for (const identifier of args.identifiers) {
-                        const doc = await resolvers.document(this.reactorClient, {
-                            identifier,
-                        });
-                        if (doc) {
-                            await this.assertCanWrite(doc.document.id, ctx);
-                        }
+                        await this.assertCanWrite(identifier, ctx);
                     }
                     return await resolvers.deleteDocuments(this.reactorClient, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in deleteDocuments:", error);
+                    this.logger.error("Error in deleteDocuments(@args): @Error", error);
                     throw error;
                 }
             },
             touchChannel: async (_parent, args) => {
-                this.logger.debug("touchChannel", args);
+                this.logger.debug("touchChannel(@args)", args);
                 try {
                     return await resolvers.touchChannel(this.syncManager, args);
                 }
                 catch (error) {
-                    this.logger.error("Error in touchChannel:", error);
+                    this.logger.error("Error in touchChannel(@args): @Error", error);
                     throw error;
                 }
             },
-            pushSyncEnvelope: async (_parent, args) => {
-                this.logger.debug("pushSyncEnvelope(@args)", args);
+            pushSyncEnvelopes: async (_parent, args) => {
+                this.logger.debug("pushSyncEnvelopes(@args)", args);
                 try {
                     // Convert readonly arrays to mutable arrays for the resolver
                     const mutableArgs = {
-                        envelope: {
-                            type: args.envelope.type,
-                            channelMeta: { id: args.envelope.channelMeta.id },
-                            operations: args.envelope.operations
-                                ? args.envelope.operations.map((op) => ({
+                        envelopes: args.envelopes.map((envelope) => ({
+                            type: envelope.type,
+                            channelMeta: { id: envelope.channelMeta.id },
+                            operations: envelope.operations
+                                ? envelope.operations.map((op) => ({
                                     operation: op.operation,
                                     context: {
                                         documentId: op.context.documentId,
                                         documentType: op.context.documentType,
                                         scope: op.context.scope,
                                         branch: op.context.branch,
+                                        ordinal: op.context.ordinal,
                                     },
                                 }))
                                 : null,
-                            cursor: args.envelope.cursor
+                            cursor: envelope.cursor
                                 ? {
-                                    remoteName: args.envelope.cursor.remoteName,
-                                    cursorOrdinal: args.envelope.cursor.cursorOrdinal,
-                                    lastSyncedAtUtcMs: args.envelope.cursor.lastSyncedAtUtcMs,
+                                    remoteName: envelope.cursor.remoteName,
+                                    cursorOrdinal: envelope.cursor.cursorOrdinal,
+                                    lastSyncedAtUtcMs: envelope.cursor.lastSyncedAtUtcMs,
                                 }
                                 : null,
-                        },
+                            key: envelope.key ?? undefined,
+                            dependsOn: envelope.dependsOn
+                                ? [...envelope.dependsOn]
+                                : undefined,
+                        })),
                     };
-                    return await resolvers.pushSyncEnvelope(this.syncManager, mutableArgs);
+                    return await resolvers.pushSyncEnvelopes(this.syncManager, mutableArgs);
                 }
                 catch (error) {
-                    this.logger.error("Error in pushSyncEnvelope:", error);
+                    this.logger.error("Error in pushSyncEnvelopes(@args): @Error", error);
                     throw error;
                 }
             },
@@ -485,7 +408,7 @@ export class ReactorSubgraph extends BaseSubgraph {
                 subscribe: withFilter(
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 (() => {
-                    this.logger.debug("documentChanges subscription started");
+                    this.logger.debug("documentChanges(@args) subscription started");
                     ensureGlobalDocumentSubscription(this.reactorClient);
                     return getPubSub().asyncIterableIterator(SUBSCRIPTION_TRIGGERS.DOCUMENT_CHANGES);
                 }), 
@@ -509,7 +432,7 @@ export class ReactorSubgraph extends BaseSubgraph {
                 subscribe: withFilter(
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 ((_parent, args) => {
-                    this.logger.debug("jobChanges subscription", args);
+                    this.logger.debug("jobChanges(@args) subscription started", args);
                     ensureJobSubscription(this.reactorClient, args.jobId);
                     return getPubSub().asyncIterableIterator(SUBSCRIPTION_TRIGGERS.JOB_CHANGES);
                 }),