@tinycloud/sdk-services 2.4.0-beta.15 → 2.4.0-beta.19

package/dist/index.js

@@ -67,6 +67,202 @@ function serviceError(code, message, service, options) {
   };
 }
 
+// src/debug.ts
+var DEBUG_FLAG = "TinyCloud_debug";
+var MAX_EVENTS = 1e3;
+function getGlobal() {
+  return globalThis;
+}
+function nowMs() {
+  const performanceNow = globalThis.performance?.now?.bind(globalThis.performance);
+  return typeof performanceNow === "function" ? performanceNow() : Date.now();
+}
+function isTrue(value) {
+  return value === true || value === "true" || value === "1";
+}
+function getProcessDebugFlag() {
+  const processLike = globalThis.process;
+  return processLike?.env?.[DEBUG_FLAG];
+}
+function isBrowserWindow() {
+  const global = getGlobal();
+  return global.window === globalThis;
+}
+function getLocalStorage() {
+  if (!isBrowserWindow()) {
+    return void 0;
+  }
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function getStoredDebugFlag() {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return void 0;
+  }
+  try {
+    return storage.getItem(DEBUG_FLAG);
+  } catch {
+    return void 0;
+  }
+}
+function setStoredDebugFlag(enabled) {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return;
+  }
+  try {
+    if (enabled) {
+      storage.setItem(DEBUG_FLAG, "true");
+    } else {
+      storage.removeItem(DEBUG_FLAG);
+    }
+  } catch {
+  }
+}
+function shouldStartEnabled() {
+  const global = getGlobal();
+  return isTrue(global[DEBUG_FLAG]) || isTrue(getStoredDebugFlag()) || isTrue(getProcessDebugFlag());
+}
+var TinyCloudDebugLogger = class {
+  constructor() {
+    this.enabled = shouldStartEnabled();
+    this.sequence = 0;
+    this.events = [];
+    this.maxEvents = MAX_EVENTS;
+  }
+  isEnabled() {
+    return this.enabled || isTrue(getGlobal()[DEBUG_FLAG]) || isTrue(getProcessDebugFlag());
+  }
+  enable(options = {}) {
+    this.enabled = true;
+    getGlobal()[DEBUG_FLAG] = true;
+    if (options.persist !== false) {
+      setStoredDebugFlag(true);
+    }
+    this.log("debug.enabled", { persisted: options.persist !== false });
+  }
+  disable(options = {}) {
+    this.log("debug.disabled", { persisted: options.persist !== false });
+    this.enabled = false;
+    getGlobal()[DEBUG_FLAG] = false;
+    if (options.persist !== false) {
+      setStoredDebugFlag(false);
+    }
+  }
+  clear() {
+    this.events = [];
+  }
+  getLogs() {
+    return [...this.events];
+  }
+  log(event, data, message) {
+    if (!this.isEnabled()) {
+      return void 0;
+    }
+    return this.record({
+      event,
+      data,
+      message,
+      level: "debug",
+      timestamp: Date.now(),
+      timestampIso: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  startTimer(event, data) {
+    if (!this.isEnabled()) {
+      return { stop: () => void 0 };
+    }
+    const startedAt = nowMs();
+    this.log(`${event}.start`, data);
+    return {
+      stop: (finishData) => {
+        const endedAt = nowMs();
+        return this.record({
+          event: `${event}.end`,
+          data: finishData,
+          durationMs: endedAt - startedAt,
+          startedAt,
+          endedAt,
+          level: "debug",
+          timestamp: Date.now(),
+          timestampIso: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    };
+  }
+  async timeAsync(event, operation, data) {
+    if (!this.isEnabled()) {
+      return operation();
+    }
+    const timer = this.startTimer(event, data);
+    try {
+      const result = await operation();
+      timer.stop({ ok: true });
+      return result;
+    } catch (error) {
+      timer.stop({ ok: false, error });
+      throw error;
+    }
+  }
+  time(event, operation, data) {
+    if (!this.isEnabled()) {
+      return operation();
+    }
+    const timer = this.startTimer(event, data);
+    try {
+      const result = operation();
+      timer.stop({ ok: true });
+      return result;
+    } catch (error) {
+      timer.stop({ ok: false, error });
+      throw error;
+    }
+  }
+  record(event) {
+    const debugEvent = {
+      ...event,
+      sequence: ++this.sequence
+    };
+    this.events.push(debugEvent);
+    if (this.events.length > this.maxEvents) {
+      this.events.splice(0, this.events.length - this.maxEvents);
+    }
+    try {
+      globalThis.console?.debug?.("[TinyCloud]", debugEvent.event, debugEvent);
+    } catch {
+    }
+    return debugEvent;
+  }
+};
+var tinyCloudDebugLogger = new TinyCloudDebugLogger();
+function enableTinyCloudDebug(options) {
+  tinyCloudDebugLogger.enable(options);
+  return tinyCloudDebugLogger;
+}
+function disableTinyCloudDebug(options) {
+  tinyCloudDebugLogger.disable(options);
+  return tinyCloudDebugLogger;
+}
+function getTinyCloudDebugLogs() {
+  return tinyCloudDebugLogger.getLogs();
+}
+function clearTinyCloudDebugLogs() {
+  tinyCloudDebugLogger.clear();
+}
+function installTinyCloudDebugGlobals() {
+  const global = getGlobal();
+  global.TinyCloudDebug = tinyCloudDebugLogger;
+  global.enableTinyCloudDebug = enableTinyCloudDebug;
+  global.disableTinyCloudDebug = disableTinyCloudDebug;
+  global.getTinyCloudDebugLogs = getTinyCloudDebugLogs;
+  global.clearTinyCloudDebugLogs = clearTinyCloudDebugLogs;
+}
+installTinyCloudDebugGlobals();
+
 // src/types.schema.ts
 import { z } from "zod";
 var ServiceErrorSchema = z.object({
@@ -308,9 +504,9 @@ var ServiceContext = class {
     this._services = /* @__PURE__ */ new Map();
     this._eventHandlers = /* @__PURE__ */ new Map();
     this._abortController = new AbortController();
-    this._invoke = config.invoke;
-    this._invokeAny = config.invokeAny;
-    this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this._invoke = this.wrapInvoke(config.invoke);
+    this._invokeAny = config.invokeAny ? this.wrapInvokeAny(config.invokeAny) : void 0;
+    this._fetch = this.wrapFetch(config.fetch ?? globalThis.fetch.bind(globalThis));
     this._hosts = config.hosts;
     this._session = config.session ?? null;
     this._retryPolicy = {
@@ -413,6 +609,7 @@ var ServiceContext = class {
    * @param data - Event data
    */
   emit(event, data) {
+    tinyCloudDebugLogger.log(event, data);
     if (this._telemetryEnabled && this._telemetryHandler) {
       try {
         this._telemetryHandler(event, data);
@@ -502,6 +699,77 @@ var ServiceContext = class {
   get retryPolicy() {
     return this._retryPolicy;
   }
+  wrapInvoke(invoke) {
+    return (session, service, path, action, facts) => {
+      if (!tinyCloudDebugLogger.isEnabled()) {
+        return invoke(session, service, path, action, facts);
+      }
+      const timer = tinyCloudDebugLogger.startTimer("sdk.invoke", {
+        service,
+        path,
+        action,
+        facts
+      });
+      try {
+        const result = invoke(session, service, path, action, facts);
+        timer.stop({ ok: true, service, path, action });
+        return result;
+      } catch (error) {
+        timer.stop({ ok: false, service, path, action, error });
+        throw error;
+      }
+    };
+  }
+  wrapInvokeAny(invokeAny) {
+    return (session, entries, facts) => {
+      if (!tinyCloudDebugLogger.isEnabled()) {
+        return invokeAny(session, entries, facts);
+      }
+      const timer = tinyCloudDebugLogger.startTimer("sdk.invokeAny", {
+        entries,
+        facts
+      });
+      try {
+        const result = invokeAny(session, entries, facts);
+        timer.stop({ ok: true, entries });
+        return result;
+      } catch (error) {
+        timer.stop({ ok: false, entries, error });
+        throw error;
+      }
+    };
+  }
+  wrapFetch(fetchFn) {
+    return async (url, init) => {
+      if (!tinyCloudDebugLogger.isEnabled()) {
+        return fetchFn(url, init);
+      }
+      const timer = tinyCloudDebugLogger.startTimer("sdk.fetch", {
+        url,
+        method: init?.method ?? "GET",
+        init
+      });
+      try {
+        const response = await fetchFn(url, init);
+        timer.stop({
+          ok: response.ok,
+          url,
+          method: init?.method ?? "GET",
+          status: response.status,
+          statusText: response.statusText
+        });
+        return response;
+      } catch (error) {
+        timer.stop({
+          ok: false,
+          url,
+          method: init?.method ?? "GET",
+          error
+        });
+        throw error;
+      }
+    };
+  }
 };
 
 // src/errors.ts
@@ -5891,6 +6159,7 @@ export {
   ServiceSessionSchema,
   TelemetryEvents,
   TelemetrySpanEventSchema,
+  TinyCloudDebugLogger,
   TinyCloudQuota,
   VaultHeaders,
   VaultPublicSpaceKVActions,
@@ -5910,21 +6179,26 @@ export {
   canonicalize as canonicalizeEncryptionJson,
   canonicalizeSecretScope,
   checkDecryptInvocationInput,
+  clearTinyCloudDebugLogs,
   createKVResponseSchema,
   createResultSchema,
   createVaultCrypto,
   decryptEnvelopeWithKey,
   defaultRetryPolicy,
   deriveSignedReceiverKey,
+  disableTinyCloudDebug,
   discoverNetwork,
+  enableTinyCloudDebug,
   encryptToNetwork,
   encryptionError,
   ensureNetworkUsableForDecrypt,
   err,
   errorResult,
   generateRandomReceiverKey,
+  getTinyCloudDebugLogs,
   hexDecode,
   hexEncode2 as hexEncode,
+  installTinyCloudDebugGlobals,
   isNetworkId,
   networkDiscoveryKey,
   networkError,
@@ -5940,6 +6214,7 @@ export {
   storageLimitReachedError,
   storageQuotaExceededError,
   timeoutError,
+  tinyCloudDebugLogger,
   utf8Decode,
   utf8Encode,
   validateEnvelope,