deepline 0.3.88 → 0.3.90

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-consumer-health.ts

@@ -0,0 +1,56 @@
+import { internal } from '@deepline/convex-client/function-references';
+import { getRequiredInternalConvexClient } from '@deepline/convex-client/internal-client';
+
+type MonitorStreamResource = {
+  key: string;
+  tool: string;
+  outputs?: unknown;
+};
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+/**
+ * Resolve current SQL-listener consumers for one monitor. Binding metadata is
+ * cheap and preserves the established `bound_plays` list contract. Delivery/run
+ * health is an explicit, bounded opt-in; monitor source/webhook health remains
+ * on the monitor resource itself.
+ */
+export async function boundPlaysForProviderMonitor(input: {
+  orgId: string;
+  monitor: MonitorStreamResource;
+  includeHealth?: boolean;
+}): Promise<{ plays: unknown[]; truncated: boolean }> {
+  const outputs = record(input.monitor.outputs);
+  const tables = Object.values(outputs).flatMap((output) => {
+    const table = record(output).table;
+    return typeof table === 'string' ? [table] : [];
+  });
+  const [provider, capability] = input.monitor.tool.split('.', 2);
+  if (!provider || !capability) return { plays: [], truncated: false };
+
+  const convex = getRequiredInternalConvexClient();
+  const bound = (await convex.query(
+    internal.monitorObservability.dependentPlaysForMonitor,
+    {
+      orgId: input.orgId,
+      monitorKey: input.monitor.key,
+      provider,
+      capability,
+      outputKeys: Object.keys(outputs),
+      tables,
+      includeHealth: input.includeHealth === true,
+    },
+  )) as { plays?: unknown[]; truncated?: boolean } | null;
+
+  // Consumer-health is supplementary observability. An absent result during a
+  // rolling control-plane deploy must never make the established monitor
+  // list/get surface fail; it simply means there are no observable consumers.
+  return {
+    plays: Array.isArray(bound?.plays) ? bound.plays : [],
+    truncated: bound?.truncated === true,
+  };
+}

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-errors.ts

@@ -0,0 +1,131 @@
+export class ProviderMonitorNotFoundError extends Error {
+  constructor(readonly monitorKey: string) {
+    super(`Provider monitor "${monitorKey}" was not found.`);
+    this.name = 'ProviderMonitorNotFoundError';
+  }
+}
+
+/**
+ * An old Convex org is being indexed for exact provider-identity admission.
+ * This is intentionally a temporary, retryable refusal instead of making one
+ * customer-facing deploy synchronously scan every legacy monitor definition.
+ */
+export class ProviderMonitorIdentityBackfillInProgressError extends Error {
+  constructor() {
+    super(
+      'Monitor identity records are still being prepared for this workspace. Retry in a few seconds; no upstream monitor was created.',
+    );
+    this.name = 'ProviderMonitorIdentityBackfillInProgressError';
+  }
+}
+
+/**
+ * A caller tried to publish an older monitor definition after newer control
+ * state had committed. Re-read before deciding whether to retry.
+ */
+export class ProviderMonitorControlStateConflictError extends Error {
+  constructor(readonly monitorKey: string) {
+    super(
+      `Monitor "${monitorKey}" changed while this update was in progress. Re-read it and retry the update if it is still needed.`,
+    );
+    this.name = 'ProviderMonitorControlStateConflictError';
+  }
+}
+
+export class ProviderMonitorCapacityBackfillInProgressError extends Error {
+  constructor() {
+    super(
+      'Monitor capacity records are still being prepared for this workspace. Retry in a few seconds; no upstream monitor was created.',
+    );
+    this.name = 'ProviderMonitorCapacityBackfillInProgressError';
+  }
+}
+
+export type ProviderMonitorCapacitySnapshot = {
+  used: number;
+  reserved: number;
+  limit: number;
+  remaining: number;
+  over_by: number;
+  can_create: boolean;
+};
+
+export class ProviderMonitorOrgLimitExceededError extends Error {
+  readonly code = 'ORG_MONITOR_LIMIT_EXCEEDED';
+
+  constructor(readonly capacity: ProviderMonitorCapacitySnapshot) {
+    super(
+      `This organization is watching ${capacity.used + capacity.reserved} of ${capacity.limit} accounts.`,
+    );
+    this.name = 'ProviderMonitorOrgLimitExceededError';
+  }
+}
+
+/**
+ * The organization may watch this account, but not with another signal.
+ *
+ * Distinct from the organization limit on purpose: the customer's next action
+ * is different. A full organization means stop watching some account; a full
+ * account means drop one of the signals on this one.
+ */
+export class ProviderMonitorEntityLimitExceededError extends Error {
+  readonly code = 'MONITOR_ENTITY_LIMIT_EXCEEDED';
+
+  constructor(
+    readonly entityKey: string,
+    readonly monitorsPerEntity: number,
+  ) {
+    super(
+      `This account already has ${monitorsPerEntity} of ${monitorsPerEntity} monitors.`,
+    );
+    this.name = 'ProviderMonitorEntityLimitExceededError';
+  }
+}
+
+export class ProviderMonitorCapacityCleanupRequiredError extends Error {
+  readonly code = 'MONITOR_CAPACITY_CLEANUP_REQUIRED';
+
+  constructor(readonly monitorKey: string) {
+    super(
+      `Monitor "${monitorKey}" still owns capacity because upstream cleanup is incomplete.`,
+    );
+    this.name = 'ProviderMonitorCapacityCleanupRequiredError';
+  }
+}
+
+/**
+ * An update already created its new upstream resource and is waiting to remove
+ * the recorded previous one. A different desired definition is unsafe until
+ * the original update finishes.
+ */
+export class ProviderMonitorUpdateOperationInProgressError extends Error {
+  constructor(readonly monitorKey: string) {
+    super(
+      `Monitor "${monitorKey}" is still finishing its previous change. Rerun that same deploy or update before making a different change.`,
+    );
+    this.name = 'ProviderMonitorUpdateOperationInProgressError';
+  }
+}
+
+/**
+ * A prior delete reached an upstream provider and did not get a confirmed
+ * result. Only a retry of that delete may proceed; a deploy or update would
+ * risk creating a second resource while the first is still live.
+ */
+export class ProviderMonitorDeleteOperationInProgressError extends Error {
+  constructor(readonly monitorKey: string) {
+    super(
+      `Monitor "${monitorKey}" still has an unfinished delete. Rerun the same delete before deploying, updating, or reactivating it.`,
+    );
+    this.name = 'ProviderMonitorDeleteOperationInProgressError';
+  }
+}
+
+export class PriorityMonitorExecutionLimitError extends Error {
+  constructor(readonly max: number) {
+    super(
+      `This workspace already has ${max} priority radars. Remove priority from a radar that is no longer urgent before creating another one.`,
+    );
+    this.name = 'PriorityMonitorExecutionLimitError';
+  }
+}