@logbrew/sdk 0.1.38 → 0.1.39

package/provided-breadcrumbs.cjs

@@ -0,0 +1,117 @@
+const { isObjectLike, propertyOf } = require("./error-details.cjs");
+const { MAX_ISSUE_BREADCRUMBS, validateIssueBreadcrumb } = require("./issue-diagnostics.cjs");
+
+/**
+ * @import { IssueBreadcrumb } from "./index.cjs"
+ * @import { Callable, DeepReadonly } from "./validation.cjs"
+ * @typedef {readonly DeepReadonly<IssueBreadcrumb>[]} Breadcrumbs
+ * @typedef {Readonly<{ breadcrumbs: Breadcrumbs, truncated: boolean }>} BreadcrumbTrail
+ */
+
+const NO_BREADCRUMBS = 0;
+/** @type {BreadcrumbTrail} */
+const EMPTY_TRAIL = { breadcrumbs: [], truncated: false };
+
+/**
+ * @param {Callable | undefined} provider
+ * @param {unknown} receiver
+ * @returns {unknown}
+ */
+function callProvider(provider, receiver) {
+  try {
+    return provider === undefined ? undefined : Reflect.apply(provider, receiver, []);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * @param {unknown} breadcrumb
+ * @returns {IssueBreadcrumb | undefined}
+ */
+function validBreadcrumb(breadcrumb) {
+  try {
+    return validateIssueBreadcrumb(breadcrumb);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * @param {readonly unknown[]} entries
+ * @returns {BreadcrumbTrail}
+ */
+function validBreadcrumbs(entries) {
+  /** @type {IssueBreadcrumb[]} */
+  const breadcrumbs = [];
+  let truncated = false;
+  for (const entry of entries.slice(-MAX_ISSUE_BREADCRUMBS)) {
+    const breadcrumb = validBreadcrumb(entry);
+    if (breadcrumb === undefined) {
+      truncated = true;
+    } else {
+      breadcrumbs.push(breadcrumb);
+    }
+  }
+  return { breadcrumbs, truncated };
+}
+
+/**
+ * @param {Callable | undefined} provider
+ * @param {unknown} receiver
+ * @returns {BreadcrumbTrail}
+ */
+function providedBreadcrumbs(provider, receiver) {
+  const provided = callProvider(provider, receiver);
+  const list = isObjectLike(provided) ? propertyOf(provided, "breadcrumbs") : undefined;
+  if (!Array.isArray(list)) {
+    return EMPTY_TRAIL;
+  }
+  /** @type {readonly unknown[]} */
+  const entries = list;
+  const flagged = propertyOf(provided, "truncated") === true || entries.length > MAX_ISSUE_BREADCRUMBS;
+  const validated = validBreadcrumbs(entries);
+  return { breadcrumbs: validated.breadcrumbs, truncated: flagged || validated.truncated };
+}
+
+/**
+ * @param {DeepReadonly<IssueBreadcrumb>} left
+ * @param {DeepReadonly<IssueBreadcrumb>} right
+ * @returns {number}
+ */
+function byTimestamp(left, right) {
+  return Date.parse(left.timestamp) - Date.parse(right.timestamp);
+}
+
+/**
+ * @param {Breadcrumbs} local
+ * @param {Breadcrumbs} provided
+ * @returns {Breadcrumbs}
+ */
+function mergedBreadcrumbs(local, provided) {
+  if (provided.length === NO_BREADCRUMBS) {
+    return local;
+  }
+  const merged = [...local, ...provided];
+  merged.sort(byTimestamp);
+  return merged;
+}
+
+/**
+ * @param {Readonly<Record<string, unknown>>} attributes
+ * @param {BreadcrumbTrail} local
+ * @param {BreadcrumbTrail} provided
+ * @returns {Readonly<Record<string, unknown>>}
+ */
+function withIssueBreadcrumbs(attributes, local, provided) {
+  const merged = mergedBreadcrumbs(local.breadcrumbs, provided.breadcrumbs);
+  const breadcrumbs = merged.slice(-MAX_ISSUE_BREADCRUMBS);
+  const truncated = attributes["breadcrumbsTruncated"] === true || local.truncated
+    || provided.truncated || merged.length > breadcrumbs.length;
+  if (breadcrumbs.length === NO_BREADCRUMBS) {
+    return attributes;
+  }
+  return { ...attributes, breadcrumbs, ...(truncated ? { breadcrumbsTruncated: true } : {}) };
+}
+
+module.exports = { providedBreadcrumbs, withIssueBreadcrumbs };

package/random-hex.cjs

@@ -0,0 +1,29 @@
+const { propertyOf } = require("./error-details.cjs");
+
+const BYTE_VALUES = 256;
+const HEX_RADIX = 16;
+const HEX_DIGITS_PER_BYTE = 2;
+
+/**
+ * @param {number} byteLength
+ * @returns {Uint8Array}
+ */
+function randomBytes(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  const getRandomValues = propertyOf(propertyOf(globalThis, "crypto"), "getRandomValues");
+  if (typeof getRandomValues === "function") {
+    Reflect.apply(getRandomValues, propertyOf(globalThis, "crypto"), [bytes]);
+    return bytes;
+  }
+  return Uint8Array.from(bytes, () => Math.floor(Math.random() * BYTE_VALUES));
+}
+
+/**
+ * @param {number} byteLength
+ * @returns {string}
+ */
+function randomHex(byteLength) {
+  return Array.from(randomBytes(byteLength), (byte) => byte.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, "0")).join("");
+}
+
+module.exports = { randomHex };

package/react-native.js

@@ -34,4 +34,4 @@ export const {
   TransportError
 } = sdk;
 
-export default sdk;
+export { default } from "./core.cjs";

package/recording-transport.cjs

@@ -0,0 +1,68 @@
+const { NULL_VALUE } = require("./null-value.cjs");
+const { retryAfterMsOrUndefined } = require("./sdk-error.cjs");
+const { requireNonEmpty } = require("./validation.cjs");
+
+/**
+ * @import { TransportResponse } from "./index.cjs"
+ * @typedef {{ statusCode: number, retryAfterMs?: number, errorCode?: string }} ScriptedResponse
+ * @typedef {ScriptedResponse | Error} ScriptedOutcome
+ */
+
+const ACCEPTED_STATUS_CODE = 202;
+const SINGLE_ATTEMPT = 1;
+const LAST_INDEX = -1;
+const FIRST_INDEX = 0;
+const SINGLE_RESPONSE = 1;
+
+class RecordingTransport {
+  /**
+   * @param {readonly (Readonly<ScriptedResponse> | Readonly<Error>)[]} [scriptedResponses]
+   */
+  constructor(scriptedResponses = [{ statusCode: ACCEPTED_STATUS_CODE }]) {
+    /** @type {ScriptedOutcome[]} */
+    this.scriptedResponses = [...scriptedResponses];
+    /** @type {string[]} */
+    this.sentBodies = [];
+  }
+
+  /**
+   * @returns {RecordingTransport}
+   */
+  static alwaysAccept() {
+    return new RecordingTransport([{ statusCode: ACCEPTED_STATUS_CODE }]);
+  }
+
+  /**
+   * @returns {string | null}
+   */
+  lastBody() {
+    return this.sentBodies.at(LAST_INDEX) ?? NULL_VALUE;
+  }
+
+  /**
+   * @param {unknown} apiKey
+   * @param {string} body
+   * @returns {Promise<TransportResponse>}
+   */
+  async send(apiKey, body) {
+    requireNonEmpty("apiKey", apiKey);
+    this.sentBodies.push(body);
+
+    const [next = { statusCode: ACCEPTED_STATUS_CODE }] = this.scriptedResponses.splice(FIRST_INDEX, SINGLE_RESPONSE);
+
+    if (next instanceof Error) {
+      throw next;
+    }
+
+    const retryAfterMs = retryAfterMsOrUndefined(next.retryAfterMs);
+    return {
+      statusCode: next.statusCode,
+
+      attempts: SINGLE_ATTEMPT,
+      ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+      ...(typeof next.errorCode === "string" ? { errorCode: next.errorCode } : {})
+    };
+  }
+}
+
+module.exports = { RecordingTransport };