@oneuptime/common 14.0.6 → 14.0.7

package/build/dist/Server/Utils/Topology/TopologyQueries.js

@@ -0,0 +1,884 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { PostgresStatementTimeoutMs } from "../../EnvironmentConfig";
+import InventoryItemService from "../../Services/InventoryItemService";
+import CaptureSpan from "../Telemetry/CaptureSpan";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { TOPOLOGY_API_FORMAT_VERSION, TOPOLOGY_CONNECTION_SECTIONS, TopologyApiLimits, } from "../../../Types/Topology/TopologyApi";
+import { isFlatInfrastructureType, isTopologyInfrastructureType, } from "../../../Types/Topology/TopologyTypeRules";
+import { rowsForSection, } from "./TopologyRequest";
+import { collectionPageStatement, collectionSearchStatement, entitySectionsStatement, entityStatement, infrastructureNodesStatement, infrastructureTypeCountsStatement, itemsByKeysStatement, placementsStatement, duplicateKeysStatement, projectTypesStatement, serviceMapDependenciesStatement, serviceMapEntitiesStatement, servicesStatement, } from "./TopologySql";
+/*
+ * The Topology API's reads: Postgres reduces the inventory graph and each
+ * view receives only the rows it draws, computed over the whole inventory.
+ * The SQL lives in TopologySql; this module runs it and shapes the contract
+ * JSON (Common/Types/Topology/TopologyApi.ts).
+ *
+ * Every request reads one consistent snapshot on one connection: a READ ONLY
+ * REPEATABLE READ transaction whose statements run one after another, so the
+ * service list, the relationships and the counts a response is built from can
+ * never disagree with each other. Parallel query is switched off for the
+ * transaction: the docker-compose Postgres has a 64 MB /dev/shm, and parallel
+ * hash joins over a large project fail there under concurrent load ("could not
+ * resize shared memory segment"); the heaviest statement here is a single pass
+ * over one project and does not need the workers. JIT is off too: it spends
+ * 100-200 ms compiling each large statement and wins nothing back on reads of
+ * this size.
+ *
+ * The statement timeout is set on the transaction as well, not left to the
+ * connection's startup parameter: PgBouncer drops that parameter, and behind
+ * it nothing but node-postgres's client-side query_timeout would remain — which
+ * abandons a query without cancelling it, leaving one of the heaviest reads in
+ * the app running on the server (holding its snapshot) after the user was
+ * already told it failed. The configured value stays below that client
+ * timeout, so Postgres cancels first.
+ */
+/*
+ * `SET LOCAL statement_timeout = <ms>` for the configured statement timeout,
+ * or null when none is configured (0, or not a number): then the connection's
+ * own setting applies, as for every other query.
+ */
+export function statementTimeoutSql(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+        return null;
+    }
+    return `SET LOCAL statement_timeout = ${Math.floor(timeoutMs)}`;
+}
+// ---------------------------------------------------------------- decoding
+function readString(row, key) {
+    const value = row[key];
+    return typeof value === "string" ? value : String(value !== null && value !== void 0 ? value : "");
+}
+function readNullableString(row, key) {
+    const value = row[key];
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return typeof value === "string" ? value : String(value);
+}
+function readNullableNumber(row, key) {
+    const value = row[key];
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function readNumber(row, key) {
+    var _a;
+    return (_a = readNullableNumber(row, key)) !== null && _a !== void 0 ? _a : 0;
+}
+function readBoolean(row, key) {
+    const value = row[key];
+    return value === true || value === "t" || value === "true";
+}
+function readJsonObject(row, key) {
+    const value = row[key];
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+/* A bag of string attributes, or undefined when it holds none. */
+function readStringBag(row, key) {
+    const bag = readJsonObject(row, key);
+    if (!bag) {
+        return undefined;
+    }
+    const strings = {};
+    let count = 0;
+    for (const attribute of Object.keys(bag).sort()) {
+        const value = bag[attribute];
+        if (typeof value === "string") {
+            strings[attribute] = value;
+            count++;
+        }
+    }
+    return count > 0 ? strings : undefined;
+}
+function toLeanEntity(row) {
+    var _a;
+    return {
+        key: readString(row, "key"),
+        type: readString(row, "type"),
+        name: readNullableString(row, "name"),
+        /* The column is NOT NULL; "" reads as "no source" on both sides. */
+        source: (_a = readNullableString(row, "source")) !== null && _a !== void 0 ? _a : "",
+        lastSeenAt: readNullableNumber(row, "lastSeenAt"),
+    };
+}
+function toServiceMapEntity(row) {
+    const entity = toLeanEntity(row);
+    const descriptive = readStringBag(row, "descriptiveAttributes");
+    const identifying = readStringBag(row, "identifyingAttributes");
+    if (descriptive) {
+        entity.descriptiveAttributes = descriptive;
+    }
+    if (identifying) {
+        entity.identifyingAttributes = identifying;
+    }
+    return entity;
+}
+function toConnectionRow(value) {
+    const row = (value || {});
+    const connection = {
+        relationshipType: readString(row, "relationshipType"),
+        direction: row["direction"] === "in" ? "in" : "out",
+        otherKey: readString(row, "otherKey"),
+        otherKnown: readBoolean(row, "otherKnown"),
+        otherName: readNullableString(row, "otherName"),
+        otherType: readNullableString(row, "otherType"),
+        callCount: readNullableNumber(row, "callCount"),
+        errorCount: readNullableNumber(row, "errorCount"),
+        avgDurationMs: readNullableNumber(row, "avgDurationMs"),
+        lastSeenAt: readNullableNumber(row, "lastSeenAt"),
+    };
+    // Only the all-time statement selects it; the drawer's rows stay as they were.
+    if ("otherId" in row) {
+        connection.otherId = readNullableString(row, "otherId");
+    }
+    return connection;
+}
+function compareCodeUnits(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    return left > right ? 1 : 0;
+}
+function emptySections() {
+    return {
+        calls: { total: 0, unknownTotal: 0, rows: [], nextOffset: null },
+        calledBy: { total: 0, unknownTotal: 0, rows: [], nextOffset: null },
+        runsOn: { total: 0, unknownTotal: 0, rows: [], nextOffset: null },
+        related: { total: 0, unknownTotal: 0, rows: [], nextOffset: null },
+    };
+}
+function isSection(value) {
+    return TOPOLOGY_CONNECTION_SECTIONS.some((section) => {
+        return section === value;
+    });
+}
+/*
+ * Decodes entitySectionsStatement's single row. `offset` is where the rows of
+ * each section start (0 for the drawer's first view).
+ */
+function decodeSections(rows, offset) {
+    const sections = emptySections();
+    const row = rows[0] || {};
+    const totals = row["sections"];
+    for (const total of Array.isArray(totals) ? totals : []) {
+        const entry = (total || {});
+        const section = entry["section"];
+        if (isSection(section)) {
+            sections[section].total = readNumber(entry, "total");
+            sections[section].unknownTotal = readNumber(entry, "unknownTotal");
+        }
+    }
+    const connectionRows = row["rows"];
+    for (const connection of Array.isArray(connectionRows)
+        ? connectionRows
+        : []) {
+        const section = (connection || {})["section"];
+        if (isSection(section)) {
+            sections[section].rows.push(toConnectionRow(connection));
+        }
+    }
+    for (const section of TOPOLOGY_CONNECTION_SECTIONS) {
+        const reached = offset + sections[section].rows.length;
+        sections[section].nextOffset =
+            sections[section].rows.length > 0 && reached < sections[section].total
+                ? reached
+                : null;
+    }
+    return {
+        sections,
+        isScanLimited: readNumber(row, "scanned") > TopologyApiLimits.EntityConnectionScanLimit,
+    };
+}
+// ------------------------------------------------------------------ queries
+export default class TopologyQueries {
+    /*
+     * Runs `work` on one pooled connection inside a READ ONLY REPEATABLE READ
+     * transaction with a server-side statement timeout. TypeORM commits on
+     * success, rolls back on failure and always releases the connection.
+     */
+    static async inReadOnlySnapshot(work) {
+        const manager = InventoryItemService.getRepository().manager;
+        return await manager.transaction("REPEATABLE READ", async (transaction) => {
+            await transaction.query("SET TRANSACTION READ ONLY");
+            const statementTimeout = statementTimeoutSql(PostgresStatementTimeoutMs);
+            if (statementTimeout) {
+                await transaction.query(statementTimeout);
+            }
+            await transaction.query("SET LOCAL max_parallel_workers_per_gather = 0");
+            await transaction.query("SET LOCAL jit = off");
+            return await work({
+                query: async (statement) => {
+                    return (await transaction.query(statement.sql, statement.params));
+                },
+            });
+        });
+    }
+    static envelope(rangeStart) {
+        return {
+            formatVersion: TOPOLOGY_API_FORMAT_VERSION,
+            rangeStart: rangeStart.toISOString(),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /* The all-time responses have no range start to echo. */
+    static allTimeEnvelope() {
+        return {
+            formatVersion: TOPOLOGY_API_FORMAT_VERSION,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /* The project's distinct entity types (see projectTypesStatement). */
+    static async readProjectTypes(runner, projectId) {
+        const rows = await runner.query(projectTypesStatement({ projectId }));
+        return rows
+            .map((row) => {
+            return readString(row, "entityType");
+        })
+            .filter((type) => {
+            return type.length > 0;
+        });
+    }
+    /*
+     * The project's types plus the keys more than one live row carries, read
+     * once per request so the statements that list items apply the winner rule
+     * only where it can matter (see winnerSql).
+     */
+    static async readWinnerScope(runner, projectId, projectTypes) {
+        const rows = await runner.query(duplicateKeysStatement({ projectId }));
+        return {
+            projectTypes,
+            duplicateKeys: rows
+                .map((row) => {
+                return readString(row, "key");
+            })
+                .sort(compareCodeUnits),
+        };
+    }
+    /*
+     * Rows up to `cap`, or — when there are more — the first `cap` and the
+     * exact total from `count`. The row statement asks for cap + 1 so the
+     * common case (under the cap) costs no count at all.
+     */
+    static async readCapped(runner, rows, count, cap) {
+        const found = await runner.query(rows(cap + 1));
+        if (found.length <= cap) {
+            return { rows: found, total: found.length, count: {} };
+        }
+        const counted = await runner.query(count());
+        const countRow = counted[0] || {};
+        return {
+            rows: found.slice(0, cap),
+            total: Math.max(readNumber(countRow, "total"), cap),
+            count: countRow,
+        };
+    }
+    /*
+     * Per (service, target type): the distinct resources each service runs on
+     * (in-range runs-on / hosted-on onto live items of any type), and how many
+     * of those reported in range. Placements and targets are read separately so
+     * the target lookup is by an array of keys the planner can size.
+     */
+    static async readRunsOnCounts(runner, data) {
+        const placementRows = await runner.query(placementsStatement({
+            projectId: data.projectId,
+            rangeStart: data.rangeStart,
+            serviceKeys: data.serviceKeys,
+        }));
+        if (placementRows.length === 0) {
+            return [];
+        }
+        const targetKeys = Array.from(new Set(placementRows.map((row) => {
+            return readString(row, "target");
+        }))).sort(compareCodeUnits);
+        const targetRows = await runner.query(itemsByKeysStatement({
+            projectId: data.projectId,
+            rangeStart: data.rangeStart,
+            winner: data.winner,
+            keys: targetKeys,
+        }));
+        const targetByKey = new Map();
+        for (const row of targetRows) {
+            targetByKey.set(readString(row, "key"), {
+                type: readString(row, "type"),
+                active: readBoolean(row, "active"),
+            });
+        }
+        const counts = new Map();
+        for (const row of placementRows) {
+            const service = readString(row, "service");
+            const target = targetByKey.get(readString(row, "target"));
+            if (!target) {
+                continue;
+            }
+            const countKey = `${service}\u0000${target.type}`;
+            let count = counts.get(countKey);
+            if (!count) {
+                count = { service, type: target.type, active: 0, total: 0 };
+                counts.set(countKey, count);
+            }
+            /* Placements are distinct (service, target) pairs: one per target. */
+            count.total++;
+            if (target.active) {
+                count.active++;
+            }
+        }
+        return Array.from(counts.values()).sort((left, right) => {
+            return (compareCodeUnits(left.service, right.service) ||
+                compareCodeUnits(left.type, right.type));
+        });
+    }
+    /*
+     * Service Map: every live service, everything services call, the in-range
+     * calls between them, and per (service, target type) what the services run
+     * on. No pods or other infrastructure rows.
+     */
+    static async getServiceMap(request) {
+        const projectId = request.projectId.toString();
+        const rangeStart = request.rangeStart.toISOString();
+        const entityCap = TopologyApiLimits.MaxServiceMapEntities;
+        const dependencyCap = TopologyApiLimits.MaxServiceMapDependencies;
+        return await TopologyQueries.inReadOnlySnapshot(async (runner) => {
+            const response = Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { entities: [], dependencies: [], runsOn: [], entityTruncation: null, dependencyTruncation: null });
+            const projectTypes = await TopologyQueries.readProjectTypes(runner, projectId);
+            if (!projectTypes.includes(EntityType.Service)) {
+                return response;
+            }
+            const winner = await TopologyQueries.readWinnerScope(runner, projectId, projectTypes);
+            const services = await TopologyQueries.readCapped(runner, (limit) => {
+                return serviceMapEntitiesStatement({
+                    projectId,
+                    winner,
+                    mode: "rows",
+                    limit,
+                });
+            }, () => {
+                return serviceMapEntitiesStatement({
+                    projectId,
+                    winner,
+                    mode: "count",
+                    limit: 0,
+                });
+            }, entityCap);
+            const serviceKeys = services.rows.map((row) => {
+                return readString(row, "key");
+            });
+            if (serviceKeys.length === 0) {
+                return response;
+            }
+            const dependencies = await TopologyQueries.readCapped(runner, (limit) => {
+                return serviceMapDependenciesStatement({
+                    projectId,
+                    rangeStart,
+                    serviceKeys,
+                    mode: "rows",
+                    limit,
+                });
+            }, () => {
+                return serviceMapDependenciesStatement({
+                    projectId,
+                    rangeStart,
+                    serviceKeys,
+                    mode: "count",
+                    limit: 0,
+                });
+            }, dependencyCap);
+            response.dependencies = dependencies.rows.map((row) => {
+                return {
+                    from: readString(row, "from"),
+                    to: readString(row, "to"),
+                    callCount: readNullableNumber(row, "callCount"),
+                    errorCount: readNullableNumber(row, "errorCount"),
+                    avgDurationMs: readNullableNumber(row, "avgDurationMs"),
+                };
+            });
+            if (dependencies.total > dependencies.rows.length) {
+                response.dependencyTruncation = {
+                    shown: dependencies.rows.length,
+                    total: dependencies.total,
+                };
+            }
+            /*
+             * Callees: the non-service items the shipped calls point at (a callee
+             * that is a service is already in the list above).
+             */
+            const serviceKeySet = new Set(serviceKeys);
+            const calleeKeys = Array.from(new Set(response.dependencies.map((dependency) => {
+                return dependency.to;
+            })))
+                .filter((key) => {
+                return !serviceKeySet.has(key);
+            })
+                .sort(compareCodeUnits);
+            let callees = {
+                rows: [],
+                total: 0,
+            };
+            if (calleeKeys.length > 0) {
+                callees = await TopologyQueries.readCapped(runner, (limit) => {
+                    return serviceMapEntitiesStatement({
+                        projectId,
+                        winner,
+                        keys: calleeKeys,
+                        mode: "rows",
+                        limit,
+                    });
+                }, () => {
+                    return serviceMapEntitiesStatement({
+                        projectId,
+                        winner,
+                        keys: calleeKeys,
+                        mode: "count",
+                        limit: 0,
+                    });
+                }, entityCap - services.rows.length);
+            }
+            response.entities = [...services.rows, ...callees.rows].map(toServiceMapEntity);
+            const entityTotal = services.total + callees.total;
+            if (entityTotal > response.entities.length) {
+                response.entityTruncation = {
+                    shown: response.entities.length,
+                    total: entityTotal,
+                };
+            }
+            response.runsOn = await TopologyQueries.readRunsOnCounts(runner, {
+                projectId,
+                rangeStart,
+                winner,
+                serviceKeys,
+            });
+            return response;
+        });
+    }
+    /*
+     * Infrastructure's traffic: the in-range calls between services that both
+     * run on a shipped node, so the map can draw them between the resources
+     * those services run on. A service placed nowhere could never be drawn, so
+     * calls to or from one are not read at all. Capped like the Service Map's
+     * dependencies (the first rows in its order, with the exact total), then
+     * ordered by (from, to) — each pair is at most one row (the unique index).
+     */
+    static async readInfrastructureDependencies(runner, data) {
+        const placedServiceIndexes = Array.from(new Set(data.response.placements.map((placement) => {
+            return placement[0];
+        }))).sort((left, right) => {
+            return left - right;
+        });
+        /* A call needs two different services at its ends. */
+        if (placedServiceIndexes.length < 2) {
+            return;
+        }
+        const placedServiceKeys = placedServiceIndexes.map((index) => {
+            return data.response.services[index].key;
+        });
+        const dependencies = await TopologyQueries.readCapped(runner, (limit) => {
+            return serviceMapDependenciesStatement({
+                projectId: data.projectId,
+                rangeStart: data.rangeStart,
+                serviceKeys: placedServiceKeys,
+                calleeKeys: placedServiceKeys,
+                mode: "rows",
+                limit,
+            });
+        }, () => {
+            return serviceMapDependenciesStatement({
+                projectId: data.projectId,
+                rangeStart: data.rangeStart,
+                serviceKeys: placedServiceKeys,
+                calleeKeys: placedServiceKeys,
+                mode: "count",
+                limit: 0,
+            });
+        }, TopologyApiLimits.MaxServiceMapDependencies);
+        const shipped = [];
+        for (const row of dependencies.rows) {
+            const from = data.serviceIndexByKey.get(readString(row, "from"));
+            const to = data.serviceIndexByKey.get(readString(row, "to"));
+            if (from === undefined || to === undefined || from === to) {
+                continue;
+            }
+            shipped.push({
+                from,
+                to,
+                callCount: readNullableNumber(row, "callCount"),
+                errorCount: readNullableNumber(row, "errorCount"),
+                avgDurationMs: readNullableNumber(row, "avgDurationMs"),
+            });
+        }
+        shipped.sort((left, right) => {
+            return left.from - right.from || left.to - right.to;
+        });
+        data.response.dependencies = shipped;
+        if (dependencies.total > dependencies.rows.length) {
+            data.response.dependencyTruncation = {
+                shown: dependencies.rows.length,
+                total: dependencies.total,
+            };
+        }
+    }
+    /*
+     * Infrastructure: one lean row per resource with its container chosen in
+     * SQL, every live service, where services run, the calls between placed
+     * services, and flat types too large to ship row by row as collections
+     * with exact counts.
+     */
+    static async getInfrastructure(request) {
+        const projectId = request.projectId.toString();
+        const rangeStart = request.rangeStart.toISOString();
+        const nodeCap = TopologyApiLimits.MaxInfrastructureNodes;
+        return await TopologyQueries.inReadOnlySnapshot(async (runner) => {
+            const response = Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { nodes: [], services: [], placements: [], dependencies: [], dependencyTruncation: null, collections: [], totals: { resources: 0, activeResources: 0 }, truncation: null });
+            const projectTypes = await TopologyQueries.readProjectTypes(runner, projectId);
+            const infrastructureTypes = projectTypes.filter((type) => {
+                return isTopologyInfrastructureType(type);
+            });
+            /*
+             * Collections: a flat type (nothing nests in it, it nests in nothing,
+             * nothing groups it) with more items than the inline budget. Its
+             * volume is not bounded by any discovery budget, so the browser gets
+             * exact counts and pages the rows on demand. Its counts are over its
+             * rows; keys are unique per type.
+             */
+            const typeCounts = infrastructureTypes.length > 0
+                ? await runner.query(infrastructureTypeCountsStatement({
+                    projectId,
+                    rangeStart,
+                    infrastructureTypes,
+                }))
+                : [];
+            const collectedTypes = new Set();
+            for (const row of typeCounts) {
+                const type = readString(row, "type");
+                const total = readNumber(row, "total");
+                if (isFlatInfrastructureType(type) &&
+                    total > TopologyApiLimits.InlineFlatItemsPerType) {
+                    collectedTypes.add(type);
+                    response.collections.push({
+                        type,
+                        total,
+                        active: readNumber(row, "active"),
+                        lastSeenAt: readNullableNumber(row, "lastSeenAt"),
+                        activeLastSeenAt: readNullableNumber(row, "activeLastSeenAt"),
+                    });
+                }
+            }
+            const nodeTypes = infrastructureTypes.filter((type) => {
+                return !collectedTypes.has(type);
+            });
+            const hasServices = projectTypes.includes(EntityType.Service);
+            const winner = nodeTypes.length > 0 || hasServices
+                ? await TopologyQueries.readWinnerScope(runner, projectId, projectTypes)
+                : { projectTypes, duplicateKeys: [] };
+            let nodes = { rows: [], total: 0, count: {} };
+            if (nodeTypes.length > 0) {
+                nodes = await TopologyQueries.readCapped(runner, (limit) => {
+                    return infrastructureNodesStatement({
+                        projectId,
+                        rangeStart,
+                        winner,
+                        nodeTypes,
+                        mode: "rows",
+                        limit,
+                    });
+                }, () => {
+                    return infrastructureNodesStatement({
+                        projectId,
+                        rangeStart,
+                        winner,
+                        nodeTypes,
+                        mode: "count",
+                        limit: 0,
+                    });
+                }, nodeCap);
+            }
+            const nodeIndexByKey = new Map();
+            nodes.rows.forEach((row, index) => {
+                nodeIndexByKey.set(readString(row, "key"), index);
+            });
+            response.nodes = nodes.rows.map((row) => {
+                const node = toLeanEntity(row);
+                const parentKey = readNullableString(row, "parent");
+                /* A container outside the shipped set (a truncated list) is dropped. */
+                const parent = parentKey === null ? undefined : nodeIndexByKey.get(parentKey);
+                if (parent === undefined) {
+                    return node;
+                }
+                node.parent = parent;
+                node.parentVia = readString(row, "parentVia");
+                if (readBoolean(row, "parentInactive")) {
+                    const activeParentKey = readNullableString(row, "activeParent");
+                    const activeParent = activeParentKey === null
+                        ? undefined
+                        : nodeIndexByKey.get(activeParentKey);
+                    if (activeParent === undefined) {
+                        node.activeParent = -1;
+                    }
+                    else {
+                        node.activeParent = activeParent;
+                        node.activeParentVia = readString(row, "activeParentVia");
+                    }
+                }
+                return node;
+            });
+            let activeNodes = 0;
+            if (nodes.total > nodes.rows.length) {
+                activeNodes = readNumber(nodes.count, "active");
+                response.truncation = {
+                    shown: nodes.rows.length,
+                    total: nodes.total,
+                };
+            }
+            else {
+                for (const row of nodes.rows) {
+                    if (readBoolean(row, "active")) {
+                        activeNodes++;
+                    }
+                }
+            }
+            response.totals = {
+                resources: nodes.total,
+                activeResources: activeNodes,
+            };
+            for (const collection of response.collections) {
+                response.totals.resources += collection.total;
+                response.totals.activeResources += collection.active;
+            }
+            if (hasServices) {
+                const serviceRows = await runner.query(servicesStatement({ projectId, winner }));
+                response.services = serviceRows.map((row) => {
+                    return {
+                        key: readString(row, "key"),
+                        name: readNullableString(row, "name"),
+                    };
+                });
+            }
+            if (response.services.length > 0 && response.nodes.length > 0) {
+                const serviceIndexByKey = new Map();
+                response.services.forEach((service, index) => {
+                    serviceIndexByKey.set(service.key, index);
+                });
+                const placementRows = await runner.query(placementsStatement({
+                    projectId,
+                    rangeStart,
+                    serviceKeys: response.services.map((service) => {
+                        return service.key;
+                    }),
+                }));
+                const placements = [];
+                for (const row of placementRows) {
+                    const service = serviceIndexByKey.get(readString(row, "service"));
+                    const node = nodeIndexByKey.get(readString(row, "target"));
+                    if (service !== undefined && node !== undefined) {
+                        placements.push([service, node]);
+                    }
+                }
+                placements.sort((left, right) => {
+                    return left[0] - right[0] || left[1] - right[1];
+                });
+                response.placements = placements;
+                await TopologyQueries.readInfrastructureDependencies(runner, {
+                    projectId,
+                    rangeStart,
+                    response,
+                    serviceIndexByKey,
+                });
+            }
+            return response;
+        });
+    }
+    /* One keyset page of a collection, with the total matching the filters. */
+    static async getCollectionPage(request) {
+        const projectId = request.projectId.toString();
+        const rangeStart = request.rangeStart.toISOString();
+        return await TopologyQueries.inReadOnlySnapshot(async (runner) => {
+            var _a;
+            const filters = {
+                projectId,
+                rangeStart,
+                entityType: request.entityType,
+                includeInactive: request.includeInactive,
+                nameTerms: request.nameTerms,
+                cursor: request.cursor,
+            };
+            const countRows = await runner.query(collectionPageStatement(Object.assign(Object.assign({}, filters), { mode: "count", limit: 0 })));
+            const rows = await runner.query(collectionPageStatement(Object.assign(Object.assign({}, filters), { mode: "rows", limit: request.limit + 1 })));
+            const items = rows
+                .slice(0, request.limit)
+                .map(toLeanEntity);
+            const last = items[items.length - 1];
+            return Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { entityType: request.entityType, total: readNumber(countRows[0] || {}, "total"), items, nextCursor: rows.length > request.limit && last
+                    ? { name: (_a = last.name) !== null && _a !== void 0 ? _a : "", key: last.key }
+                    : null });
+        });
+    }
+    /* How many items of each requested collection match its terms. */
+    static async getCollectionSearch(request) {
+        const response = Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { matches: [] });
+        if (request.types.length === 0) {
+            return response;
+        }
+        const rows = await TopologyQueries.inReadOnlySnapshot(async (runner) => {
+            return await runner.query(collectionSearchStatement({
+                projectId: request.projectId.toString(),
+                rangeStart: request.rangeStart.toISOString(),
+                includeInactive: request.includeInactive,
+                types: request.types,
+            }));
+        });
+        const countByType = new Map();
+        for (const row of rows) {
+            countByType.set(readString(row, "entityType"), readNumber(row, "count"));
+        }
+        for (const type of request.types) {
+            const count = countByType.get(type.entityType) || 0;
+            if (count > 0) {
+                response.matches.push({ entityType: type.entityType, count });
+            }
+        }
+        return response;
+    }
+    /*
+     * The drawer: the entity's full row and its in-range relationships in four
+     * sections with exact totals (lower bounds when the scan stopped) and the
+     * top rows of each.
+     */
+    static async getEntity(request) {
+        const result = await TopologyQueries.readEntityAndSections(request, { kind: "range", rangeStart: request.rangeStart.toISOString() }, TopologyQueries.firstView());
+        return Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { entity: result.entity, sections: result.decoded.sections, isScanLimited: result.decoded.isScanLimited });
+    }
+    /* "Show more": the next page of one drawer section. */
+    static async getEntityConnections(request) {
+        const result = await TopologyQueries.readEntityAndSections(request, { kind: "range", rangeStart: request.rangeStart.toISOString() }, TopologyQueries.pageWindow(request));
+        return Object.assign(Object.assign({}, TopologyQueries.envelope(request.rangeStart)), { section: request.section, connections: result.decoded.sections[request.section], isScanLimited: result.decoded.isScanLimited });
+    }
+    /*
+     * The inventory item page: the drawer's sections over everything the
+     * inventory holds — every relationship however long ago it was seen, for
+     * an item archived or not, with archived other ends named and linkable.
+     */
+    static async getEntityAllTime(request) {
+        const result = await TopologyQueries.readEntityAndSections(request, { kind: "allTime" }, TopologyQueries.firstView());
+        return Object.assign(Object.assign({}, TopologyQueries.allTimeEnvelope()), { entity: result.entity, sections: result.decoded.sections, isScanLimited: result.decoded.isScanLimited });
+    }
+    /* "Show more" on the inventory item page: one all-time section's page. */
+    static async getEntityAllTimeConnections(request) {
+        const result = await TopologyQueries.readEntityAndSections(request, { kind: "allTime" }, TopologyQueries.pageWindow(request));
+        return Object.assign(Object.assign({}, TopologyQueries.allTimeEnvelope()), { section: request.section, connections: result.decoded.sections[request.section], isScanLimited: result.decoded.isScanLimited });
+    }
+    /* The first view: the top rows of every section. */
+    static firstView() {
+        return {
+            kind: "top",
+            dependencyRows: TopologyApiLimits.EntityDependencyRows,
+            otherRows: TopologyApiLimits.EntityOtherRows,
+        };
+    }
+    static pageWindow(request) {
+        return {
+            kind: "page",
+            section: request.section,
+            offset: request.offset,
+            limit: request.limit || rowsForSection(request.section),
+        };
+    }
+    static async readEntityAndSections(request, scope, window) {
+        const projectId = request.projectId.toString();
+        const allTime = scope.kind === "allTime";
+        return await TopologyQueries.inReadOnlySnapshot(async (runner) => {
+            const nothing = {
+                sections: emptySections(),
+                isScanLimited: false,
+            };
+            const projectTypes = await TopologyQueries.readProjectTypes(runner, projectId);
+            if (projectTypes.length === 0) {
+                return { entity: null, decoded: nothing };
+            }
+            const entityRows = await runner.query(entityStatement({
+                projectId,
+                projectTypes,
+                entityKey: request.entityKey,
+                entityType: request.entityType,
+                includeArchived: allTime,
+            }));
+            const entityRow = entityRows[0];
+            if (!entityRow) {
+                return { entity: null, decoded: nothing };
+            }
+            const entity = Object.assign(Object.assign({}, toLeanEntity(entityRow)), { id: readString(entityRow, "id"), firstSeenAt: readNullableNumber(entityRow, "firstSeenAt"), resourceType: readNullableString(entityRow, "resourceType"), resourceId: readNullableString(entityRow, "resourceId"), identifyingAttributes: readJsonObject(entityRow, "identifyingAttributes"), descriptiveAttributes: readJsonObject(entityRow, "descriptiveAttributes") });
+            const sectionRows = await runner.query(entitySectionsStatement({
+                projectId,
+                scope,
+                projectTypes,
+                entityKey: entity.key,
+                isService: entity.type === EntityType.Service,
+                scanLimit: TopologyApiLimits.EntityConnectionScanLimit + 1,
+                window,
+            }));
+            return {
+                entity,
+                decoded: decodeSections(sectionRows, window.kind === "page" ? window.offset : 0),
+            };
+        });
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getServiceMap", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getInfrastructure", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getCollectionPage", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getCollectionSearch", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getEntity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getEntityConnections", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getEntityAllTime", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TopologyQueries, "getEntityAllTimeConnections", null);
+//# sourceMappingURL=TopologyQueries.js.map