@abyss-project/probe 1.0.0 → 2.0.0

package/src/types/interface/models/probe-webhook-delivery.dto.ts

@@ -0,0 +1,73 @@
+import { ProbeScanVerdict } from '../../enum';
+
+// Mirrors apps/api/src/services/probe-webhook-delivery.service.ts's
+// ProbeWebhookPayload EXACTLY (same field set, same JSON.stringify'd body a
+// receiver's raw request body will deserialize into) — this is the payload
+// AbyssProbe POSTs to every registered webhook's `callbackUrl` (and to a
+// scan's own per-request `callbackUrl`, see probe-scan docs) once an ASYNC
+// scan reaches a verdict (`status: DONE`).
+//
+// `verdict` is typed as the concrete enum here (not `string` like the
+// server's internal type) because delivery only ever happens on a DONE scan,
+// where the verdict is always set — see dispatchProbeScanWebhooks's guard.
+
+/**
+ * Body of a webhook delivery, signed via HMAC-SHA256 of
+ * `JSON.stringify(payload)` — see {@link PROBE_WEBHOOK_SIGNATURE_HEADER} and
+ * {@link verifyProbeWebhookSignature} (this package's root / utils).
+ */
+export interface IProbeWebhookDeliveryPayload {
+  scanId: string;
+  /** Free-form caller reference, echoed back verbatim (see IProbeScanHistoryItem#context). */
+  context: Record<string, unknown> | null;
+  verdict: ProbeScanVerdict;
+  /** [] when clean. */
+  viruses: string[];
+  /**
+   * `ACCOUNT_AV_SCAN_UNITS` this scan consumed (WS5-1). Delivery only ever
+   * happens on a DONE scan, where the cost is always already computed and
+   * billed — see {@link IProbeScanHistoryItem#costUnits}.
+   */
+  costUnits: number | null;
+}
+
+// ─── Delivery HISTORY (WS5-6) ────────────────
+//
+// The interface above is the PAYLOAD a webhook receiver gets POSTed. This
+// section is a DIFFERENT concept: the persisted AUDIT ROW AbyssProbe keeps
+// of its OWN delivery attempts (one row per attempt — mirrors
+// apps/api/src/database/models/probe-webhook-delivery.model.ts EXACTLY,
+// itself modelled after this package's own extraction-webhook
+// delivery-history shape, trimmed to AbyssProbe's simpler
+// one-attempt-per-row reality — see that model's header comment). Read via
+// `GET /webhook/:webhookId/deliveries` (`sdk.probe.webhook.listDeliveries`).
+
+/**
+ * One persisted delivery-attempt row, as returned (paginated) by
+ * `GET /webhook/:webhookId/deliveries`.
+ */
+export interface IProbeWebhookDelivery {
+  id: string;
+  /**
+   * The registered webhook this delivery targeted. null for a delivery to a
+   * scan's own ad-hoc per-request `callbackUrl` that matched no registered
+   * webhook (see the server model's own doc comment) — such a row is never
+   * reachable via this webhook-scoped endpoint in practice (there is no
+   * webhookId to query it under), but the field stays nullable to mirror the
+   * server column's real type.
+   */
+  webhookId: string | null;
+  /** The scan whose verdict this delivery carried. */
+  scanId: string;
+  /** The exact URL this attempt POSTed to. */
+  url: string;
+  /** HTTP status code received. null when the request never got a response (network error / timeout / abort). */
+  statusCode: number | null;
+  /** true only for a 2xx response. */
+  success: boolean;
+  /** When this attempt was made. */
+  attemptedAt: Date;
+  /** Failure reason (HTTP non-2xx status, or the caught network/timeout error's message). null on success. */
+  error: string | null;
+  createdAt: Date;
+}

package/src/types/interface/models/probe-webhook.dto.ts

@@ -0,0 +1,29 @@
+// Mirrors apps/api/src/api/controllers/probe-webhook.controller.ts's local
+// WebhookResponseData. Public shape of a registered `probe_webhooks` row —
+// never echoes the internal ownership columns
+// (userId/organizationId/applicationId), same discipline as the scan models.
+//
+// WS5-7 (AbyssProbe UX rework): `secret` is ALWAYS re-displayable now —
+// returned on every read (GET /webhook list, and PATCH /webhook/:id), not
+// just once on create. Mirrors how AbyssExtract's own webhook model
+// (`IExtractionWebhookDelivery`'s sibling `ExtractionWebhook` — see
+// apps/api/src/database/models/extraction-webhook.model.ts /
+// extraction-webhook.controller.ts) has always exposed its
+// `webhookSecret` column on every response, never a once-only reveal. This
+// lets a consumer (e.g. abyss-storage's own webhook registration) read its
+// secret back at any time instead of relying on a log-once bootstrap.
+
+export interface IProbeWebhook {
+  id: string;
+  /** HTTPS endpoint the verdict is POSTed to. */
+  callbackUrl: string;
+  /**
+   * Server-generated HMAC-SHA256 signing secret. Re-displayable: returned on
+   * every read (list/create/update), not once-only — see this interface's
+   * own header note (WS5-7).
+   */
+  secret: string;
+  /** Disabled webhooks are skipped by dispatch (soft-off, not deleted). */
+  active: boolean;
+  createdAt: Date;
+}

package/src/types/tests/probe.dto.test.ts

@@ -0,0 +1,156 @@
+// Type-level compile test for AbyssProbe's DTO/response shapes — asserts
+// they match the server contract (probe-scan.controller.ts /
+// probe-webhook.controller.ts / probe-usage.controller.ts /
+// probe-webhook-delivery.service.ts) at compile time: any incompatible
+// rename/removal on either side fails `npm run build` here. No jest runner
+// in this SDK package; compile guard only (mirrors
+// ../api/extraction-plan-preset.api.test.ts). Run: npx tsc --noEmit.
+
+import {
+  ProbeScanVerdict,
+  ProbeScanMode,
+  ProbeScanStatus,
+  IProbeScanDetail,
+  IProbeScanHistoryItem,
+  IProbeWebhook,
+  IProbeWebhookDelivery,
+  IProbeWebhookDeliveryPayload,
+  IScanSyncData,
+  IScanAsyncData,
+  IUpdateProbeWebhookBody,
+  IProbeUsageData,
+} from '..';
+// estimateProbeScanCost lives in src/utils/ (a SIBLING of src/types/, not
+// re-exported by the types barrel this file otherwise imports from) — see
+// probe-scan-cost.utils.ts's own header comment for why it is a plain
+// top-level export rather than a `sdk.probe.*` method.
+import { estimateProbeScanCost } from '../../utils';
+
+// Enum exhaustiveness: fails to compile if a member is added/removed/renamed
+// here without updating this file — a cheap drift guard for values
+// transported verbatim over the wire (this SDK does not control the
+// server's enum, so a silent value drift is exactly what this must catch).
+const _verdicts: Record<ProbeScanVerdict, true> = { clean: true, infected: true };
+const _modes: Record<ProbeScanMode, true> = { sync: true, async: true };
+const _statuses: Record<ProbeScanStatus, true> = {
+  queued: true,
+  scanning: true,
+  done: true,
+  error: true,
+};
+
+// GET /scan/:scanId — WS5-4: full metadata parity with IProbeScanHistoryItem
+// (fileName/fileSize/mimeType/mode/startedAt/finishedAt/costUnits).
+const _scanDetail: IProbeScanDetail = {
+  scanId: 's1',
+  status: ProbeScanStatus.DONE,
+  verdict: ProbeScanVerdict.CLEAN,
+  viruses: [],
+  context: null,
+  fileName: 'invoice.pdf',
+  fileSize: 1024,
+  mimeType: 'application/pdf',
+  mode: ProbeScanMode.SYNC,
+  startedAt: new Date(),
+  finishedAt: new Date(),
+  costUnits: 3,
+};
+
+// GET /scan history row — WS5-1: costUnits added.
+const _historyItem: IProbeScanHistoryItem = {
+  scanId: 's1',
+  fileName: 'invoice.pdf',
+  fileSize: 1024,
+  mimeType: 'application/pdf',
+  verdict: ProbeScanVerdict.INFECTED,
+  viruses: ['Eicar-Test-Signature'],
+  mode: ProbeScanMode.ASYNC,
+  status: ProbeScanStatus.DONE,
+  context: { applicationFileId: 'af1' },
+  startedAt: new Date(),
+  finishedAt: new Date(),
+  costUnits: 1,
+  createdAt: new Date(),
+};
+
+// POST /scan — sync (200) / async (202) data shapes. WS5-1: costUnits added to the sync shape (always known/billed by the time a 200 is returned).
+const _scanSyncData: IScanSyncData = {
+  scanId: 's1',
+  verdict: ProbeScanVerdict.CLEAN,
+  viruses: [],
+  costUnits: 3,
+};
+const _scanAsyncData: IScanAsyncData = { scanId: 's1', status: ProbeScanStatus.QUEUED };
+
+// Webhook subscription — WS5-7: secret is now ALWAYS present (list/create/
+// update) and the create response returns IProbeWebhook.
+const _webhook: IProbeWebhook = {
+  id: 'w1',
+  callbackUrl: 'https://example.com/hook',
+  secret: 'shh',
+  active: true,
+  createdAt: new Date(),
+};
+
+// PATCH /webhook/:webhookId body (WS5-5) — every field optional (at least one required server-side).
+const _updateBody: IUpdateProbeWebhookBody = { active: false };
+const _updateBody2: IUpdateProbeWebhookBody = { callbackUrl: 'https://example.com/hook2' };
+
+// Webhook delivery payload — the exact body signed by x-probe-signature
+// (see verifyProbeWebhookSignature). WS5-1: costUnits added.
+const _deliveryPayload: IProbeWebhookDeliveryPayload = {
+  scanId: 's1',
+  context: null,
+  verdict: ProbeScanVerdict.INFECTED,
+  viruses: ['Eicar-Test-Signature'],
+  costUnits: 5,
+};
+
+// GET /webhook/:webhookId/deliveries row (WS5-6) — a persisted delivery-attempt.
+const _deliveryRecord: IProbeWebhookDelivery = {
+  id: 'd1',
+  webhookId: 'w1',
+  scanId: 's1',
+  url: 'https://example.com/hook',
+  statusCode: 200,
+  success: true,
+  attemptedAt: new Date(),
+  error: null,
+  createdAt: new Date(),
+};
+// webhookId is nullable (ad-hoc per-request callbackUrl with no matching registration).
+const _deliveryRecordAdHoc: IProbeWebhookDelivery = { ..._deliveryRecord, webhookId: null };
+
+// GET /usage data shape (WS5-3).
+const _usage: IProbeUsageData = { used: 10, limit: 1000, remaining: 990 };
+// -1 is the established "unlimited" sentinel (see estimateProbeScanCost's
+// server-side counterpart, utils/billing-emit.util.ts#UNLIMITED_EXPIRY_DAYS).
+const _usageUnlimited: IProbeUsageData = { used: 10, limit: -1, remaining: -1 };
+
+// estimateProbeScanCost (WS5-2) — pure shared cost model, ASYNC must cost
+// strictly less than SYNC for the same size (the scanner UI's "background
+// analysis saves tokens" tooltip depends on this). A one-byte compile-time
+// smoke check; the full behavioural suite lives in probe-scan-cost.utils.test.ts.
+const _asyncCost: number = estimateProbeScanCost(5 * 1024 * 1024, ProbeScanMode.ASYNC);
+const _syncCost: number = estimateProbeScanCost(5 * 1024 * 1024, ProbeScanMode.SYNC);
+if (_asyncCost >= _syncCost) {
+  throw new Error('estimateProbeScanCost: ASYNC must cost strictly less than SYNC');
+}
+
+void _verdicts;
+void _modes;
+void _statuses;
+void _scanDetail;
+void _historyItem;
+void _scanSyncData;
+void _scanAsyncData;
+void _webhook;
+void _updateBody;
+void _updateBody2;
+void _deliveryPayload;
+void _deliveryRecord;
+void _deliveryRecordAdHoc;
+void _usage;
+void _usageUnlimited;
+
+export {};

package/src/utils/enum.utils.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/src/utils/error.utils.ts

@@ -0,0 +1,30 @@
+import { Code, ErrorType } from '../types';
+
+type ErrorParams = { code: Code; type: ErrorType; message?: string };
+
+export class ServiceException extends Error {
+  private readonly code: Code;
+
+  private readonly type: ErrorType;
+
+  getCode(): Code {
+    return this.code;
+  }
+
+  getType(): ErrorType {
+    return this.type;
+  }
+
+  constructor(params: ErrorParams) {
+    super(params.message);
+    this.code = params.code;
+    this.type = params.type;
+  }
+}
+
+export const handleError = (error: Error | ErrorParams, _params?: ErrorParams): Error => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new ServiceException(error);
+};

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './error.utils';
+export * from './enum.utils';
+export * from './probe-webhook-signature.utils';
+export * from './probe-scan-cost.utils';

package/src/utils/probe-scan-cost.utils.ts

@@ -0,0 +1,101 @@
+// ──────────────────────────────────────────────
+// AbyssProbe scan cost model — pure, shared (client + server, no endpoint).
+//
+// Ported from abyss-storage's OWN weighted AV-scan cost model
+// (`apps/api/src/services/av-scan-usage.ts#computeAvScanCost`, introduced in
+// storage commit 317e4a0 "wire the weighted AV-scan quota", since made dead
+// code there by the AV v3 Phase 3b-2 hand-off — "storage never bills —
+// AbyssProbe does" — but the FORMULA itself is exactly what AbyssProbe's own
+// weighted billing needs, so it is ported here verbatim rather than
+// reinvented):
+//
+//   cost = round( (BASE + K_MB * ceil(sizeOctet / 1 MiB)) * MODE_WEIGHT[mode] )
+//
+// ASYNC costs LESS than SYNC (MODE_WEIGHT.async=1 < MODE_WEIGHT.sync=3) — a
+// synchronous scan holds the caller's request (and an engine worker) until
+// the verdict and cannot be batched/load-balanced, so it costs more than an
+// asynchronous (queued) scan of the SAME bytes. This is the numeric backing
+// for the scanner UI's "l'analyse en arrière-plan économise des tokens"
+// tooltip (WS1).
+//
+// PURE + DETERMINISTIC + no I/O: this is the SINGLE source of truth for
+// AbyssProbe's scan cost, used on BOTH sides of the wire —
+//   - server (apps/api/src/services/probe-scan.service.ts): the REAL cost
+//     billed via recordProbeScanUsage and persisted on probe_scans.costUnits
+//     once a scan reaches a verdict (DONE).
+//   - client (the AbyssProbe UI, or any external caller): a cost PREVIEW
+//     before scanning — call this with the picked file's size and the
+//     intended mode to show the estimated token cost, matching exactly what
+//     the server will bill (no separate "estimate" formula to drift out of
+//     sync with the real one — same function, same constants, both sides).
+//
+// Deliberately NOT exposed as an HTTP endpoint (no `POST /scan/estimate`):
+// the whole point of a pure function is that the client can compute it
+// locally, instantly, with zero round-trip — see this package's root README
+// note on `sdk.probe.*`'s HTTP-call-only convention; a helper like this one
+// (and `verifyProbeWebhookSignature` before it) is instead a plain top-level
+// export, not a `sdk.probe.*` method.
+// ──────────────────────────────────────────────
+
+import { ProbeScanMode } from '../types';
+
+/** Flat floor every scanned file pays (the "one scan" cost). Tunable. */
+export const PROBE_SCAN_COST_BASE = 1;
+
+/** Additional units per (ceil'd) mebibyte of scanned bytes. Tunable. */
+export const PROBE_SCAN_COST_K_MB = 1;
+
+/**
+ * Per-mode cost multiplier. A synchronous scan blocks the caller's request
+ * (and an engine worker) until the verdict and cannot be queued/batched, so
+ * it costs strictly MORE than an asynchronous scan of the same bytes —
+ * ASYNC < SYNC is a load-bearing invariant relied on by the scanner UI's
+ * "background analysis saves tokens" messaging (WS1). Tunable, but this
+ * ordering must never be inverted.
+ */
+export const PROBE_SCAN_COST_MODE_WEIGHT: Record<ProbeScanMode, number> = {
+  [ProbeScanMode.ASYNC]: 1,
+  [ProbeScanMode.SYNC]: 3,
+};
+
+/** One mebibyte, the unit the per-MB term is quantised to. */
+const ONE_MB = 1024 * 1024;
+
+/**
+ * Weighted cost of one AbyssProbe scan, in `ACCOUNT_AV_SCAN_UNITS` ("tokens"
+ * in the UI). Pure + deterministic — same inputs always produce the same
+ * output, no I/O, safe to call from a browser or a server.
+ *
+ * Returns `0` for a non-finite / non-positive `sizeOctet` (nothing to scan,
+ * nothing to bill) rather than throwing — a defensive, never-crash contract
+ * appropriate for a client-side cost preview that might run ahead of full
+ * input validation (e.g. while a file is still being selected).
+ *
+ * `mode` defaults to the (cheaper) ASYNC weight when given an unrecognised
+ * value, mirroring the ported formula's own `MODE_WEIGHT[mode] ?? MODE_WEIGHT.async`
+ * fallback — never silently the MORE expensive weight.
+ *
+ * `mode`'s type is widened to `| 'sync' | 'async'` alongside the enum
+ * itself, NOT just `ProbeScanMode`: apps/api's own server-side
+ * `database/probe-scan.enum.ts#ProbeScanMode` is a SEPARATE TypeScript enum
+ * declaration (kept server-local — see that file's header comment on why —
+ * with the identical 'sync'/'async' runtime values, so the wire format never
+ * drifts). TypeScript string enums are nominal: a same-valued member of that
+ * OTHER enum is not directly assignable to THIS package's `ProbeScanMode`
+ * parameter type, but IS assignable to a plain string-literal type matching
+ * its value — so the server can call this exact function (`scan.mode`,
+ * `estimateProbeScanCost`'s whole reason for living being ONE shared formula
+ * on both sides of the wire, see this file's header comment) without a cast.
+ */
+export const estimateProbeScanCost = (
+  sizeOctet: number,
+  mode: ProbeScanMode | 'sync' | 'async',
+): number => {
+  if (!Number.isFinite(sizeOctet) || sizeOctet <= 0) {
+    return 0;
+  }
+  const megabytes = Math.ceil(sizeOctet / ONE_MB);
+  const weight =
+    PROBE_SCAN_COST_MODE_WEIGHT[mode] ?? PROBE_SCAN_COST_MODE_WEIGHT[ProbeScanMode.ASYNC];
+  return Math.round((PROBE_SCAN_COST_BASE + PROBE_SCAN_COST_K_MB * megabytes) * weight);
+};

package/src/utils/probe-webhook-signature.utils.ts

@@ -0,0 +1,56 @@
+// ──────────────────────────────────────────────
+// AbyssProbe webhook signature verification (helper for RECEIVERS of a
+// webhook delivery — the abyss-main UI/abyss-storage/any external
+// integrator that registered a callbackUrl).
+//
+// Mirrors this package's own extraction-webhook.utils.ts
+// (verifyExtractionWebhook) — the same package's own precedent for this
+// exact problem — adapted to AbyssProbe's actual wire format: the signature
+// header (see PROBE_WEBHOOK_SIGNATURE_HEADER in this package's root index)
+// carries the RAW hex HMAC digest with no `sha256=` prefix (unlike
+// the extraction signature header `x-rcb-signature: sha256=<hex>`) — see
+// apps/api/src/services/probe-webhook-delivery.service.ts's `sign()`.
+//
+// Lazy-requires `crypto` so the SDK stays browser-compatible when this
+// utility is never invoked (a browser page is never the receiving end of a
+// server-to-server webhook).
+// ──────────────────────────────────────────────
+
+export interface VerifyProbeWebhookSignatureInput {
+  /** The exact bytes/string the receiver's HTTP framework handed it — must be the RAW body, not a re-serialized JSON.parse/stringify round trip (whitespace/key-order would change the HMAC). */
+  rawBody: string | Buffer;
+  /** The incoming `x-probe-signature` header value. */
+  signatureHeader: string | undefined;
+  /** This webhook registration's secret (re-displayable on IProbeWebhook). */
+  secret: string;
+}
+
+/**
+ * Recompute the HMAC-SHA256 of `rawBody` with `secret` and constant-time
+ * compare it against `signatureHeader`. Returns `false` (never throws) for
+ * any malformed input — a hostile/truncated header must not crash the
+ * receiver.
+ */
+export function verifyProbeWebhookSignature(input: VerifyProbeWebhookSignatureInput): boolean {
+  if (!input.signatureHeader || !input.secret) return false;
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const crypto = require('crypto');
+  const computed: string = crypto
+    .createHmac('sha256', input.secret)
+    .update(input.rawBody)
+    .digest('hex');
+
+  if (input.signatureHeader.length !== computed.length) return false;
+
+  try {
+    return crypto.timingSafeEqual(
+      Buffer.from(input.signatureHeader, 'hex'),
+      Buffer.from(computed, 'hex'),
+    );
+  } catch {
+    // Buffer.from(..., 'hex') on a non-hex string yields a shorter buffer,
+    // which would otherwise make timingSafeEqual throw on a length mismatch.
+    return false;
+  }
+}

package/tsconfig.check.json

@@ -0,0 +1,15 @@
+{
+  // Perimetre de VERIFICATION, distinct de celui du build.
+  //
+  // `tsconfig.json` exclut `src/**/*.spec.ts` parce qu'il sert a emettre `dist/`, ou une spec
+  // n'a rien a faire. Mais eslint s'appuie sur ce meme fichier via `parserOptions.project` :
+  // les cinq specs du paquet sortaient donc en « Parsing error: that TSConfig does not include
+  // this file », mesure du 2026-09-09, et n'etaient lintees par personne.
+  //
+  // Ce fichier sert uniquement a eslint. Il n'emet rien et ne change pas ce que `build` produit.
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "exclude": ["./dist/**/*"]
+}

package/dist/types/interface/dto/index.d.ts

@@ -1 +0,0 @@
-export * from './probe-webhook-delivery.dto';

package/dist/types/interface/dto/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./probe-webhook-delivery.dto"), exports);
-//# sourceMappingURL=index.js.map

package/dist/types/interface/dto/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/types/interface/dto/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+DAA6C"}

package/dist/types/interface/dto/probe-webhook-delivery.dto.d.ts

@@ -1,7 +0,0 @@
-import { ProbeScanVerdict } from '../../enum';
-export interface IProbeWebhookDeliveryPayload {
-    scanId: string;
-    context: Record<string, unknown> | null;
-    verdict: ProbeScanVerdict;
-    viruses: string[];
-}

package/dist/types/interface/dto/probe-webhook-delivery.dto.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"probe-webhook-delivery.dto.js","sourceRoot":"","sources":["../../../../src/types/interface/dto/probe-webhook-delivery.dto.ts"],"names":[],"mappings":""}

package/dist/types/interface/models/probe-scan.model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"probe-scan.model.js","sourceRoot":"","sources":["../../../../src/types/interface/models/probe-scan.model.ts"],"names":[],"mappings":""}

package/dist/types/interface/models/probe-webhook.model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"probe-webhook.model.js","sourceRoot":"","sources":["../../../../src/types/interface/models/probe-webhook.model.ts"],"names":[],"mappings":""}

package/dist/utils/http.utils.d.ts

@@ -1,3 +0,0 @@
-export declare const API_KEY_HEADER = "abyss-api-key";
-export declare function authHeader(apiKey?: string): Record<string, string>;
-export declare function serializeProbeQuery<T extends object>(query: T): Record<string, unknown>;

package/dist/utils/http.utils.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeProbeQuery = exports.authHeader = exports.API_KEY_HEADER = void 0;
-exports.API_KEY_HEADER = 'abyss-api-key';
-function authHeader(apiKey) {
-    return apiKey ? { [exports.API_KEY_HEADER]: apiKey } : {};
-}
-exports.authHeader = authHeader;
-function serializeProbeQuery(query) {
-    const out = {};
-    for (const [key, value] of Object.entries(query)) {
-        if (value === undefined || value === null)
-            continue;
-        const wireKey = key === 'organizationId' ? 'organization_id' : key;
-        out[wireKey] = value instanceof Date ? value.toISOString() : value;
-    }
-    return out;
-}
-exports.serializeProbeQuery = serializeProbeQuery;
-//# sourceMappingURL=http.utils.js.map

package/dist/utils/http.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.utils.js","sourceRoot":"","sources":["../../src/utils/http.utils.ts"],"names":[],"mappings":";;;AAQa,QAAA,cAAc,GAAG,eAAe,CAAC;AAS9C,SAAgB,UAAU,CAAC,MAAe;IACxC,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,sBAAc,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AACpD,CAAC;AAFD,gCAEC;AASD,SAAgB,mBAAmB,CAAmB,KAAQ;IAC5D,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;QAC5E,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;YAAE,SAAS;QACpD,MAAM,OAAO,GAAG,GAAG,KAAK,gBAAgB,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC;QACnE,GAAG,CAAC,OAAO,CAAC,GAAG,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACrE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AARD,kDAQC"}