@oneuptime/common 14.0.3 → 14.0.6

package/build/dist/Server/Services/DatabaseServerEndpointService.js

@@ -0,0 +1,694 @@
+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 DatabaseService from "./DatabaseService";
+import DatabaseServerFeedService from "./DatabaseServerFeedService";
+import DatabaseServerService from "./DatabaseServerService";
+import Model from "../../Models/DatabaseModels/DatabaseServerEndpoint";
+import DatabaseServer from "../../Models/DatabaseModels/DatabaseServer";
+import { DatabaseServerFeedEventType } from "../../Models/DatabaseModels/DatabaseServerFeed";
+import ModelPermission from "../Types/Database/Permissions/Index";
+import RelationIdUtil from "../Utils/Database/RelationIdUtil";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
+import ObjectID from "../../Types/ObjectID";
+import { formatDatabaseEndpoint, parseManualDatabaseEndpoint, } from "../../Types/DatabaseServer/DatabaseEndpoint";
+/*
+ * "Last matched" is refreshed at most this often per endpoint: often enough
+ * that a stale alias stands out on the Endpoints tab, rarely enough that a
+ * busy endpoint costs one write an hour, not one per lookup.
+ */
+export const ENDPOINT_MATCH_REFRESH_SECONDS = 60 * 60;
+// What an alias looks like, for the refusal of an empty one.
+const ENDPOINT_EXAMPLE = "Enter the host name or IP address applications use to reach this database, with an optional port, for example orders-db.example.com:5432.";
+/*
+ * The endpoints a database is reached at. Every endpoint belongs to at most
+ * one database per project: the (projectId, endpoint) unique index enforces
+ * it, and this service turns a collision into a message naming the database
+ * that already owns the endpoint instead of a raw constraint error.
+ *
+ * Endpoints are stored canonical (formatDatabaseEndpoint), because the
+ * telemetry entity key of a database is derived from the endpoint string -
+ * a person typing "Orders-DB.example.com" must land on the same key ingest
+ * computes for `server.address=orders-db.example.com`.
+ */
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    /*
+     * A person adding an alias. Root writes (the discovery paths, through
+     * claimEndpoint) pass through untouched: they already hold a canonical
+     * endpoint and handle ownership themselves.
+     *
+     * Adding an endpoint is an EDIT of the database it is added to: it decides
+     * which traffic that database's pages show and - one owner per endpoint -
+     * that no other database can claim it. So the caller must be allowed to
+     * edit that very row, label and Owned scopes included. DatabaseService
+     * checks the create permission only after this hook, and never scopes a
+     * create to the parent row, so both happen here - the create permission
+     * FIRST, so a caller without it learns nothing about which databases exist
+     * or who owns an endpoint.
+     */
+    async onBeforeCreate(createBy) {
+        var _a;
+        if (createBy.props.isRoot) {
+            return { createBy: createBy, carryForward: null };
+        }
+        const data = createBy.data;
+        ModelPermission.checkCreatePermissions(Model, data, createBy.props);
+        /*
+         * The tenant column is stamped from props.tenantId only after this hook,
+         * so read the request tenant first - it is the only project the caller
+         * was checked in.
+         */
+        const projectId = createBy.props.tenantId || data.projectId || undefined;
+        if (!projectId) {
+            throw new BadDataException("Project ID is required to add a database endpoint.");
+        }
+        /*
+         * The reference arrives as the FK column or as a relation object, and
+         * TypeORM persists the relation object's id over the column's. Read both
+         * spellings, refuse a payload whose two spellings disagree, and leave the
+         * validated column as the only one that can reach the insert.
+         */
+        const databaseServerId = RelationIdUtil.readConsistent(data, ["databaseServerId", "databaseServer"], "database");
+        data.setColumnValue("databaseServer", undefined);
+        if (!databaseServerId) {
+            throw new BadDataException("Select the database this endpoint belongs to.");
+        }
+        const databaseServer = await this.findEditableDatabaseServer({
+            projectId: projectId,
+            databaseServerId: databaseServerId,
+            props: createBy.props,
+        });
+        /*
+         * One answer for "no such database in this project" and "a database you
+         * may not edit", so the refusal is not a way to probe for ids.
+         */
+        if (!databaseServer) {
+            throw new NotAuthorizedException("Database not found, or you do not have permission to edit it. Adding an endpoint to a database needs permission to edit that database.");
+        }
+        /*
+         * Canonicalize with the database's own context: its engine supplies the
+         * default port, and for a database discovered on Kubernetes its
+         * namespace expands a bare service name (and `<service>.<namespace>` to
+         * the Service's full name) and its cluster qualifies a cluster-local
+         * name - exactly what ingest does for the pods calling it. A value that
+         * cannot be used - `user@host`, a cluster qualifier on a public host, a
+         * loopback name, a port outside 1-65535 - is refused with a message
+         * saying what to change, never read as something else or quietly given
+         * the engine's default port.
+         */
+        const manual = parseManualDatabaseEndpoint(data.endpoint, {
+            system: databaseServer.dbSystem || "",
+            kubernetesClusterName: (_a = databaseServer.kubernetesCluster) === null || _a === void 0 ? void 0 : _a.clusterIdentifier,
+            kubernetesNamespace: databaseServer.kubernetesNamespace,
+        });
+        const endpoint = manual.endpoint;
+        if (!endpoint) {
+            throw new BadDataException(typeof data.endpoint !== "string" || !data.endpoint.trim()
+                ? `Endpoint is required. ${ENDPOINT_EXAMPLE}`
+                : manual.error || `This is not a valid endpoint. ${ENDPOINT_EXAMPLE}`);
+        }
+        const formatted = formatDatabaseEndpoint(endpoint);
+        if (formatted.length > ColumnLength.LongText) {
+            throw new BadDataException(`This endpoint is too long. Endpoints can be at most ${ColumnLength.LongText} characters.`);
+        }
+        const owner = await this.findOwnerByEndpoint(projectId, formatted);
+        if (owner) {
+            if (owner.databaseServerId.toString() === databaseServerId.toString()) {
+                throw new BadDataException(`${formatted} is already an endpoint of this database.`);
+            }
+            throw new BadDataException(await getOwnedByOtherDatabaseMessage(formatted, owner, createBy.props));
+        }
+        data.databaseServerId = databaseServerId;
+        data.endpoint = formatted;
+        /*
+         * Forced, whatever the caller sent: a person only ever adds a removable
+         * alias. The primary endpoint is written by whichever path created the
+         * database, as root.
+         */
+        data.source = "user";
+        data.isPrimary = false;
+        return { createBy: createBy, carryForward: null };
+    }
+    /*
+     * A person removing endpoints. Removing one is an EDIT of the database it
+     * belongs to, exactly like adding one (onBeforeCreate): it decides which
+     * traffic that database's pages show, and frees the endpoint for another
+     * database to claim. DatabaseService scopes a delete to the project only -
+     * the endpoint has no labels of its own, and the parent's label and Owned
+     * scopes never reach a delete - so the caller must be allowed to edit
+     * every database the delete would touch, checked here: the delete
+     * permission FIRST (so a caller without it learns nothing), then the
+     * parents, and only then the primary guard, whose refusal names the
+     * endpoint.
+     *
+     * The primary endpoint is what the database was created from; discovery
+     * would claim it straight back, and a manually added database would lose
+     * the only endpoint its telemetry is keyed by. Aliases can be removed.
+     */
+    async onBeforeDelete(deleteBy) {
+        var _a;
+        if (deleteBy.props.isRoot) {
+            return { deleteBy: deleteBy, carryForward: null };
+        }
+        // The project the caller was checked in, whatever project the query named.
+        const query = await ModelPermission.checkDeleteQueryPermission(Model, deleteBy.query, deleteBy.props);
+        const matched = await this.findBy({
+            query: query,
+            select: {
+                _id: true,
+                projectId: true,
+                databaseServerId: true,
+                endpoint: true,
+                isPrimary: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const checked = new Set();
+        for (const endpoint of matched) {
+            const databaseServerId = (_a = endpoint.databaseServerId) === null || _a === void 0 ? void 0 : _a.toString();
+            const projectId = deleteBy.props.tenantId || endpoint.projectId || undefined;
+            if (!databaseServerId || !projectId || checked.has(databaseServerId)) {
+                continue;
+            }
+            const databaseServer = await this.findEditableDatabaseServer({
+                projectId: projectId,
+                databaseServerId: new ObjectID(databaseServerId),
+                props: deleteBy.props,
+            });
+            // The same answer onBeforeCreate gives: no probing for ids.
+            if (!databaseServer) {
+                throw new NotAuthorizedException("Database not found, or you do not have permission to edit it. Removing an endpoint from a database needs permission to edit that database.");
+            }
+            checked.add(databaseServerId);
+        }
+        const primary = matched.find((endpoint) => {
+            return Boolean(endpoint.isPrimary);
+        });
+        if (primary) {
+            const endpoint = primary.endpoint || "The primary endpoint";
+            throw new BadDataException(`${endpoint} is the primary endpoint of this database and cannot be removed. Add another endpoint as an alias instead, or delete the database.`);
+        }
+        // The rows are gone by onDeleteSuccess: its feed items are built from these.
+        const carryForward = {
+            endpointsToDelete: matched,
+        };
+        return { deleteBy: deleteBy, carryForward: carryForward };
+    }
+    /*
+     * A person added an alias: that is an edit of the database (it decides
+     * which traffic the database's pages show), so it goes on the database's
+     * Feed like any other edit, naming the endpoint and who added it. A
+     * discovery claim is root and never gets here.
+     */
+    async onCreateSuccess(onCreate, createdItem) {
+        if (onCreate.createBy.props.isRoot) {
+            return createdItem;
+        }
+        await this.writeEndpointFeedItem({
+            change: "added",
+            endpoint: createdItem,
+            projectId: createdItem.projectId || onCreate.createBy.props.tenantId || undefined,
+            userId: createdItem.createdByUserId ||
+                onCreate.createBy.props.userId ||
+                undefined,
+        });
+        return createdItem;
+    }
+    /*
+     * A person removed aliases: one feed item per endpoint actually removed,
+     * on its own database. Discovery's releases and moves are root writes and
+     * never get here.
+     */
+    async onDeleteSuccess(onDelete, itemIdsBeforeDelete) {
+        var _a;
+        const carried = onDelete.carryForward || null;
+        if (onDelete.deleteBy.props.isRoot || !carried) {
+            return onDelete;
+        }
+        const deletedIds = new Set((itemIdsBeforeDelete || []).map((id) => {
+            return id.toString();
+        }));
+        const userId = ((_a = onDelete.deleteBy.deletedByUser) === null || _a === void 0 ? void 0 : _a.id) ||
+            onDelete.deleteBy.props.userId ||
+            undefined;
+        for (const endpoint of carried.endpointsToDelete || []) {
+            if (!endpoint._id || !deletedIds.has(endpoint._id.toString())) {
+                continue;
+            }
+            await this.writeEndpointFeedItem({
+                change: "removed",
+                endpoint: endpoint,
+                projectId: endpoint.projectId || onDelete.deleteBy.props.tenantId || undefined,
+                userId: userId,
+            });
+        }
+        return onDelete;
+    }
+    // One "endpoint added / removed" item on the database's Feed. Never throws.
+    async writeEndpointFeedItem(data) {
+        const databaseServerId = data.endpoint.databaseServerId || undefined;
+        const endpoint = (data.endpoint.endpoint || "").trim();
+        if (!databaseServerId || !data.projectId || !endpoint) {
+            return;
+        }
+        try {
+            const link = await DatabaseServerService.getDatabaseServerMarkdownLink(data.projectId, databaseServerId);
+            const added = data.change === "added";
+            await DatabaseServerFeedService.createDatabaseServerFeedItem({
+                databaseServerId: databaseServerId,
+                projectId: data.projectId,
+                databaseServerFeedEventType: DatabaseServerFeedEventType.DatabaseServerUpdated,
+                displayColor: added ? Gray500 : Red500,
+                feedInfoInMarkdown: added
+                    ? `🔗 Added the endpoint \`${endpoint}\` to ${link}.`
+                    : `🔗 Removed the endpoint \`${endpoint}\` from ${link}.`,
+                moreInformationInMarkdown: added
+                    ? `**Endpoint**: \`${endpoint}\`\n\nCalls applications make to this endpoint now count as this database's traffic, and no other database can claim it.`
+                    : `**Endpoint**: \`${endpoint}\`\n\nCalls to this endpoint no longer count as this database's traffic, and another database may claim it.`,
+                userId: data.userId,
+            });
+        }
+        catch (error) {
+            logger.warn(`DatabaseServerEndpointService: could not write the feed item for endpoint ${endpoint} ${data.change}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * The database that owns this canonical (formatDatabaseEndpoint) endpoint
+     * in the project, or null when no database lists it.
+     */
+    async findOwnerByEndpoint(projectId, formattedEndpoint) {
+        const endpoint = (formattedEndpoint || "").trim();
+        if (!endpoint) {
+            return null;
+        }
+        const row = await this.findOneBy({
+            query: {
+                projectId: projectId,
+                endpoint: endpoint,
+            },
+            select: {
+                _id: true,
+                databaseServerId: true,
+                isPrimary: true,
+                source: true,
+                lastMatchedAt: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!row || !row.databaseServerId) {
+            return null;
+        }
+        return {
+            databaseServerId: new ObjectID(row.databaseServerId.toString()),
+            isPrimary: Boolean(row.isPrimary),
+            endpointId: row._id ? new ObjectID(row._id.toString()) : undefined,
+            source: row.source || undefined,
+            lastMatchedAt: row.lastMatchedAt || undefined,
+        };
+    }
+    /**
+     * Record that telemetry just matched this endpoint to its database: moves
+     * lastMatchedAt to now, at most once per ENDPOINT_MATCH_REFRESH_SECONDS
+     * (decided from the lastMatchedAt the owner lookup already read, so a
+     * fresh endpoint costs nothing). A "workload" endpoint is left alone: its
+     * lastMatchedAt says when the workload last produced it, which is what
+     * decides whether discovery may release it. Never throws.
+     */
+    async markEndpointMatched(owner) {
+        if (!owner || !owner.endpointId || owner.source === "workload") {
+            return;
+        }
+        const now = OneUptimeDate.getCurrentDate();
+        if (owner.lastMatchedAt &&
+            OneUptimeDate.isAfter(owner.lastMatchedAt, OneUptimeDate.addRemoveSeconds(now, -ENDPOINT_MATCH_REFRESH_SECONDS))) {
+            return;
+        }
+        try {
+            await this.updateColumnsByIdWithoutHooks({
+                id: owner.endpointId,
+                data: {
+                    lastMatchedAt: now,
+                },
+                skipUpdateDateColumn: true,
+            });
+            owner.lastMatchedAt = now;
+        }
+        catch (error) {
+            logger.warn(`DatabaseServerEndpointService: could not record a match of endpoint ${owner.endpointId.toString()}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Move lastMatchedAt to `now` on those of `endpoints` this database owns
+     * whose lastMatchedAt is empty or older than `staleBefore` - one
+     * statement, however many endpoints. The workload path calls it for the
+     * aliases a discovery run produced again.
+     */
+    async refreshMatchedEndpoints(data) {
+        if (data.endpoints.length === 0) {
+            return;
+        }
+        await this.getRepository().manager.query(`UPDATE "DatabaseServerEndpoint"
+      SET "lastMatchedAt" = $1
+      WHERE "projectId" = $2
+        AND "databaseServerId" = $3
+        AND "endpoint" = ANY($4::text[])
+        AND ("lastMatchedAt" IS NULL OR "lastMatchedAt" < $5)
+        AND "deletedAt" IS NULL`, [
+            data.now,
+            data.projectId.toString(),
+            data.databaseServerId.toString(),
+            data.endpoints,
+            data.staleBefore,
+        ]);
+    }
+    /**
+     * Hand a discovered endpoint to another database: the workload that now
+     * serves it. A compare-and-set on the current owner, and never a "user"
+     * endpoint - those only a person moves. The endpoint becomes a "workload"
+     * endpoint of its new owner, matched now. True when it moved.
+     */
+    async transferEndpoint(data) {
+        /*
+         * Wrapped in a CTE so the statement is a SELECT: TypeORM answers a bare
+         * UPDATE with [rows, rowCount], which would read as "moved" every time.
+         */
+        const moved = await this.getRepository().manager.query(`WITH "moved" AS (
+        UPDATE "DatabaseServerEndpoint"
+        SET "databaseServerId" = $1,
+          "source" = 'workload',
+          "isPrimary" = $2,
+          "lastMatchedAt" = $3,
+          "updatedAt" = CURRENT_TIMESTAMP
+        WHERE "_id" = $4
+          AND "projectId" = $5
+          AND "databaseServerId" = $6
+          AND COALESCE("source", '') <> 'user'
+          AND "deletedAt" IS NULL
+        RETURNING "_id"
+      )
+      SELECT "_id" FROM "moved"`, [
+            data.toDatabaseServerId.toString(),
+            data.isPrimary,
+            data.now,
+            data.endpointId.toString(),
+            data.projectId.toString(),
+            data.fromDatabaseServerId.toString(),
+        ]);
+        return Array.isArray(moved) && moved.length > 0;
+    }
+    /**
+     * Release the "workload" endpoints of one database that its workload no
+     * longer produces: not in `keepEndpoints` and not matched since
+     * `staleBefore` (so one partial discovery run releases nothing). Never the
+     * primary endpoint, never an "auto" or "user" one. Returns the endpoints
+     * released.
+     */
+    async releaseUnproducedWorkloadEndpoints(data) {
+        // A CTE for the same reason as transferEndpoint: a SELECT's rows come back.
+        const released = await this.getRepository().manager.query(`WITH "released" AS (
+        DELETE FROM "DatabaseServerEndpoint"
+        WHERE "projectId" = $1
+          AND "databaseServerId" = $2
+          AND "source" = 'workload'
+          AND "isPrimary" = false
+          AND NOT ("endpoint" = ANY($3::text[]))
+          AND ("lastMatchedAt" IS NULL OR "lastMatchedAt" < $4)
+        RETURNING "endpoint"
+      )
+      SELECT "endpoint" FROM "released"`, [
+            data.projectId.toString(),
+            data.databaseServerId.toString(),
+            data.keepEndpoints,
+            data.staleBefore,
+        ]);
+        if (!Array.isArray(released)) {
+            return [];
+        }
+        return released
+            .map((row) => {
+            const endpoint = row === null || row === void 0 ? void 0 : row.endpoint;
+            return typeof endpoint === "string" ? endpoint : "";
+        })
+            .filter((endpoint) => {
+            return endpoint.length > 0;
+        });
+    }
+    // True when the database has a primary endpoint.
+    async hasPrimaryEndpoint(data) {
+        const primary = await this.findOneBy({
+            query: {
+                projectId: data.projectId,
+                databaseServerId: data.databaseServerId,
+                isPrimary: true,
+            },
+            select: {
+                _id: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        return Boolean(primary);
+    }
+    /**
+     * Make a canonical endpoint this database's, as root. Never takes an
+     * endpoint away from another database: that answers "owned-by-other" and
+     * the caller decides what to do (discovery logs and skips it).
+     *
+     * Two discovery writers can race to claim the same endpoint. The unique
+     * index lets exactly one insert through; the loser re-reads the owner and
+     * reports the winner rather than throwing.
+     */
+    async claimEndpoint(data) {
+        const endpoint = (data.endpoint || "").trim();
+        if (!endpoint) {
+            throw new BadDataException("Endpoint is required to claim it.");
+        }
+        const existingOwner = await this.findOwnerByEndpoint(data.projectId, endpoint);
+        if (existingOwner) {
+            const result = classifyOwner(existingOwner, data.databaseServerId);
+            // Re-reported by the database that owns it: that is a match.
+            if (result === "already-owned-by-this") {
+                await this.markEndpointMatched(existingOwner);
+            }
+            return result;
+        }
+        try {
+            const row = new Model();
+            row.projectId = data.projectId;
+            row.databaseServerId = data.databaseServerId;
+            row.endpoint = endpoint;
+            row.isPrimary = data.isPrimary;
+            row.source = data.source;
+            row.lastMatchedAt = OneUptimeDate.getCurrentDate();
+            await this.create({
+                data: row,
+                props: {
+                    isRoot: true,
+                },
+            });
+            return "claimed";
+        }
+        catch (error) {
+            const racedOwner = await this.findOwnerByEndpoint(data.projectId, endpoint);
+            if (racedOwner) {
+                return classifyOwner(racedOwner, data.databaseServerId);
+            }
+            // Not a lost race (a foreign key, a dead connection): surface it.
+            throw error;
+        }
+    }
+    /**
+     * Every endpoint of one database, primary first then alphabetical - the
+     * input getDatabaseServerSignalEntityKeys turns into the database's
+     * telemetry key set.
+     */
+    async listEndpoints(databaseServerId) {
+        const rows = await this.findBy({
+            query: {
+                databaseServerId: databaseServerId,
+            },
+            select: {
+                _id: true,
+                endpoint: true,
+                isPrimary: true,
+            },
+            sort: {
+                isPrimary: SortOrder.Descending,
+                endpoint: SortOrder.Ascending,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const endpoints = [];
+        for (const row of rows) {
+            if (row.endpoint && !endpoints.includes(row.endpoint)) {
+                endpoints.push(row.endpoint);
+            }
+        }
+        return endpoints;
+    }
+    /**
+     * The database a caller adds an endpoint to, read only if the caller may
+     * EDIT it: the update permission check scopes the lookup exactly the way
+     * an update of that row would be scoped (project, label-scoped and
+     * Owned-scoped grants, block permissions). Null when the row does not
+     * exist in the project or the caller may not edit it - deliberately the
+     * same answer.
+     */
+    async findEditableDatabaseServer(data) {
+        const editableQuery = await ModelPermission.checkUpdateQueryPermissions(DatabaseServer, {
+            _id: data.databaseServerId.toString(),
+            projectId: data.projectId,
+        }, {}, data.props);
+        return await DatabaseServerService.findOneBy({
+            query: editableQuery,
+            select: {
+                _id: true,
+                dbSystem: true,
+                kubernetesNamespace: true,
+                kubernetesCluster: {
+                    clusterIdentifier: true,
+                },
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeCreate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeDelete", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Model]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onCreateSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onDeleteSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID, String]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "findOwnerByEndpoint", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "markEndpointMatched", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "refreshMatchedEndpoints", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "transferEndpoint", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "releaseUnproducedWorkloadEndpoints", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "hasPrimaryEndpoint", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "claimEndpoint", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "listEndpoints", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "findEditableDatabaseServer", null);
+function classifyOwner(owner, databaseServerId) {
+    return owner.databaseServerId.toString() === databaseServerId.toString()
+        ? "already-owned-by-this"
+        : "owned-by-other";
+}
+/*
+ * "orders-db.example.com:5432 already belongs to the database "PostgreSQL
+ * orders-db.example.com:5432"" - naming the owner is the only way a person can
+ * find and fix the conflict. But only a database the caller can READ is
+ * named: with label- or Owned-scoped permissions the owner may be a row they
+ * are not allowed to see, and then it is just "another database". Without
+ * props (a root path) the name is read as root.
+ */
+export async function getOwnedByOtherDatabaseMessage(formattedEndpoint, owner, props) {
+    let ownerName = "";
+    try {
+        ownerName = await DatabaseServerService.getDatabaseServerNameIfReadable({
+            databaseServerId: owner.databaseServerId,
+            props: props,
+        });
+    }
+    catch (_a) {
+        // The name only decorates the message; the refusal stands without it.
+    }
+    const ownerLabel = ownerName
+        ? `the database "${ownerName}"`
+        : "another database";
+    return `${formattedEndpoint} already belongs to ${ownerLabel}. An endpoint can belong to only one database in a project - remove it from that database first.`;
+}
+export default new Service();
+//# sourceMappingURL=DatabaseServerEndpointService.js.map