@kanca-app/ikas 0.2.0 → 0.3.0

package/dist/index.js

@@ -145,7 +145,7 @@ function classifyGraphql(status, json) {
 
 // src/shared.ts
 var SDK_NAME = "@kanca-app/ikas";
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.3.0";
 var DEFAULT_ENDPOINT = "https://kanca.onurhan.dev";
 var MAX_NAME = 200;
 var MAX_ERROR_MESSAGE = 500;
@@ -378,6 +378,126 @@ var Transport = class {
   }
 };
 
+// src/install.ts
+var INSTALL_RECHECK_DELAY_MS = 3e3;
+var MASS_REVOCATION_MIN = 5;
+var PROBE = "query getAuthorizedApp { getAuthorizedApp { id } }";
+async function probe(client) {
+  const c = client;
+  if (!c || typeof c !== "object" || !c._client || typeof c._client.request !== "function") {
+    return { state: "unknown", reason: "UNSUPPORTED_CLIENT" };
+  }
+  if (typeof c._checkToken === "function") {
+    try {
+      await c._checkToken();
+    } catch {
+      return { state: "unknown", reason: "TOKEN_CHECK_FAILED" };
+    }
+  }
+  let data;
+  try {
+    data = await c._client.request({ document: PROBE });
+  } catch (err) {
+    const resp = err?.response;
+    const status = resp?.status;
+    if (typeof status !== "number") return { state: "unknown", reason: "NETWORK" };
+    const first = Array.isArray(resp.errors) ? resp.errors[0] : void 0;
+    const code = first?.extensions?.code;
+    return { state: "unknown", reason: typeof code === "string" && code ? code.slice(0, 100) : `HTTP_${status}` };
+  }
+  if (data && typeof data === "object" && "getAuthorizedApp" in data) {
+    const app = data.getAuthorizedApp;
+    if (app === null) return { state: "removed" };
+    const id = app && typeof app === "object" ? app.id : void 0;
+    if (typeof id === "string" && id) return { state: "installed" };
+  }
+  return { state: "unknown", reason: "UNEXPECTED_RESPONSE" };
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function checkInstallState(merchantId, client, recheckDelayMs) {
+  if (typeof merchantId !== "string" || !merchantId) return { merchantId: "", state: "unknown", reason: "MISSING_MERCHANT_ID" };
+  try {
+    const first = await probe(client);
+    if (first.state === "installed") return { merchantId, state: "installed" };
+    if (first.state === "unknown") return { merchantId, state: "unknown", reason: first.reason };
+    await sleep2(recheckDelayMs);
+    const second = await probe(client);
+    if (second.state === "removed") return { merchantId, state: "uninstalled" };
+    if (second.state === "installed") return { merchantId, state: "installed" };
+    return { merchantId, state: "unknown", reason: second.reason };
+  } catch {
+    return { merchantId, state: "unknown", reason: "UNEXPECTED_RESPONSE" };
+  }
+}
+function isMassRevocation(uninstalled, checked) {
+  return uninstalled >= MASS_REVOCATION_MIN && uninstalled * 2 > checked;
+}
+async function checkInstallStates(stores, concurrency, recheckDelayMs) {
+  const list = Array.isArray(stores) ? stores : [];
+  const results = new Array(list.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < list.length) {
+      const i = next++;
+      const store = list[i];
+      results[i] = await checkInstallState(store?.merchantId, store?.client, recheckDelayMs);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, list.length) }, worker));
+  const uninstalled = results.filter((r) => r.state === "uninstalled").length;
+  if (!isMassRevocation(uninstalled, results.length)) return { results, massRevocation: false };
+  return {
+    massRevocation: true,
+    results: results.map((r) => r.state === "uninstalled" ? { merchantId: r.merchantId, state: "unknown", reason: "MASS_REVOCATION" } : r)
+  };
+}
+
+// src/oauth.ts
+var OAUTH_REFRESH = "oauth:refresh";
+var OAUTH_TOKEN = "oauth:token";
+var STORE_SUFFIXES = [".myikas.com", ".myikas.dev"];
+var OAUTH_ERROR = /^[a-z0-9_]{1,64}$/;
+function ikasTokenUrl(url) {
+  const host = url.hostname.toLowerCase();
+  const suffix = STORE_SUFFIXES.find((s) => host.endsWith(s));
+  if (!suffix) return void 0;
+  if (url.pathname.replace(/\/+$/, "") !== "/api/admin/oauth/token") return void 0;
+  const store = host.slice(0, -suffix.length);
+  if (!store || store.includes(".")) return void 0;
+  return store === "api" ? {} : { storeName: store };
+}
+function oauthNameFromBody(body) {
+  try {
+    let params;
+    if (body instanceof URLSearchParams) params = body;
+    else if (typeof body === "string") params = new URLSearchParams(body);
+    return params?.get("grant_type") === "refresh_token" ? OAUTH_REFRESH : OAUTH_TOKEN;
+  } catch {
+    return OAUTH_TOKEN;
+  }
+}
+function oauthErrorCode(data, status) {
+  const code = data && typeof data === "object" ? data.error : void 0;
+  return typeof code === "string" && OAUTH_ERROR.test(code) ? code : `HTTP_${status}`;
+}
+function fromStatus(status, data) {
+  const ok = status < 400;
+  return ok ? { status, ok } : { status, ok, error: { code: oauthErrorCode(data, status) } };
+}
+function validStatus(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 100 && v <= 599;
+}
+function refreshResultOutcome(result) {
+  const r = result;
+  if (r && typeof r === "object" && validStatus(r.status)) return fromStatus(r.status, r.data);
+  return {};
+}
+function refreshErrorOutcome(err) {
+  const resp = err?.response;
+  if (resp && typeof resp === "object" && validStatus(resp.status)) return fromStatus(resp.status, resp.data);
+  return { ok: false, error: { code: "NETWORK" } };
+}
+
 // src/index.ts
 var exitFlushers = /* @__PURE__ */ new Set();
 var exitHookInstalled = false;
@@ -395,11 +515,6 @@ function registerExitFlush(fn) {
   } catch {
   }
 }
-var UNINSTALL_SCOPES = [
-  "store/app/deleted",
-  "store/app/uninstalled",
-  "store/authorizedApp/deleted"
-];
 var MARK = /* @__PURE__ */ Symbol.for("kanca.instrumented");
 var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 function clampInt(v, def, min, max) {
@@ -441,12 +556,18 @@ function parseWebhookMeta(text) {
     return null;
   }
 }
-function noopKanca() {
+function checkInstallsOptions(options) {
+  return clampInt(options?.concurrency, 3, 1, 10);
+}
+function noopKanca(recheckDelayMs) {
   return {
     webhook: (handler) => async (req, ...rest) => handler(req, ...rest),
     fetch: ((input, init) => globalThis.fetch(input, init)),
     instrument: (client) => client,
     track: () => void 0,
+    checkInstall: (client, fields) => checkInstallState(fields?.merchantId, client, recheckDelayMs),
+    checkInstalls: (stores, options) => checkInstallStates(stores, checkInstallsOptions(options), recheckDelayMs),
+    trackRefresh: async (call) => await call(),
     flush: () => Promise.resolve(),
     enabled: false
   };
@@ -457,20 +578,21 @@ function createKanca(options = {}) {
     if (debug) console.debug(`[kanca] ${msg}`, ...args);
   };
   const warn = (msg) => console.warn(msg);
+  const recheckDelayMs = clampInt(options.installRecheckDelayMs, INSTALL_RECHECK_DELAY_MS, 0, 6e4);
   if (options.disabled) {
     log("disabled; SDK is a no-op");
-    return noopKanca();
+    return noopKanca(recheckDelayMs);
   }
   const key = typeof options.key === "string" ? options.key.trim() : "";
   if (!key) {
     log("no key (KANCA_KEY) configured; SDK is a no-op");
-    return noopKanca();
+    return noopKanca(recheckDelayMs);
   }
   if (!key.startsWith("kk_")) {
     warn(
       key.startsWith("kp_") ? "[kanca] createKanca() needs a server key (kk_...), got a public key (kp_...). Public keys are for reportVitals()/<KancaVitals/> only. SDK disabled." : "[kanca] KANCA_KEY must start with kk_. SDK disabled."
     );
-    return noopKanca();
+    return noopKanca(recheckDelayMs);
   }
   const maxBatchSize = clampInt(options.maxBatchSize, 100, 1, MAX_EVENTS_PER_BATCH);
   const transport = new Transport({
@@ -557,7 +679,6 @@ function createKanca(options = {}) {
             durationMs,
             error
           });
-          if (m?.scope && UNINSTALL_SCOPES.includes(m.scope)) emit({ ...base, type: "uninstall", name: "uninstall" });
         })
       );
       afterDelivery();
@@ -585,11 +706,17 @@ function createKanca(options = {}) {
     let method = "GET";
     let gql = false;
     let opName;
+    let tokenUrl;
     try {
       url = toUrl(input);
       method = (init?.method ?? (isRequest(input) ? input.method : "GET")).toUpperCase();
       gql = !!url && isIkasGraphqlUrl(url);
-      if (gql) {
+      tokenUrl = url ? ikasTokenUrl(url) : void 0;
+      if (tokenUrl) {
+        if (init && init.body != null) opName = Promise.resolve(oauthNameFromBody(bodyToString(init.body) ?? init.body));
+        else if (isRequest(input) && input.body) opName = input.clone().text().then(oauthNameFromBody, () => oauthNameFromBody(void 0));
+        else opName = Promise.resolve(oauthNameFromBody(void 0));
+      } else if (gql) {
         if (init && init.body != null) opName = Promise.resolve(operationNameFromBody(bodyToString(init.body)));
         else if (isRequest(input) && input.body) opName = input.clone().text().then(operationNameFromBody, () => "anonymous");
         else opName = Promise.resolve("anonymous");
@@ -607,7 +734,8 @@ function createKanca(options = {}) {
       const durationMs2 = now() - t0;
       try {
         const error = { code: "NETWORK", message: errorMessage(err) };
-        if (gql) observe((opName ?? Promise.resolve("anonymous")).then((name) => emit({ type: "graphql", name, ts, ok: false, durationMs: durationMs2, error })));
+        if (tokenUrl) recordOAuth(opName, ts, durationMs2, tokenUrl.storeName, { ok: false, error: { code: "NETWORK" } }, void 0);
+        else if (gql) observe((opName ?? Promise.resolve("anonymous")).then((name) => emit({ type: "graphql", name, ts, ok: false, durationMs: durationMs2, error })));
         else emit({ type: "rest", name: `${method} ${url.host}${url.pathname}`, ts, ok: false, durationMs: durationMs2, error });
       } catch {
       }
@@ -616,7 +744,15 @@ function createKanca(options = {}) {
     const durationMs = now() - t0;
     try {
       const status = res.status;
-      if (gql) {
+      if (tokenUrl) {
+        let clone;
+        try {
+          clone = status >= 400 ? res.clone() : void 0;
+        } catch {
+          clone = void 0;
+        }
+        recordOAuth(opName, ts, durationMs, tokenUrl.storeName, { status, ok: status < 400 }, clone);
+      } else if (gql) {
         let clone;
         try {
           clone = res.clone();
@@ -652,6 +788,32 @@ function createKanca(options = {}) {
     }
     return res;
   };
+  const recordOAuth = (name, ts, durationMs, storeName, outcome, errorBody) => {
+    observe(
+      (async () => {
+        let error = outcome.error;
+        if (errorBody && typeof outcome.status === "number") {
+          let data;
+          try {
+            data = JSON.parse(await errorBody.text());
+          } catch {
+            data = void 0;
+          }
+          error = { code: oauthErrorCode(data, outcome.status) };
+        }
+        emit({
+          type: "rest",
+          name: await (name ?? Promise.resolve(OAUTH_REFRESH)),
+          ts,
+          status: outcome.status,
+          ok: outcome.ok,
+          durationMs,
+          error,
+          attrs: storeName ? { storeName } : void 0
+        });
+      })()
+    );
+  };
   let warnedInstrument = false;
   const instrument = (client, opts) => {
     const c = client;
@@ -760,12 +922,52 @@ function createKanca(options = {}) {
       log("track failed", e);
     }
   };
+  const recordUninstall = (result) => {
+    if (result.state !== "uninstalled") return;
+    emit({ type: "uninstall", name: "uninstall", ts: Date.now(), merchantId: result.merchantId, attrs: { source: "check" } });
+    transport.scheduleSoon();
+  };
+  const checkInstall = async (client, fields) => {
+    const result = await checkInstallState(fields?.merchantId, client, recheckDelayMs);
+    recordUninstall(result);
+    return result;
+  };
+  const checkInstalls = async (stores, opts) => {
+    const out = await checkInstallStates(stores, checkInstallsOptions(opts), recheckDelayMs);
+    for (const r of out.results) recordUninstall(r);
+    return out;
+  };
+  const trackRefresh = async (call, fields) => {
+    const ts = Date.now();
+    const t0 = now();
+    const record = (outcome) => {
+      try {
+        const attrs = {};
+        if (typeof fields?.storeName === "string" && fields.storeName) attrs.storeName = fields.storeName;
+        emit({ type: "rest", name: OAUTH_REFRESH, ts, durationMs: now() - t0, merchantId: fields?.merchantId, attrs, ...outcome });
+      } catch (e) {
+        log("trackRefresh failed", e);
+      }
+    };
+    let result;
+    try {
+      result = await call();
+    } catch (err) {
+      record(refreshErrorOutcome(err));
+      throw err;
+    }
+    record(refreshResultOutcome(result));
+    return result;
+  };
   log(`enabled \u2192 ${options.endpoint || DEFAULT_ENDPOINT}`);
   return {
     webhook,
     fetch: kfetch,
     instrument,
     track,
+    checkInstall,
+    checkInstalls,
+    trackRefresh,
     flush,
     enabled: true
   };
@@ -773,7 +975,6 @@ function createKanca(options = {}) {
 export {
   SDK_NAME,
   SDK_VERSION,
-  UNINSTALL_SCOPES,
   createKanca,
   operationName
 };