@supertokens-plugins/rownd-nodejs 0.2.0 → 0.3.0-beta.0

package/dist/bulkMigrate.js

@@ -0,0 +1,1096 @@
+#!/usr/bin/env node
+"use strict";
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports2, module2) {
+    "use strict";
+    module2.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"(exports2, module2) {
+    "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);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// scripts/bulkMigrate.ts
+var bulkMigrate_exports = {};
+__export(bulkMigrate_exports, {
+  migrateRowndUsersToSuperTokens: () => migrateRowndUsersToSuperTokens,
+  runCli: () => runCli,
+  stageUsersForImport: () => stageUsersForImport
+});
+module.exports = __toCommonJS(bulkMigrate_exports);
+var fs2 = __toESM(require("fs/promises"));
+var import_zod2 = require("zod");
+
+// src/pluginImplementation.ts
+var import_supertokens_node = __toESM(require("supertokens-node"));
+var import_accountlinking = __toESM(require("supertokens-node/recipe/accountlinking"));
+var import_emailverification = __toESM(require("supertokens-node/recipe/emailverification"));
+var import_passwordless = __toESM(require("supertokens-node/recipe/passwordless"));
+var import_session = __toESM(require("supertokens-node/recipe/session"));
+var import_claims = require("supertokens-node/recipe/session/claims");
+var import_thirdparty = __toESM(require("supertokens-node/recipe/thirdparty"));
+var import_usermetadata2 = __toESM(require("supertokens-node/recipe/usermetadata"));
+
+// src/constants.ts
+var PLUGIN_ID = "supertokens-plugin-rownd";
+var PLUGIN_SDK_VERSION = ["23.0.0", "23.0.1", ">=23.0.1"];
+var GUEST_AUTH_METHOD_ID = "guest";
+var ANONYMOUS_AUTH_METHOD_ID = "anonymous";
+
+// ../../shared/nodejs/src/pluginUserMetadata.ts
+var import_usermetadata = __toESM(require("supertokens-node/recipe/usermetadata"));
+
+// ../../shared/nodejs/src/log/logger.ts
+var import_util = __toESM(require("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(import_util.default.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 import_util.default.inspect(value, { colors: this.useColors, compact: true }).split("\n").map((line) => line.trim()).join(" ");
+  };
+  logger.formatters.O = function(value) {
+    return import_util.default.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/logger.ts
+var { logDebugMessage, enableDebugLogs } = buildLogger(
+  PLUGIN_ID,
+  PLUGIN_SDK_VERSION
+);
+
+// src/pluginImplementation.ts
+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 && !rowndUserData.google_id && !rowndUserData.apple_id) {
+    loginMethods.push({
+      recipeId: "passwordless",
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.email
+    });
+  }
+  let authLevel = rowndUser.auth_level;
+  if (loginMethods.length === 0) {
+    const thirdPartyId = authLevel === GUEST_AUTH_METHOD_ID ? GUEST_AUTH_METHOD_ID : ANONYMOUS_AUTH_METHOD_ID;
+    if (!authLevel) authLevel = thirdPartyId;
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId,
+      thirdPartyUserId: rowndUserData.user_id,
+      email: `${rowndUserData.user_id}@anonymous.local`,
+      isVerified: false
+    });
+  }
+  const userMetadata = buildRowndUserMetadata(rowndUser);
+  return {
+    externalUserId: rowndUserData.user_id,
+    loginMethods,
+    userMetadata
+  };
+}
+var IDENTITY_USER_DATA_FIELDS = /* @__PURE__ */ new Set([
+  "user_id",
+  "email",
+  "phone_number",
+  "google_id",
+  "apple_id"
+]);
+function isIdentityField(field) {
+  return IDENTITY_USER_DATA_FIELDS.has(field);
+}
+function buildRowndUserMetadata(rowndUser) {
+  const metadata = {
+    ...rowndUser.meta || {},
+    original_rownd_user: rowndUser
+  };
+  for (const [key, value] of Object.entries(rowndUser.data || {})) {
+    if (!isIdentityField(key) && value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  return metadata;
+}
+var RowndIsAnonymousClaim = new import_claims.BooleanClaim({
+  key: "is_anonymous",
+  fetchValue: async (userId) => {
+    const user = await import_supertokens_node.default.getUser(userId);
+    const effectiveAuthLevel = getEffectiveAuthLevel(user);
+    return effectiveAuthLevel === GUEST_AUTH_METHOD_ID;
+  }
+});
+function getThirdPartyId(method) {
+  return method.thirdPartyId || method.thirdParty?.id;
+}
+function getThirdPartyUserId(method) {
+  return method.thirdPartyUserId || method.thirdParty?.userId;
+}
+function getGuestAuthLevel(user) {
+  const guestMethod = user?.loginMethods.find(isGuestLoginMethod);
+  return guestMethod ? GUEST_AUTH_METHOD_ID : void 0;
+}
+function isGuestLoginMethod(method) {
+  const thirdPartyId = getThirdPartyId(method);
+  return method.recipeId === "thirdparty" && (thirdPartyId === GUEST_AUTH_METHOD_ID || thirdPartyId === ANONYMOUS_AUTH_METHOD_ID);
+}
+function hasVerifiedRealLoginMethod(user) {
+  return !!user?.loginMethods.some((method) => {
+    if (isGuestLoginMethod(method)) {
+      return false;
+    }
+    if (method.recipeId === "passwordless") {
+      return !!(method.email || method.phoneNumber);
+    }
+    if (method.recipeId === "thirdparty") {
+      return !!getThirdPartyUserId(method) && method.verified === true;
+    }
+    if (method.recipeId === "emailpassword") {
+      return !!method.email && method.verified === true;
+    }
+    return method.verified === true;
+  });
+}
+function getEffectiveAuthLevel(user, originalAuthLevel, verifiedData) {
+  if (hasVerifiedRealLoginMethod(user)) {
+    return "verified";
+  }
+  return getGuestAuthLevel(user) || originalAuthLevel || (verifiedData && Object.keys(verifiedData).length > 0 ? "verified" : "unverified");
+}
+
+// scripts/scriptUtils.ts
+var fs = __toESM(require("fs/promises"));
+var import_node_path = require("path");
+var import_yaml = require("yaml");
+var import_zod = require("zod");
+var SCRIPT_DIR = __dirname;
+var ConfigSchema = import_zod.z.object({
+  limit: import_zod.z.preprocess(
+    (value) => value === void 0 ? Number.POSITIVE_INFINITY : value,
+    import_zod.z.union([import_zod.z.literal(Number.POSITIVE_INFINITY), import_zod.z.number().int().positive()])
+  ),
+  checkpoint: import_zod.z.object({
+    file: import_zod.z.string(),
+    resume: import_zod.z.boolean().default(false)
+  }),
+  retry: import_zod.z.object({
+    maxAttempts: import_zod.z.number().int().positive(),
+    initialDelayMs: import_zod.z.number().int().positive()
+  }),
+  rownd: import_zod.z.object({
+    appId: import_zod.z.string(),
+    appKey: import_zod.z.string(),
+    appSecret: import_zod.z.string(),
+    bearerToken: import_zod.z.string().optional(),
+    pageSize: import_zod.z.number().int().positive()
+  }),
+  supertokens: import_zod.z.object({
+    connectionURI: import_zod.z.string(),
+    apiKey: import_zod.z.string().optional(),
+    batchSize: import_zod.z.number().int().positive()
+  }),
+  thirdPartyProviders: import_zod.z.array(
+    import_zod.z.object({
+      thirdPartyId: import_zod.z.string(),
+      name: import_zod.z.string().optional(),
+      clients: import_zod.z.array(
+        import_zod.z.object({
+          clientType: import_zod.z.string().optional(),
+          clientId: import_zod.z.string(),
+          clientSecret: import_zod.z.string().optional(),
+          scope: import_zod.z.array(import_zod.z.string()).optional()
+        })
+      )
+    })
+  ).optional()
+});
+var RowndUserRecordSchema = import_zod.z.looseObject({
+  user_id: import_zod.z.string().optional(),
+  rownd_user: import_zod.z.string().optional(),
+  subject: import_zod.z.string().optional(),
+  state: import_zod.z.string().optional(),
+  auth_level: import_zod.z.string().optional(),
+  data: import_zod.z.looseObject({
+    user_id: import_zod.z.string(),
+    email: import_zod.z.string().optional(),
+    phone_number: import_zod.z.string().optional(),
+    google_id: import_zod.z.string().optional(),
+    apple_id: import_zod.z.string().optional(),
+    first_name: import_zod.z.string().optional(),
+    last_name: import_zod.z.string().optional()
+  }),
+  verified_data: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({}),
+  attributes: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.string())).optional(),
+  groups: import_zod.z.array(import_zod.z.unknown()).optional(),
+  meta: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  connection_map: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var RowndUserListItemSchema = import_zod.z.object({
+  data: RowndUserRecordSchema
+});
+var RowndUsersPageSchema = import_zod.z.object({
+  results: import_zod.z.array(RowndUserRecordSchema).optional(),
+  data: import_zod.z.array(RowndUserListItemSchema).optional(),
+  total_results: import_zod.z.number().optional()
+}).superRefine((value, context) => {
+  if (!value.results && !value.data) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "Rownd API response is missing a results/data array."
+    });
+  }
+});
+function formatIssuePath(path) {
+  if (path.length === 0) {
+    return "<root>";
+  }
+  return path.map((segment, index) => {
+    if (typeof segment === "number") {
+      return `[${segment}]`;
+    }
+    return index === 0 ? segment : `.${segment}`;
+  }).join("");
+}
+function formatZodError(error) {
+  return error.issues.map(
+    (issue) => `${formatIssuePath(issue.path.filter((segment) => typeof segment === "string" || typeof segment === "number"))}: ${issue.message}`
+  ).join("\n");
+}
+function parseConfig(rawConfig, configDir = SCRIPT_DIR) {
+  const parsed = ConfigSchema.parse(rawConfig);
+  const checkpointFile = (0, import_node_path.isAbsolute)(parsed.checkpoint.file) ? parsed.checkpoint.file : (0, import_node_path.resolve)(configDir, parsed.checkpoint.file);
+  return {
+    limit: parsed.limit,
+    checkpoint: {
+      file: checkpointFile,
+      resume: parsed.checkpoint.resume
+    },
+    retry: parsed.retry,
+    rownd: parsed.rownd,
+    supertokens: parsed.supertokens,
+    thirdPartyProviders: parsed.thirdPartyProviders
+  };
+}
+async function loadConfig2(configFilePath) {
+  const configFile = await fs.readFile(configFilePath, "utf8");
+  return parseConfig((0, import_yaml.parse)(configFile), (0, import_node_path.dirname)(configFilePath));
+}
+function parseRequiredConfigArg(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--config" || arg === "-c") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      return (0, import_node_path.resolve)(value);
+    }
+  }
+  throw new Error("Missing required --config <path>");
+}
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function parseRowndUser(parsed) {
+  const rowndUserId = parsed.data.user_id;
+  const rowndUser = {
+    state: parsed.state ?? "",
+    auth_level: parsed.auth_level ?? "",
+    data: {
+      ...parsed.data,
+      user_id: rowndUserId
+    },
+    verified_data: parsed.verified_data ?? {},
+    attributes: parsed.attributes,
+    groups: parsed.groups,
+    meta: parsed.meta
+  };
+  return { rowndUser, rowndUserId };
+}
+async function fetchRowndUsersPage(config2, cursor, pageSize) {
+  const url = new URL(
+    `/applications/${config2.rownd.appId}/users/data`,
+    "https://api.rownd.io"
+  );
+  if (cursor) {
+    url.searchParams.set("after", cursor);
+  }
+  url.searchParams.set("include_duplicates", "true");
+  url.searchParams.set("page_size", String(pageSize ?? config2.rownd.pageSize));
+  const response = await fetchWithRetry({
+    url: url.toString(),
+    requestInit: {
+      headers: {
+        "x-rownd-app-key": config2.rownd.appKey,
+        "x-rownd-app-secret": config2.rownd.appSecret
+      }
+    },
+    retryConfig: config2.retry,
+    operation: "Fetching Rownd users"
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Rownd API error: ${response.status} ${await response.text()}`
+    );
+  }
+  const page = RowndUsersPageSchema.parse(await response.json());
+  const users = page.data?.map((entry) => entry.data) ?? page.results ?? [];
+  return users.map(parseRowndUser);
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+async function fetchWithRetry({
+  url,
+  requestInit,
+  retryConfig,
+  operation
+}) {
+  let lastError;
+  for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, requestInit);
+      if (response.ok || !isRetryableStatus(response.status) || attempt === retryConfig.maxAttempts) {
+        return response;
+      }
+      const responseText = await response.text();
+      lastError = new Error(
+        `${operation} failed with ${response.status}${responseText ? ` ${responseText}` : ""}`
+      );
+    } catch (error) {
+      if (attempt === retryConfig.maxAttempts) {
+        throw error;
+      }
+      lastError = error instanceof Error ? error : new Error(`${operation} failed`);
+    }
+    const delayMs = Math.round(
+      retryConfig.initialDelayMs * 2 ** (attempt - 1) * (1 + Math.random() * 0.2)
+    );
+    console.log(
+      `${operation} attempt ${attempt} failed. Retrying in ${delayMs}ms.`
+    );
+    await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+  }
+  throw lastError ?? new Error(`${operation} failed`);
+}
+
+// scripts/bulkMigrate.ts
+function printHelp() {
+  console.log(`Usage: rownd-nodejs bulk-migrate --config <path>
+
+Options:
+  -c, --config <path>  Path to the bulk migration config file
+  -h, --help           Show this help message`);
+}
+var CheckpointSchema = import_zod2.z.object({
+  cursor: import_zod2.z.string().optional(),
+  importedCount: import_zod2.z.number().int().nonnegative().optional(),
+  updatedAt: import_zod2.z.string()
+});
+async function loadCheckpoint(checkpointFile) {
+  try {
+    const checkpoint = await fs2.readFile(checkpointFile, "utf8");
+    return CheckpointSchema.parse(JSON.parse(checkpoint));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function saveCheckpoint(checkpointFile, checkpoint) {
+  const tempFile = `${checkpointFile}.tmp`;
+  await fs2.writeFile(tempFile, JSON.stringify(checkpoint, null, 2), "utf8");
+  await fs2.rename(tempFile, checkpointFile);
+}
+function getFailedMappingsFilePath(checkpointFile) {
+  return `${checkpointFile}.failed-mappings.json`;
+}
+async function loadFailedMappings(filePath) {
+  try {
+    const contents = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(contents);
+    if (!Array.isArray(parsed)) {
+      throw new Error("Failed mappings file must contain a JSON array.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function appendFailedMappings(filePath, failedMappings) {
+  if (failedMappings.length === 0) {
+    return;
+  }
+  const existingMappings = await loadFailedMappings(filePath);
+  const tempFile = `${filePath}.tmp`;
+  await fs2.writeFile(
+    tempFile,
+    JSON.stringify([...existingMappings, ...failedMappings], null, 2),
+    "utf8"
+  );
+  await fs2.rename(tempFile, filePath);
+}
+async function stageUsersForImport(config2) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config2.supertokens.apiKey) {
+    headers["api-key"] = config2.supertokens.apiKey;
+  }
+  const response = await fetchWithRetry({
+    url: new URL(
+      "/bulk-import/users",
+      config2.supertokens.connectionURI
+    ).toString(),
+    requestInit: {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ users: config2.users })
+    },
+    retryConfig: config2.retry,
+    operation: "Importing users into SuperTokens"
+  });
+  if (!response.ok) {
+    throw new Error(
+      `SuperTokens bulk import error: ${response.status} ${await response.text()}`
+    );
+  }
+}
+async function importUsersBatch(config2, users, totalImportedBeforeBatch) {
+  for (let index = 0; index < users.length; index += config2.supertokens.batchSize) {
+    const batch = users.slice(index, index + config2.supertokens.batchSize);
+    console.log(
+      `Importing batch ${Math.floor(totalImportedBeforeBatch / config2.supertokens.batchSize) + 1} (${batch.length} users)`
+    );
+    await stageUsersForImport({
+      users: batch.map((entry) => entry.user),
+      supertokens: config2.supertokens,
+      retry: config2.retry
+    });
+  }
+}
+async function migrateRowndUsersToSuperTokens(config2) {
+  const checkpoint = config2.checkpoint.resume ? await loadCheckpoint(config2.checkpoint.file) : null;
+  const failedMappingsFile = getFailedMappingsFilePath(config2.checkpoint.file);
+  let cursor = checkpoint?.cursor;
+  let totalProcessed = 0;
+  let totalImported = checkpoint?.importedCount ?? 0;
+  let totalSkipped = 0;
+  if (config2.checkpoint.resume) {
+    console.log(
+      checkpoint ? `Resuming migration from cursor ${checkpoint.cursor ?? "<start>"}` : "No checkpoint found. Starting a fresh migration."
+    );
+  }
+  while (totalProcessed < config2.limit) {
+    const remaining = Number.isFinite(config2.limit) ? Math.max(config2.limit - totalProcessed, 0) : config2.rownd.pageSize;
+    const requestedPageSize = Number.isFinite(config2.limit) ? Math.min(config2.rownd.pageSize, remaining) : config2.rownd.pageSize;
+    if (requestedPageSize === 0) {
+      break;
+    }
+    console.log(
+      `Fetching page ${Math.floor(totalProcessed / config2.rownd.pageSize) + 1}`
+    );
+    const pageUsers = await fetchRowndUsersPage(
+      config2,
+      cursor,
+      requestedPageSize
+    );
+    if (pageUsers.length === 0) {
+      break;
+    }
+    const mappedUsers = [];
+    const failedMappings = [];
+    for (const { rowndUser, rowndUserId } of pageUsers) {
+      try {
+        mappedUsers.push({
+          rowndUserId,
+          user: mapRowndUserToSuperTokens(rowndUser)
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown mapping error";
+        failedMappings.push({
+          user: rowndUser,
+          error: errorMessage
+        });
+        console.warn(
+          `Skipping Rownd user ${rowndUserId}: ${errorMessage}. Saved to ${failedMappingsFile}`
+        );
+      }
+    }
+    await appendFailedMappings(failedMappingsFile, failedMappings);
+    totalSkipped += failedMappings.length;
+    await importUsersBatch(config2, mappedUsers, totalImported);
+    totalProcessed += pageUsers.length;
+    totalImported += mappedUsers.length;
+    cursor = pageUsers[pageUsers.length - 1]?.rowndUserId;
+    await saveCheckpoint(config2.checkpoint.file, {
+      cursor,
+      importedCount: totalImported,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log(`Processed ${totalProcessed} users so far`);
+    console.log(`Imported ${totalImported} users so far`);
+    if (pageUsers.length < requestedPageSize) {
+      break;
+    }
+  }
+  return {
+    totalProcessed,
+    totalImported,
+    totalSkipped,
+    cursor
+  };
+}
+async function runCli() {
+  const args = process.argv.slice(2);
+  if (hasHelpArg(args)) {
+    printHelp();
+    return;
+  }
+  const config2 = await loadConfig2(parseRequiredConfigArg(args));
+  const result = await migrateRowndUsersToSuperTokens(config2);
+  console.log(`Migrated ${result.totalImported} users`);
+  if (result.totalSkipped > 0) {
+    console.warn(
+      `Skipped ${result.totalSkipped} users. Details saved to ${getFailedMappingsFilePath(config2.checkpoint.file)}`
+    );
+  }
+}
+if (require.main === module) {
+  runCli().catch((error) => {
+    if (error instanceof import_zod2.z.ZodError) {
+      console.error(formatZodError(error));
+    } else {
+      console.error(
+        error instanceof Error ? error.message : "Bulk migration failed"
+      );
+    }
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  migrateRowndUsersToSuperTokens,
+  runCli,
+  stageUsersForImport
+});