lorenz 0.1.10 → 0.1.11

package/node_modules/@lorenz/linear-tracker/dist/client.js

@@ -1,10 +1,12 @@
 import { LinearGraphQLClient } from "@linear/sdk";
 export { LinearGraphQLClient } from "@linear/sdk";
 import { normalizeIssue } from "@lorenz/issue";
-import { errorMessage, isRecord, normalizeStateType, } from "@lorenz/domain";
+import { createTrackerPaginationGuard } from "@lorenz/tracker-sdk";
+import { errorMessage, isRecord, normalizeStateType, redactDiagnosticText, } from "@lorenz/domain";
+import { linearErrorContext } from "./diagnostics.js";
 import { linearEndpoint, linearTrackerOptions } from "./options.js";
 const LINEAR_REQUEST_TIMEOUT_MS = 30_000;
-const MAX_ERROR_BODY_LOG_BYTES = 1000;
+const LINEAR_CONNECTION_PAGE_SIZE = 50;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const issueFields = `
   id
@@ -42,6 +44,7 @@ export class LinearClient {
     settings;
     fetchImpl;
     logger;
+    paginationLimits;
     constructor(settings, fetchImplOrDeps, retryOptions = {}) {
         this.settings = settings;
         this.retryOptions = {
@@ -58,6 +61,7 @@ export class LinearClient {
             warn: (message) => console.warn(message),
             error: (message) => console.error(message),
         };
+        this.paginationLimits = deps.paginationLimits;
         if (deps.graphqlClient) {
             this.gqlClient = deps.graphqlClient;
         }
@@ -106,9 +110,11 @@ export class LinearClient {
         catch (error) {
             if (!response.ok) {
                 this.logStatusError(query, response.status, errorBodyText ?? errorMessage(error));
-                throw new Error(`linear api status ${response.status}`, { cause: error });
+                // eslint-disable-next-line preserve-caught-error -- Secret-boundary rethrows must not retain provider error objects.
+                throw new Error(`linear api status ${response.status}`);
             }
-            throw new Error(`linear_invalid_json: ${errorMessage(error)}`, { cause: error });
+            // eslint-disable-next-line preserve-caught-error -- Secret-boundary rethrows must not retain provider error objects.
+            throw new Error(`linear_invalid_json: ${redactDiagnosticText(errorMessage(error))}`);
         }
         if (response.status === 429) {
             this.logStatusError(query, response.status, body);
@@ -116,7 +122,7 @@ export class LinearClient {
         }
         if (isRecord(body) && Array.isArray(body.errors) && body.errors.length > 0) {
             this.logStatusError(query, response.status, body);
-            throw new Error(`linear_graphql_errors: ${JSON.stringify(body.errors)}`);
+            throw new Error(`linear_graphql_errors: ${redactDiagnosticText(JSON.stringify(body.errors))}`);
         }
         if (!response.ok) {
             this.logStatusError(query, response.status, body);
@@ -144,7 +150,8 @@ export class LinearClient {
             }
             catch (error) {
                 this.logRequestError(query, error);
-                throw error;
+                // eslint-disable-next-line preserve-caught-error -- Secret-boundary rethrows must not retain provider error objects.
+                throw new Error(redactDiagnosticText(errorMessage(error)));
             }
             if (response.status !== 429 || retryCount >= this.retryOptions.maxRetries)
                 return response;
@@ -182,7 +189,7 @@ export class LinearClient {
         const project = data.projects.nodes[0];
         if (!project)
             throw new Error(`linear project not found: ${projectSlug}`);
-        return parseProject(project);
+        return this.parseProject(project);
     }
     async fetchCandidateIssues() {
         return this.fetchIssuesByStates(this.settings.tracker.activeStates);
@@ -195,7 +202,13 @@ export class LinearClient {
         const issues = [];
         const assignee = await this.assigneeFilterValue();
         const projectSlugs = await this.resolveProjectSlugs();
+        const pagination = createTrackerPaginationGuard({
+            tracker: "linear",
+            resource: "issues",
+            limits: this.paginationLimits,
+        });
         for (;;) {
+            pagination.recordPage();
             const data = await this.graphql(`query LorenzTsPoll($projectSlugs: [String!]!, $stateNames: [String!]!, $first: Int!, $after: String) {
           issues(filter: {project: {slugId: {in: $projectSlugs}}, state: {name: {in: $stateNames}}}, first: $first, after: $after) {
             nodes { ${issueFields} }
@@ -207,18 +220,22 @@ export class LinearClient {
                 first: 50,
                 after,
             });
-            appendNormalizedIssues(issues, data.issues.nodes, assignee);
+            pagination.recordItems(data.issues.nodes.length);
+            await this.appendNormalizedIssues(issues, data.issues.nodes, assignee);
             if (!data.issues.pageInfo.hasNextPage)
                 return issues;
-            if (!data.issues.pageInfo.endCursor)
-                throw new Error("linear_missing_end_cursor");
-            after = data.issues.pageInfo.endCursor;
+            after = pagination.nextCursor(data.issues.pageInfo.endCursor, "endCursor");
         }
     }
     async fetchIssuesByIds(ids) {
         const uniqueIds = [...new Set(ids)];
         if (uniqueIds.length === 0)
             return [];
+        createTrackerPaginationGuard({
+            tracker: "linear",
+            resource: "issuesByIds",
+            limits: this.paginationLimits,
+        }).recordItems(uniqueIds.length);
         const assignee = await this.assigneeFilterValue();
         const issueOrder = new Map(uniqueIds.map((id, index) => [id, index]));
         const issues = [];
@@ -230,7 +247,7 @@ export class LinearClient {
               nodes { ${issueFields} }
             }
           }`, { ids: batchIds, first: batchIds.length });
-                appendNormalizedIssues(issues, data.issues.nodes, assignee);
+                await this.appendNormalizedIssues(issues, data.issues.nodes, assignee);
             }
             catch (error) {
                 // Identifier-shaped inputs ("MT-32" from workspace directory names) can make
@@ -255,7 +272,7 @@ export class LinearClient {
             }
           }`, { id });
                 if (data.issue)
-                    appendNormalizedIssues(issues, [data.issue], assignee);
+                    await this.appendNormalizedIssues(issues, [data.issue], assignee);
             }
             catch {
                 // Best-effort identifier resolution.
@@ -286,7 +303,10 @@ export class LinearClient {
         });
         if (!data.issueCreate.success || !data.issueCreate.issue)
             throw new Error("linear issueCreate failed");
-        return normalizeIssue(linearIssuePayload(data.issueCreate.issue), await this.assigneeFilterValue());
+        const normalized = await this.normalizeLinearIssue(data.issueCreate.issue, await this.assigneeFilterValue());
+        if (!normalized)
+            throw new Error("linear issueCreate returned malformed issue");
+        return normalized;
     }
     async updateIssueState(issueId, stateId) {
         const data = await this.graphql(`mutation LorenzTsUpdateIssue($id: String!, $input: IssueUpdateInput!) {
@@ -297,7 +317,10 @@ export class LinearClient {
       }`, { id: issueId, input: { stateId } });
         if (!data.issueUpdate.success || !data.issueUpdate.issue)
             throw new Error("linear issueUpdate failed");
-        return normalizeIssue(linearIssuePayload(data.issueUpdate.issue), await this.assigneeFilterValue());
+        const normalized = await this.normalizeLinearIssue(data.issueUpdate.issue, await this.assigneeFilterValue());
+        if (!normalized)
+            throw new Error("linear issueUpdate returned malformed issue");
+        return normalized;
     }
     async archiveIssue(issueId) {
         const data = await this.graphql(`mutation LorenzTsArchiveIssue($id: String!) {
@@ -335,24 +358,276 @@ export class LinearClient {
     async resolveProjectSlugsByLabels(labels) {
         let after = null;
         const slugs = [];
+        const pagination = createTrackerPaginationGuard({
+            tracker: "linear",
+            resource: "projectsByLabels",
+            limits: this.paginationLimits,
+        });
         for (;;) {
+            pagination.recordPage();
             const data = await this.graphql(`query LorenzTsProjectsByLabels($labels: [String!]!, $first: Int!, $after: String) {
           projects(filter: {labels: {name: {in: $labels}}}, first: $first, after: $after) {
             nodes { slugId }
             pageInfo { hasNextPage endCursor }
           }
         }`, { labels, first: 100, after });
+            pagination.recordItems(data.projects.nodes.length);
             slugs.push(...data.projects.nodes.map((p) => p.slugId));
             if (!data.projects.pageInfo?.hasNextPage)
                 break;
-            if (!data.projects.pageInfo.endCursor)
-                throw new Error("linear_missing_end_cursor: projectsByLabels");
-            after = data.projects.pageInfo.endCursor;
+            after = pagination.nextCursor(data.projects.pageInfo.endCursor, "endCursor");
         }
         if (slugs.length === 0)
             throw new Error(`no linear projects found for labels: ${labels.join(", ")}`);
         return slugs;
     }
+    async appendNormalizedIssues(target, nodes, assignee) {
+        for (const issue of nodes) {
+            const normalized = await this.normalizeLinearIssue(issue, assignee);
+            if (normalized)
+                target.push(normalized);
+        }
+    }
+    async normalizeLinearIssue(issue, assignee) {
+        if (!isRecord(issue))
+            return null;
+        try {
+            return normalizeIssue(await this.linearIssuePayload(issue), assignee);
+        }
+        catch {
+            return null;
+        }
+    }
+    async linearIssuePayload(issue) {
+        const source = issueSource(issue);
+        const issueId = stringField(issue, "id");
+        const [labels, inverseRelations] = await Promise.all([
+            this.completePagedConnection({
+                source,
+                connection: "issue.labels",
+                initial: issue.labels,
+                fetchPage: async (after) => this.fetchIssueLabelsPage(issueId, after),
+            }),
+            this.completePagedConnection({
+                source,
+                connection: "issue.inverseRelations",
+                initial: issue.inverseRelations,
+                fetchPage: async (after) => this.fetchIssueInverseRelationsPage(issueId, after),
+            }),
+        ]);
+        const degradedConnections = [
+            ...labels.degradedConnections,
+            ...inverseRelations.degradedConnections,
+        ];
+        if (degradedConnections.length > 0)
+            this.logDegradedConnections(degradedConnections);
+        return linearIssuePayload({
+            ...issue,
+            labels: connectionFromNodes(labels.nodes),
+            inverseRelations: connectionFromNodes(inverseRelations.nodes),
+        }, degradedConnections);
+    }
+    async fetchIssueLabelsPage(issueId, after) {
+        const data = await this.graphql(`query LorenzTsIssueLabels($id: String!, $first: Int!, $after: String) {
+        issue(id: $id) {
+          labels(first: $first, after: $after) {
+            nodes { name }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }`, { id: issueId, first: LINEAR_CONNECTION_PAGE_SIZE, after });
+        if (!data.issue)
+            throw new Error(`linear issue not found: ${issueId}`);
+        return data.issue.labels;
+    }
+    async fetchIssueInverseRelationsPage(issueId, after) {
+        const data = await this.graphql(`query LorenzTsIssueInverseRelations($id: String!, $first: Int!, $after: String) {
+        issue(id: $id) {
+          inverseRelations(first: $first, after: $after) {
+            nodes {
+              type
+              issue {
+                id
+                identifier
+                state { name type }
+              }
+            }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }`, { id: issueId, first: LINEAR_CONNECTION_PAGE_SIZE, after });
+        if (!data.issue)
+            throw new Error(`linear issue not found: ${issueId}`);
+        return data.issue.inverseRelations;
+    }
+    async parseProject(project) {
+        const id = stringField(project, "id");
+        const name = stringField(project, "name");
+        const slugId = stringField(project, "slugId");
+        const teams = await this.completePagedConnection({
+            source: projectSource(project),
+            connection: "project.teams",
+            initial: project.teams,
+            fetchPage: async (after) => this.fetchProjectTeamsPage(id, after),
+        });
+        const parsedTeams = await Promise.all(teams.nodes.map(async (team) => this.parseTeam(asRecord(team))));
+        const degradedConnections = [
+            ...teams.degradedConnections,
+            ...parsedTeams.flatMap((team) => team.degradedConnections ?? []),
+        ];
+        if (degradedConnections.length > 0)
+            this.logDegradedConnections(degradedConnections);
+        return {
+            id,
+            name,
+            slugId,
+            teams: parsedTeams,
+            ...(degradedConnections.length > 0 ? { degradedConnections } : {}),
+        };
+    }
+    async fetchProjectTeamsPage(projectId, after) {
+        const data = await this.graphql(`query LorenzTsProjectTeams($id: String!, $first: Int!, $after: String) {
+        project(id: $id) {
+          teams(first: $first, after: $after) {
+            nodes {
+              id
+              key
+              name
+              states(first: $first) {
+                nodes { id name type }
+                pageInfo { hasNextPage endCursor }
+              }
+            }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }`, { id: projectId, first: LINEAR_CONNECTION_PAGE_SIZE, after });
+        if (!data.project)
+            throw new Error(`linear project not found: ${projectId}`);
+        return data.project.teams;
+    }
+    async parseTeam(team) {
+        const id = stringField(team, "id");
+        const key = stringField(team, "key");
+        const name = stringField(team, "name");
+        const states = await this.completePagedConnection({
+            source: teamSource(team),
+            connection: "project.team.states",
+            initial: team.states,
+            fetchPage: async (after) => this.fetchTeamStatesPage(id, after),
+        });
+        const degradedConnections = states.degradedConnections;
+        return {
+            id,
+            key,
+            name,
+            states: states.nodes.map((state) => {
+                const stateRecord = asRecord(state);
+                return {
+                    id: stringField(stateRecord, "id"),
+                    name: stringField(stateRecord, "name"),
+                    type: normalizeStateType(stringField(stateRecord, "type")),
+                };
+            }),
+            ...(degradedConnections.length > 0 ? { degradedConnections } : {}),
+        };
+    }
+    async fetchTeamStatesPage(teamId, after) {
+        const data = await this.graphql(`query LorenzTsTeamStates($id: String!, $first: Int!, $after: String) {
+        team(id: $id) {
+          states(first: $first, after: $after) {
+            nodes { id name type }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }`, { id: teamId, first: LINEAR_CONNECTION_PAGE_SIZE, after });
+        if (!data.team)
+            throw new Error(`linear team not found: ${teamId}`);
+        return data.team.states;
+    }
+    async completePagedConnection(input) {
+        const pagination = createTrackerPaginationGuard({
+            tracker: "linear",
+            resource: input.connection,
+            limits: this.paginationLimits,
+        });
+        const initial = connectionSnapshot(input.initial);
+        const nodes = [...initial.nodes];
+        try {
+            pagination.recordPage();
+            pagination.recordItems(initial.nodes.length);
+        }
+        catch (error) {
+            return {
+                nodes: [],
+                degradedConnections: [degradedConnection(input, errorMessage(error))],
+            };
+        }
+        if (!initial.pageInfo?.hasNextPage)
+            return { nodes, degradedConnections: [] };
+        let after;
+        try {
+            after = pagination.nextCursor(initial.pageInfo.endCursor, "endCursor");
+        }
+        catch (error) {
+            return {
+                nodes,
+                degradedConnections: [
+                    degradedConnection(input, errorMessage(error), initial.pageInfo.endCursor),
+                ],
+            };
+        }
+        for (;;) {
+            let page;
+            try {
+                pagination.recordPage();
+                page = await input.fetchPage(after);
+            }
+            catch (error) {
+                return {
+                    nodes,
+                    degradedConnections: [degradedConnection(input, errorMessage(error), after)],
+                };
+            }
+            const next = connectionSnapshot(page);
+            if (!next.isConnection) {
+                return {
+                    nodes,
+                    degradedConnections: [
+                        degradedConnection(input, "linear_invalid_connection_payload", after),
+                    ],
+                };
+            }
+            try {
+                pagination.recordItems(next.nodes.length);
+            }
+            catch (error) {
+                return {
+                    nodes,
+                    degradedConnections: [degradedConnection(input, errorMessage(error), after)],
+                };
+            }
+            nodes.push(...next.nodes);
+            if (!next.pageInfo?.hasNextPage)
+                return { nodes, degradedConnections: [] };
+            try {
+                after = pagination.nextCursor(next.pageInfo.endCursor, "endCursor");
+            }
+            catch (error) {
+                return {
+                    nodes,
+                    degradedConnections: [
+                        degradedConnection(input, errorMessage(error), next.pageInfo.endCursor),
+                    ],
+                };
+            }
+        }
+    }
+    logDegradedConnections(degradedConnections) {
+        for (const degraded of degradedConnections) {
+            this.logger.warn(`linear tracker degraded connection source=${degraded.source} connection=${degraded.connection} reason=${degraded.reason}${degraded.cursor ? ` cursor=${degraded.cursor}` : ""}`);
+        }
+    }
     requiredProjectSlug() {
         const { projectSlug } = linearTrackerOptions(this.settings);
         if (!projectSlug)
@@ -388,80 +663,48 @@ export class LinearClient {
         this.logger.error(`Linear GraphQL request failed status=${status}${linearErrorContext(query, body)}`);
     }
     logRequestError(query, error) {
-        this.logger.error(`Linear GraphQL request failed: ${errorMessage(error)}${linearErrorContext(query)}`);
+        this.logger.error(`Linear GraphQL request failed: ${redactDiagnosticText(errorMessage(error))}${linearErrorContext(query)}`);
     }
 }
 function resolveDeps(fetchImplOrDeps) {
     if (!fetchImplOrDeps)
-        return { fetchImpl: undefined, graphqlClient: undefined, logger: undefined };
+        return {
+            fetchImpl: undefined,
+            graphqlClient: undefined,
+            logger: undefined,
+            paginationLimits: undefined,
+        };
     if (typeof fetchImplOrDeps === "function")
-        return { fetchImpl: fetchImplOrDeps, graphqlClient: undefined, logger: undefined };
+        return {
+            fetchImpl: fetchImplOrDeps,
+            graphqlClient: undefined,
+            logger: undefined,
+            paginationLimits: undefined,
+        };
     return {
         fetchImpl: fetchImplOrDeps.fetchImpl ?? undefined,
         graphqlClient: fetchImplOrDeps.graphqlClient ?? undefined,
         logger: fetchImplOrDeps.logger ?? undefined,
+        paginationLimits: fetchImplOrDeps.paginationLimits ?? undefined,
     };
 }
-function linearIssuePayload(issue) {
+function linearIssuePayload(issue, degradedConnections = []) {
     return {
         ...issue,
         state: issue.state,
         state_type: isRecord(issue.state) ? issue.state.type : null,
         branch_name: issue.branchName,
         assignee_id: isRecord(issue.assignee) ? issue.assignee.id : null,
-        labels: nodesFromConnection(issue.labels, "issue.labels"),
-        relations: nodesFromConnection(issue.inverseRelations, "issue.inverseRelations"),
+        labels: connectionSnapshot(issue.labels).nodes,
+        relations: connectionSnapshot(issue.inverseRelations).nodes,
         created_at: issue.createdAt,
         updated_at: issue.updatedAt,
+        ...(degradedConnections.length > 0 ? { linear_degraded_connections: degradedConnections } : {}),
     };
 }
-function appendNormalizedIssues(target, nodes, assignee) {
-    for (const issue of nodes) {
-        const normalized = normalizeLinearIssue(issue, assignee);
-        if (normalized)
-            target.push(normalized);
-    }
-}
-function normalizeLinearIssue(issue, assignee) {
-    if (!isRecord(issue))
-        return null;
-    try {
-        return normalizeIssue(linearIssuePayload(issue), assignee);
-    }
-    catch (error) {
-        if (isLinearConnectionTruncatedError(error))
-            throw error;
-        return null;
-    }
-}
 function normalizeStateNames(stateNames) {
     return [...new Set(stateNames.map((stateName) => String(stateName)))];
 }
-function parseProject(project) {
-    const teams = nodesFromConnection(project.teams, "project.teams");
-    return {
-        id: stringField(project, "id"),
-        name: stringField(project, "name"),
-        slugId: stringField(project, "slugId"),
-        teams: teams.map((team) => {
-            const teamRecord = asRecord(team);
-            const states = nodesFromConnection(teamRecord.states, "project.team.states");
-            return {
-                id: stringField(teamRecord, "id"),
-                key: stringField(teamRecord, "key"),
-                name: stringField(teamRecord, "name"),
-                states: states.map((state) => {
-                    const stateRecord = asRecord(state);
-                    return {
-                        id: stringField(stateRecord, "id"),
-                        name: stringField(stateRecord, "name"),
-                        type: normalizeStateType(stringField(stateRecord, "type")),
-                    };
-                }),
-            };
-        }),
-    };
-}
 function isRateLimitError(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -484,35 +727,61 @@ function retryDelayFromError(error, options, retryCount) {
 }
 function reclassifyError(error) {
     if (error instanceof Error) {
-        const msg = error.message;
+        const msg = redactDiagnosticText(error.message);
+        const cause = redactedLinearCause(error);
         if (msg.includes("429"))
-            return new Error("linear api status 429", { cause: error });
+            return new Error("linear api status 429", { cause });
         if (msg.toLowerCase().includes("graphql")) {
-            return new Error(`linear_graphql_errors: ${msg}`, { cause: error });
+            return new Error(`linear_graphql_errors: ${msg}`, { cause });
         }
-        return error;
+        return new Error(msg, { cause });
     }
-    return new Error(String(error));
+    return new Error(redactDiagnosticText(String(error)));
 }
-class LinearConnectionTruncatedError extends Error {
-    constructor(connectionName) {
-        super(`linear_truncated_connection: ${connectionName}`);
-        this.name = "LinearConnectionTruncatedError";
-    }
+function redactedLinearCause(error) {
+    return new Error(redactDiagnosticText(errorMessage(error)));
 }
-function isLinearConnectionTruncatedError(error) {
-    return error instanceof LinearConnectionTruncatedError;
+function isConnection(value) {
+    return isRecord(value) && Array.isArray(value.nodes);
 }
-function nodesFromConnection(value, connectionName) {
+function connectionSnapshot(value) {
     if (!isConnection(value))
-        return [];
-    if (isRecord(value.pageInfo) && value.pageInfo.hasNextPage === true) {
-        throw new LinearConnectionTruncatedError(connectionName);
-    }
-    return value.nodes;
+        return { nodes: [], pageInfo: null, isConnection: false };
+    return { nodes: value.nodes, pageInfo: connectionPageInfo(value.pageInfo), isConnection: true };
 }
-function isConnection(value) {
-    return isRecord(value) && Array.isArray(value.nodes);
+function connectionPageInfo(value) {
+    if (!isRecord(value) || typeof value.hasNextPage !== "boolean")
+        return null;
+    return {
+        hasNextPage: value.hasNextPage,
+        endCursor: typeof value.endCursor === "string" || value.endCursor === null ? value.endCursor : null,
+    };
+}
+function connectionFromNodes(nodes) {
+    return { nodes, pageInfo: { hasNextPage: false, endCursor: null } };
+}
+function degradedConnection(input, reason, cursor) {
+    return {
+        source: input.source,
+        connection: input.connection,
+        reason,
+        ...(cursor !== undefined ? { cursor } : {}),
+    };
+}
+function issueSource(issue) {
+    const identifier = typeof issue.identifier === "string" ? issue.identifier : "unknown";
+    const id = typeof issue.id === "string" ? issue.id : "unknown";
+    return `issue ${identifier} (${id})`;
+}
+function projectSource(project) {
+    const slug = typeof project.slugId === "string" ? project.slugId : "unknown";
+    const id = typeof project.id === "string" ? project.id : "unknown";
+    return `project ${slug} (${id})`;
+}
+function teamSource(team) {
+    const key = typeof team.key === "string" ? team.key : "unknown";
+    const id = typeof team.id === "string" ? team.id : "unknown";
+    return `team ${key} (${id})`;
 }
 function stringField(record, key) {
     const value = record[key];
@@ -525,25 +794,6 @@ function asRecord(value) {
         throw new Error("expected Linear object");
     return value;
 }
-function linearErrorContext(query, body) {
-    const parts = [];
-    const operation = operationName(query);
-    if (operation)
-        parts.push(`operation=${operation}`);
-    if (body !== undefined)
-        parts.push(`body=${summarizeErrorBody(body)}`);
-    return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
-}
-function operationName(query) {
-    return /\b(?:query|mutation)\s+([A-Za-z_][A-Za-z0-9_]*)/.exec(query)?.[1] ?? null;
-}
-function summarizeErrorBody(body) {
-    const text = typeof body === "string" ? body : (JSON.stringify(body) ?? String(body));
-    const compact = text.replace(/\s+/g, " ").trim();
-    if (compact.length <= MAX_ERROR_BODY_LOG_BYTES)
-        return compact;
-    return `${compact.slice(0, MAX_ERROR_BODY_LOG_BYTES)}...<truncated>`;
-}
 function retryAfterHeaderValueFromError(error) {
     if (!isRecord(error))
         return null;