@supertokens-plugins/rownd-nodejs 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -0,0 +1,1095 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/supertokens-js-override/lib/build/getProxyObject.js
+var require_getProxyObject = __commonJS({
+  "../../node_modules/supertokens-js-override/lib/build/getProxyObject.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getProxyObject = void 0;
+    function getProxyObject(orig) {
+      var ret = __assign(__assign({}, orig), { _call: function(_, __) {
+        throw new Error("This function should only be called through the recipe object");
+      } });
+      var keys = Object.keys(ret);
+      var _loop_1 = function(k2) {
+        if (k2 !== "_call") {
+          ret[k2] = function() {
+            var args = [];
+            for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+              args[_i2] = arguments[_i2];
+            }
+            return this._call(k2, args);
+          };
+        }
+      };
+      for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var k = keys_1[_i];
+        _loop_1(k);
+      }
+      return ret;
+    }
+    exports.getProxyObject = getProxyObject;
+  }
+});
+
+// ../../node_modules/supertokens-js-override/lib/build/index.js
+var require_build = __commonJS({
+  "../../node_modules/supertokens-js-override/lib/build/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OverrideableBuilder = void 0;
+    var getProxyObject_1 = require_getProxyObject();
+    var OverrideableBuilder2 = (
+      /** @class */
+      (function() {
+        function OverrideableBuilder3(originalImplementation) {
+          this.layers = [originalImplementation];
+          this.proxies = [];
+        }
+        OverrideableBuilder3.prototype.override = function(overrideFunc) {
+          var proxy = (0, getProxyObject_1.getProxyObject)(this.layers[0]);
+          var layer = overrideFunc(proxy, this);
+          for (var _i = 0, _a = Object.keys(this.layers[0]); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (layer[key] === proxy[key] || key === "_call") {
+              delete layer[key];
+            } else if (layer[key] === void 0) {
+              layer[key] = null;
+            }
+          }
+          this.layers.push(layer);
+          this.proxies.push(proxy);
+          return this;
+        };
+        OverrideableBuilder3.prototype.build = function() {
+          var _this = this;
+          if (this.result) {
+            return this.result;
+          }
+          this.result = {};
+          for (var _i = 0, _a = this.layers; _i < _a.length; _i++) {
+            var layer = _a[_i];
+            for (var _b = 0, _c = Object.keys(layer); _b < _c.length; _b++) {
+              var key = _c[_b];
+              var override = layer[key];
+              if (override !== void 0) {
+                if (override === null) {
+                  this.result[key] = void 0;
+                } else if (typeof override === "function") {
+                  this.result[key] = override.bind(this.result);
+                } else {
+                  this.result[key] = override;
+                }
+              }
+            }
+          }
+          var _loop_1 = function(proxyInd2) {
+            var proxy = this_1.proxies[proxyInd2];
+            proxy._call = function(fname, args) {
+              for (var i = proxyInd2; i >= 0; --i) {
+                var func = _this.layers[i][fname];
+                if (func !== void 0 && func !== null) {
+                  return func.bind(_this.result).apply(void 0, args);
+                }
+              }
+            };
+          };
+          var this_1 = this;
+          for (var proxyInd = 0; proxyInd < this.proxies.length; ++proxyInd) {
+            _loop_1(proxyInd);
+          }
+          return this.result;
+        };
+        return OverrideableBuilder3;
+      })()
+    );
+    exports.OverrideableBuilder = OverrideableBuilder2;
+    exports.default = OverrideableBuilder2;
+  }
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// ../../shared/js/src/createPluginInit.ts
+var import_supertokens_js_override = __toESM(require_build());
+var createPluginInitFunction = (init2, getImplementation, getNormalisedConfig = (config2) => config2) => {
+  const getNormalizedImplementation = typeof getImplementation === "function" ? getImplementation : (_config) => getImplementation || {};
+  return (inputConfig) => {
+    const config2 = getNormalisedConfig(inputConfig || {});
+    const baseImplementation = getNormalizedImplementation(config2);
+    const overrideBuilder = new import_supertokens_js_override.OverrideableBuilder(baseImplementation);
+    if (inputConfig?.override) {
+      overrideBuilder.override(inputConfig.override);
+    }
+    const actualImplementation = overrideBuilder.build();
+    return init2(config2, actualImplementation);
+  };
+};
+
+// ../../shared/nodejs/src/pluginUserMetadata.ts
+import UserMetadata from "supertokens-node/recipe/usermetadata";
+
+// ../../shared/nodejs/src/withRequestHandler.ts
+var withRequestHandler = (fn) => {
+  return async (req, res, session, userContext) => {
+    const result = await fn(req, res, session, userContext);
+    if (result.status === "OK") {
+      res.setStatusCode(200);
+    } else {
+      res.setStatusCode(Number(result.code) || 400);
+    }
+    res.sendJSONResponse(result);
+    return null;
+  };
+};
+
+// ../../shared/nodejs/src/log/logger.ts
+import util from "util";
+
+// ../../shared/nodejs/src/log/common.ts
+function setup(env) {
+  createDebug.debug = createDebug;
+  createDebug.default = createDebug;
+  createDebug.coerce = coerce;
+  createDebug.disable = disable;
+  createDebug.enable = enable;
+  createDebug.enabled = enabled;
+  createDebug.humanize = env.humanize;
+  createDebug.destroy = destroy;
+  Object.keys(env).forEach((key) => {
+    createDebug[key] = env[key];
+  });
+  createDebug.names = [];
+  createDebug.skips = [];
+  createDebug.formatters = {};
+  function selectColor(namespace) {
+    let hash = 0;
+    for (let i = 0; i < namespace.length; i++) {
+      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+      hash |= 0;
+    }
+    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+  }
+  createDebug.selectColor = selectColor;
+  function createDebug(namespace) {
+    let prevTime;
+    let enableOverride = null;
+    let namespacesCache;
+    let enabledCache;
+    function debug(...args) {
+      if (!debug.enabled) {
+        return;
+      }
+      const self = debug;
+      const curr = Number(/* @__PURE__ */ new Date());
+      const ms = curr - (prevTime || curr);
+      self.diff = ms;
+      self.prev = prevTime;
+      self.curr = curr;
+      prevTime = curr;
+      args[0] = createDebug.coerce(args[0]);
+      if (typeof args[0] !== "string") {
+        args.unshift("%O");
+      }
+      let index = 0;
+      args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+        if (match === "%%") {
+          return "%";
+        }
+        index++;
+        const formatter = createDebug.formatters[format];
+        if (typeof formatter === "function") {
+          const val = args[index];
+          match = formatter.call(self, val);
+          args.splice(index, 1);
+          index--;
+        }
+        return match;
+      });
+      createDebug.formatArgs.call(self, args);
+      const logFn = self.log || createDebug.log;
+      logFn.apply(self, args);
+    }
+    debug.namespace = namespace;
+    debug.useColors = createDebug.useColors();
+    debug.color = createDebug.selectColor(namespace);
+    debug.extend = extend;
+    debug.destroy = createDebug.destroy;
+    Object.defineProperty(debug, "enabled", {
+      enumerable: true,
+      configurable: false,
+      get: () => {
+        if (enableOverride !== null) {
+          return enableOverride;
+        }
+        if (namespacesCache !== createDebug.namespaces) {
+          namespacesCache = createDebug.namespaces;
+          enabledCache = createDebug.enabled(namespace);
+        }
+        return enabledCache;
+      },
+      set: (v) => {
+        enableOverride = v;
+      }
+    });
+    if (typeof createDebug.init === "function") {
+      createDebug.init(debug);
+    }
+    return debug;
+  }
+  function extend(namespace, delimiter) {
+    const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+    newDebug.log = this.log;
+    return newDebug;
+  }
+  function enable(namespaces) {
+    createDebug.save(namespaces);
+    createDebug.namespaces = namespaces;
+    createDebug.names = [];
+    createDebug.skips = [];
+    const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+    for (const ns of split) {
+      if (ns[0] === "-") {
+        createDebug.skips.push(ns.slice(1));
+      } else {
+        createDebug.names.push(ns);
+      }
+    }
+  }
+  function matchesTemplate(search, template) {
+    let searchIndex = 0;
+    let templateIndex = 0;
+    let starIndex = -1;
+    let matchIndex = 0;
+    while (searchIndex < search.length) {
+      if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+        if (template[templateIndex] === "*") {
+          starIndex = templateIndex;
+          matchIndex = searchIndex;
+          templateIndex++;
+        } else {
+          searchIndex++;
+          templateIndex++;
+        }
+      } else if (starIndex !== -1) {
+        templateIndex = starIndex + 1;
+        matchIndex++;
+        searchIndex = matchIndex;
+      } else {
+        return false;
+      }
+    }
+    while (templateIndex < template.length && template[templateIndex] === "*") {
+      templateIndex++;
+    }
+    return templateIndex === template.length;
+  }
+  function disable() {
+    const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
+    createDebug.enable("");
+    return namespaces;
+  }
+  function enabled(name) {
+    for (const skip of createDebug.skips) {
+      if (matchesTemplate(name, skip)) {
+        return false;
+      }
+    }
+    for (const ns of createDebug.names) {
+      if (matchesTemplate(name, ns)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function coerce(val) {
+    if (val instanceof Error) {
+      return val.stack || val.message;
+    }
+    return val;
+  }
+  function destroy() {
+    console.warn(
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+  }
+  createDebug.enable(createDebug.load());
+  return createDebug;
+}
+var common_default = setup;
+
+// ../../shared/nodejs/src/log/logger.ts
+var BASIC_COLORS = [6, 2, 3, 4, 5, 1];
+var EXTENDED_COLORS = [
+  20,
+  21,
+  26,
+  27,
+  32,
+  33,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  56,
+  57,
+  62,
+  63,
+  68,
+  69,
+  74,
+  75,
+  76,
+  77,
+  78,
+  79,
+  80,
+  81,
+  92,
+  93,
+  98,
+  99,
+  112,
+  113,
+  128,
+  129,
+  134,
+  135,
+  148,
+  149,
+  160,
+  161,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  171,
+  172,
+  173,
+  178,
+  179,
+  184,
+  185,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  209,
+  214,
+  215,
+  220,
+  221
+];
+function supportsExtendedColors() {
+  try {
+    const supportsColor = require_supports_color();
+    return supportsColor && (supportsColor.stderr || supportsColor).level >= 2;
+  } catch {
+    return false;
+  }
+}
+function shouldUseColors() {
+  return false;
+}
+function formatArgs(args) {
+  const { namespace, useColors, color } = this;
+  if (useColors) {
+    const colorCode = color < 8 ? `3${color}` : `38;5;${color}`;
+    const prefix = `\x1B[${colorCode};1m${namespace}\x1B[0m`;
+    args[0] = `${prefix} ${args[0]}`.split("\n").join(`
+${prefix} `);
+    args.push(`\x1B[${colorCode}m+${humanizeTime(this.diff)}\x1B[0m`);
+  } else {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    args[0] = `${timestamp} ${namespace} ${args[0]}`;
+  }
+}
+function writeOutput(...args) {
+  process.stderr.write(util.format(...args) + "\n");
+}
+function saveConfig(namespaces) {
+  if (namespaces) {
+    process.env.DEBUG = namespaces;
+  } else {
+    delete process.env.DEBUG;
+  }
+}
+function loadConfig() {
+  return process.env.DEBUG;
+}
+function humanizeTime(milliseconds) {
+  if (milliseconds >= 1e3) {
+    const seconds = Math.round(milliseconds / 1e3);
+    return `${seconds}s`;
+  }
+  return `${milliseconds}ms`;
+}
+function createLoggerConfig() {
+  const colors = supportsExtendedColors() ? EXTENDED_COLORS : BASIC_COLORS;
+  return {
+    colors,
+    useColors: shouldUseColors,
+    formatArgs,
+    log: writeOutput,
+    save: saveConfig,
+    load: loadConfig,
+    humanize: humanizeTime
+  };
+}
+var config = createLoggerConfig();
+var logger = common_default(config);
+if (logger.formatters) {
+  logger.formatters.o = function(value) {
+    return util.inspect(value, { colors: this.useColors, compact: true }).split("\n").map((line) => line.trim()).join(" ");
+  };
+  logger.formatters.O = function(value) {
+    return util.inspect(value, { colors: this.useColors, compact: false });
+  };
+}
+var logger_default = logger;
+
+// ../../shared/nodejs/src/log/index.ts
+var log_default = logger_default;
+
+// ../../shared/nodejs/src/logger.ts
+var getFileLocation = () => {
+  let errorObject = new Error();
+  if (errorObject.stack === void 0) {
+    return "N/A";
+  }
+  let errorStack = errorObject.stack.split("\n");
+  for (let i = 1; i < errorStack.length; i++) {
+    if (!errorStack[i]?.includes("logger.js")) {
+      return errorStack[i]?.match(/(?<=\().+?(?=\))/g);
+    }
+  }
+  return "N/A";
+};
+var buildLogger = (pluginId, version, { fileLocation = true } = {}) => {
+  const namespace = `com.supertokens.plugin.${pluginId}`;
+  function logDebugMessage2(message) {
+    if (log_default.enabled(namespace)) {
+      log_default(namespace)(
+        `{t: "${(/* @__PURE__ */ new Date()).toISOString()}", message: "${message}", file: "${fileLocation ? getFileLocation() : "N/A"}" version: "${version}"}`
+      );
+      console.log();
+    }
+  }
+  function enableDebugLogs2() {
+    log_default.enable(namespace);
+  }
+  return {
+    logDebugMessage: logDebugMessage2,
+    enableDebugLogs: enableDebugLogs2
+  };
+};
+
+// src/plugin.ts
+import { createInstance } from "@rownd/node";
+import supertokens from "supertokens-node";
+
+// src/constants.ts
+var PLUGIN_ID = "supertokens-plugin-rownd";
+var PLUGIN_SDK_VERSION = ["23.0.0", "23.0.1", ">=23.0.1"];
+var HANDLE_BASE_PATH = "/plugin/rownd";
+var PUBLIC_TENANT_ID = "public";
+
+// src/logger.ts
+var { logDebugMessage, enableDebugLogs } = buildLogger(
+  PLUGIN_ID,
+  PLUGIN_SDK_VERSION
+);
+
+// src/plugin.ts
+import Session from "supertokens-node/recipe/session";
+
+// src/telemetry/axiomTelemetryClient.ts
+var DEFAULT_AXIOM_URL = "https://api.axiom.co/v1/datasets";
+var AxiomTelemetryClient = class {
+  constructor(token, dataset, endpoint) {
+    this.token = token;
+    this.dataset = dataset;
+    const baseUrl = (endpoint ?? DEFAULT_AXIOM_URL).replace(/\/$/, "");
+    this.url = `${baseUrl}/${dataset}/ingest`;
+  }
+  token;
+  dataset;
+  url;
+  async recordEvent(event) {
+    await fetch(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify([
+        {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          plugin: PLUGIN_ID,
+          ...event
+        }
+      ])
+    });
+  }
+};
+
+// src/telemetry/openTelemetryClient.ts
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+var OpenTelemetryClient = class {
+  recordEvent(event) {
+    const tracer = trace.getTracer("supertokens-plugin-rownd", "0.1.0");
+    const span = tracer.startSpan("rownd.migrate");
+    span.setAttributes({
+      "rownd.outcome": event.outcome,
+      "rownd.duration_ms": event.durationMs,
+      "rownd.tenant_id": event.tenantId ?? "",
+      "rownd.rownd_user_id": event.rowndUserId ?? "",
+      "rownd.supertokens_user_id": event.superTokensUserId ?? ""
+    });
+    if (event.outcome === "error") {
+      const err = new Error(event.error.message);
+      if (event.error.name) {
+        err.name = event.error.name;
+      }
+      span.recordException(err);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: event.error.message
+      });
+    } else {
+      span.setStatus({ code: SpanStatusCode.OK });
+    }
+    span.end();
+  }
+};
+
+// src/telemetry/createTelemetryClient.ts
+function createClient(telemetryConfig) {
+  let client;
+  if (telemetryConfig?.provider === "opentelemetry") {
+    client = new OpenTelemetryClient();
+  } else if (telemetryConfig?.provider === "axiom") {
+    client = new AxiomTelemetryClient(
+      telemetryConfig.token,
+      telemetryConfig.dataset,
+      telemetryConfig.url
+    );
+  } else if (telemetryConfig?.provider === "custom") {
+    client = telemetryConfig.factory();
+  }
+  return {
+    recordSuccess: (event) => {
+      if (!client) {
+        return;
+      }
+      safeRecordEvent(client, event, "success");
+    },
+    recordError: (input) => {
+      if (!client) {
+        return;
+      }
+      const event = {
+        outcome: "error",
+        durationMs: Date.now() - input.startedAt,
+        tenantId: input.tenantId,
+        rowndUserId: input.rowndUserId,
+        superTokensUserId: input.superTokensUserId,
+        error: {
+          message: input.error instanceof Error ? input.error.message : "Unknown error",
+          name: input.error instanceof Error ? input.error.name : void 0
+        }
+      };
+      safeRecordEvent(client, event, "error");
+    }
+  };
+}
+function safeRecordEvent(client, event, outcome) {
+  try {
+    Promise.resolve(client.recordEvent(event)).catch((error) => {
+      logDebugMessage(
+        `Failed to record telemetry ${outcome} event. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    });
+  } catch (error) {
+    logDebugMessage(
+      `Failed to record telemetry ${outcome} event. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/errors.ts
+var ROWND_PLUGIN_ERROR_MESSAGES = {
+  MISSING_AUTHORIZATION_HEADER: "Missing authorization header",
+  INVALID_TOKEN: "Invalid token",
+  ROWND_USER_NOT_FOUND: "User not found in Rownd"
+};
+var RowndPluginError = class extends Error {
+  constructor(type) {
+    super(ROWND_PLUGIN_ERROR_MESSAGES[type]);
+  }
+};
+
+// src/pluginImplementation.ts
+var rowndClient;
+function setRowndClient(client) {
+  rowndClient = client;
+}
+function getRowndClient() {
+  if (!rowndClient) {
+    throw new Error("Rownd client not initialized");
+  }
+  return rowndClient;
+}
+async function parseRequest(req) {
+  const authHeader = req.getHeaderValue("authorization");
+  if (!authHeader) {
+    throw new RowndPluginError("MISSING_AUTHORIZATION_HEADER");
+  }
+  const token = authHeader.replace(/^Bearer /i, "");
+  if (!token) {
+    throw new RowndPluginError("INVALID_TOKEN");
+  }
+  return {
+    token
+  };
+}
+function mapRowndUserToSuperTokens(rowndUser) {
+  const loginMethods = [];
+  const rowndUserData = rowndUser.data || {};
+  const rowndUserVerifiedData = rowndUser.verified_data || {};
+  if (!rowndUserData.user_id) {
+    throw new Error("Rownd user has no user_id");
+  }
+  if (rowndUserData.google_id) {
+    if (!rowndUserData.email) {
+      throw new Error("Rownd Google user is missing email");
+    }
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId: "google",
+      thirdPartyUserId: rowndUserData.google_id,
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.google_id
+    });
+  }
+  if (rowndUserData.apple_id) {
+    if (!rowndUserData.email) {
+      throw new Error("Rownd Apple user is missing email");
+    }
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId: "apple",
+      thirdPartyUserId: rowndUserData.apple_id,
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.apple_id
+    });
+  }
+  if (rowndUserData.phone_number) {
+    loginMethods.push({
+      recipeId: "passwordless",
+      phoneNumber: rowndUserData.phone_number,
+      isVerified: !!rowndUserVerifiedData.phone_number
+    });
+  }
+  if (rowndUserData.email && loginMethods.length === 0) {
+    loginMethods.push({
+      recipeId: "passwordless",
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.email
+    });
+  }
+  if (loginMethods.length === 0) {
+    throw new Error("No valid login methods found in Rownd user data");
+  }
+  const rowndUserMeta = rowndUser.meta || {};
+  const rowndUserAttributes = rowndUser.attributes || {};
+  const userMetadata = {
+    data: {
+      ...rowndUserData
+    },
+    meta: {
+      ...rowndUserMeta
+    },
+    verified_data: {
+      ...rowndUserVerifiedData
+    },
+    attributes: {
+      ...rowndUserAttributes
+    },
+    rownd_migrated: true,
+    rownd_user_id: rowndUserData.user_id
+  };
+  return {
+    externalUserId: rowndUserData.user_id,
+    loginMethods,
+    userMetadata
+  };
+}
+async function importUser(stUser, config2) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config2.apiKey) {
+    headers["api-key"] = config2.apiKey;
+  }
+  const response = await fetch(`${config2.connectionURI}/bulk-import/import`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(stUser)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Bulk import failed with status ${response.status}: ${errorText}`
+    );
+  }
+  const importResponse = await response.json();
+  if (importResponse.status !== "OK" || !importResponse.user) {
+    throw new Error(
+      `Bulk import failed: ${importResponse.message || "Missing user in response"}`
+    );
+  }
+  return importResponse.user;
+}
+async function validateRowndToken(token) {
+  const client = getRowndClient();
+  const tokenInfo = await client.validateToken(token);
+  return tokenInfo.user_id;
+}
+async function fetchRowndUserInfo(userId) {
+  const client = getRowndClient();
+  const rowndUser = await client.fetchUserInfo({ user_id: userId });
+  if (!rowndUser) {
+    throw new RowndPluginError("ROWND_USER_NOT_FOUND");
+  }
+  return rowndUser;
+}
+
+// src/plugin.ts
+var init = createPluginInitFunction(
+  (config2) => {
+    const rowndClient2 = createInstance({
+      app_key: config2.rowndAppKey,
+      app_secret: config2.rowndAppSecret
+    });
+    const telemetryClient = createClient(config2.telemetry);
+    setRowndClient(rowndClient2);
+    if (config2.enableDebugLogs) {
+      enableDebugLogs();
+    }
+    logDebugMessage("Rownd plugin init complete");
+    return {
+      id: PLUGIN_ID,
+      compatibleSDKVersions: PLUGIN_SDK_VERSION,
+      init: async () => {
+        if (!supertokens.isRecipeInitialized("session")) {
+          console.warn(
+            "RowndMigrationPlugin: Session recipe is not initialized. Session migration will fail."
+          );
+        }
+      },
+      routeHandlers(config3) {
+        const apiBasePath = config3.appInfo.apiBasePath.getAsStringDangerous();
+        return {
+          status: "OK",
+          routeHandlers: [
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/migrate`,
+              method: "post",
+              handler: withRequestHandler(
+                async (req, res, _session, userContext) => {
+                  const startedAt = Date.now();
+                  let tenantId = PUBLIC_TENANT_ID;
+                  let rowndUserId;
+                  let superTokensUserId;
+                  let user;
+                  let recipeUserId;
+                  try {
+                    if (!config3.supertokens) {
+                      throw new Error("Supertokens config not found");
+                    }
+                    const parsed = await parseRequest(req);
+                    rowndUserId = await validateRowndToken(parsed.token);
+                    user = await supertokens.getUser(rowndUserId, userContext);
+                    if (!user) {
+                      const rowndUser = await fetchRowndUserInfo(rowndUserId);
+                      const stUserImport = mapRowndUserToSuperTokens(rowndUser);
+                      const importedUser = await importUser(
+                        stUserImport,
+                        config3.supertokens
+                      );
+                      superTokensUserId = importedUser.id;
+                      if (importedUser.loginMethods[0]?.recipeUserId) {
+                        recipeUserId = supertokens.convertToRecipeUserId(
+                          importedUser.loginMethods[0].recipeUserId
+                        );
+                      }
+                      logDebugMessage(
+                        `User migrated successfully. tenantId: ${PUBLIC_TENANT_ID}, rowndUserId: ${rowndUserId}`
+                      );
+                    } else {
+                      superTokensUserId = user.id;
+                      recipeUserId = user.loginMethods[0]?.recipeUserId;
+                      logDebugMessage(
+                        `User already migrated. tenantId: ${PUBLIC_TENANT_ID}, rowndUserId: ${rowndUserId}`
+                      );
+                    }
+                    if (!recipeUserId) {
+                      throw new Error("User not found or has no login methods");
+                    }
+                    await Session.createNewSession(
+                      req,
+                      res,
+                      PUBLIC_TENANT_ID,
+                      recipeUserId,
+                      {},
+                      {},
+                      userContext
+                    );
+                    logDebugMessage(
+                      `Session migrated successfully. tenantId: ${PUBLIC_TENANT_ID}, userId: ${superTokensUserId}`
+                    );
+                    telemetryClient.recordSuccess({
+                      outcome: "success",
+                      durationMs: Date.now() - startedAt,
+                      tenantId,
+                      rowndUserId,
+                      superTokensUserId
+                    });
+                    return { status: "OK" };
+                  } catch (error) {
+                    logDebugMessage(
+                      `Migration failed. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+                    );
+                    telemetryClient.recordError({
+                      error,
+                      startedAt,
+                      tenantId,
+                      rowndUserId,
+                      superTokensUserId
+                    });
+                    return {
+                      status: "ERROR",
+                      message: error instanceof RowndPluginError ? error.message : "Migration failed"
+                    };
+                  }
+                }
+              )
+            }
+          ]
+        };
+      }
+    };
+  },
+  () => ({}),
+  (config2) => {
+    if (!config2?.rowndAppKey || !config2?.rowndAppSecret) {
+      throw new Error("Missing rowndAppKey or rowndAppSecret in plugin config");
+    }
+    if (config2.telemetry?.provider === "axiom") {
+      if (!config2.telemetry.token || !config2.telemetry.dataset) {
+        throw new Error(
+          "Missing telemetry axiom token or dataset in plugin config"
+        );
+      }
+    }
+    if (config2.telemetry?.provider === "custom") {
+      if (typeof config2.telemetry.factory !== "function") {
+        throw new Error(
+          "Missing telemetry custom factory function in plugin config"
+        );
+      }
+    }
+    return {
+      rowndAppKey: config2.rowndAppKey,
+      rowndAppSecret: config2.rowndAppSecret,
+      enableDebugLogs: config2.enableDebugLogs,
+      telemetry: config2.telemetry
+    };
+  }
+);
+
+// src/index.ts
+var index_default = { init };
+export {
+  HANDLE_BASE_PATH,
+  PLUGIN_ID,
+  PLUGIN_SDK_VERSION,
+  PUBLIC_TENANT_ID,
+  ROWND_PLUGIN_ERROR_MESSAGES,
+  RowndPluginError,
+  index_default as default,
+  init
+};