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

package/dist/initConfig.js

@@ -0,0 +1,136 @@
+#!/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 __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
+));
+
+// scripts/initConfig.ts
+var fs = __toESM(require("fs/promises"));
+var import_node_path = require("path");
+var BULK_MIGRATE_CONFIG_TEMPLATE = `# Maximum number of users to process. Remove this field to process everything.
+limit: 100
+
+checkpoint:
+  # File used to persist migration progress so a later run can resume.
+  file: ./rownd-migration-checkpoint.json
+  # When true, continue from the saved checkpoint instead of starting over.
+  resume: false
+
+retry:
+  # Number of attempts for retryable HTTP failures such as 429 and 5xx.
+  maxAttempts: 5
+  # Base backoff delay in milliseconds before exponential retry waits.
+  initialDelayMs: 500
+
+rownd:
+  appId: <APP_ID>
+  appKey: <APP_KEY>
+  appSecret: <APP_SECRET>
+  # Required when using generate-plugin-config --include-sub-brands.
+  # bearerToken: <ROWND_API_BEARER_TOKEN>
+  # Number of Rownd users to request per page.
+  pageSize: 100
+
+supertokens:
+  connectionURI: <CONNECTION_URI>
+  apiKey: <API_KEY>
+  # Number of users to send to SuperTokens per bulk import request.
+  batchSize: 500
+`;
+function printHelp() {
+  console.log(`Usage: rownd-nodejs init-config --output <path> [options]
+
+Options:
+  --type <type>      Config template type. Only "bulk-migrate" is supported.
+  -o, --output <path>  Destination path for the config file
+  --force            Overwrite the destination if it already exists
+  -h, --help         Show this help message`);
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    type: "bulk-migrate",
+    output: "",
+    force: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      return void 0;
+    }
+    if (arg === "--type") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error("Missing value for --type");
+      }
+      options.type = value;
+      i += 1;
+    } else if (arg === "--output" || arg === "-o") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      options.output = value;
+      i += 1;
+    } else if (arg === "--force") {
+      options.force = true;
+    } else {
+      throw new Error(`Unknown or incomplete argument: ${arg}`);
+    }
+  }
+  if (options.type !== "bulk-migrate") {
+    throw new Error('Only "bulk-migrate" config templates are supported.');
+  }
+  if (!options.output) {
+    throw new Error("Missing required --output <path>");
+  }
+  return options;
+}
+async function fileExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function run() {
+  const options = parseArgs();
+  if (!options) {
+    return;
+  }
+  const outputPath = (0, import_node_path.resolve)(options.output);
+  if (!options.force && await fileExists(outputPath)) {
+    throw new Error(`${outputPath} already exists. Use --force to overwrite it.`);
+  }
+  await fs.mkdir((0, import_node_path.dirname)(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, BULK_MIGRATE_CONFIG_TEMPLATE, {
+    encoding: "utf8",
+    flag: options.force ? "w" : "wx"
+  });
+  console.log(`Wrote bulk migration config template to ${outputPath}`);
+}
+run().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/dist/setupCoreInstance.js

@@ -0,0 +1,295 @@
+#!/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 __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);
+
+// scripts/setupCoreInstance.ts
+var setupCoreInstance_exports = {};
+__export(setupCoreInstance_exports, {
+  fetchRowndOidcClients: () => fetchRowndOidcClients,
+  provisionSuperTokensInfrastructure: () => provisionSuperTokensInfrastructure,
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(setupCoreInstance_exports);
+var import_zod2 = require("zod");
+
+// 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 loadConfig(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");
+}
+
+// scripts/setupCoreInstance.ts
+function printHelp() {
+  console.log(`Usage: rownd-nodejs setup-core --config <path>
+
+Options:
+  -c, --config <path>  Path to the bulk migration config file
+  -h, --help           Show this help message`);
+}
+async function provisionSuperTokensInfrastructure(config, oidcClients) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.supertokens.apiKey) {
+    headers["api-key"] = config.supertokens.apiKey;
+  }
+  for (const oidcClient of oidcClients) {
+    for (const credential of oidcClient.credentials ?? []) {
+      console.log(
+        `Provisioning SuperTokens OAuth2 Client: ${credential.client_id}`
+      );
+      const oauthRes = await fetch(
+        new URL(
+          "/recipe/oauth/clients",
+          config.supertokens.connectionURI
+        ).toString(),
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            clientName: oidcClient.name || credential.client_id || "Rownd Client",
+            clientId: credential.client_id,
+            clientSecret: credential.secret,
+            redirectUris: oidcClient.config.redirect_uris || [],
+            postLogoutRedirectUris: oidcClient.config.post_logout_uris || [],
+            scope: oidcClient.config.allowed_scopes?.join(" "),
+            responseTypes: ["code", "token", "id_token"],
+            grantTypes: [
+              "authorization_code",
+              "refresh_token",
+              "client_credentials",
+              "implicit"
+            ],
+            tokenEndpointAuthMethod: "client_secret_post"
+          })
+        }
+      );
+      if (!oauthRes.ok) {
+        const errorText = await oauthRes.text();
+        if (!errorText.includes("already exists") && !errorText.includes("Duplicate")) {
+          throw new Error(
+            `Failed to create OAuth2 Client ${credential.client_id}: ${oauthRes.status} ${errorText}`
+          );
+        }
+      }
+    }
+  }
+}
+var RowndOidcClientSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  config: import_zod2.z.object({
+    redirect_uris: import_zod2.z.array(import_zod2.z.string()).optional(),
+    post_logout_uris: import_zod2.z.array(import_zod2.z.string()).optional(),
+    allowed_scopes: import_zod2.z.array(import_zod2.z.string()).optional()
+  }),
+  credentials: import_zod2.z.array(
+    import_zod2.z.object({
+      client_id: import_zod2.z.string(),
+      secret: import_zod2.z.string().optional(),
+      app_variant_id: import_zod2.z.string().optional()
+    })
+  ).optional()
+});
+async function fetchRowndOidcClients(config) {
+  const url = new URL(
+    `/api/applications/${config.rownd.appId}/oidc-clients`,
+    "https://app.rownd.io"
+  );
+  const response = await fetch(url.toString(), {
+    headers: {
+      "x-rownd-app-key": config.rownd.appKey,
+      "x-rownd-app-secret": config.rownd.appSecret
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Rownd API error: ${response.status} ${await response.text()}`
+    );
+  }
+  const page = import_zod2.z.object({ results: import_zod2.z.array(RowndOidcClientSchema) }).parse(await response.json());
+  return page.results;
+}
+async function runCli() {
+  const args = process.argv.slice(2);
+  if (hasHelpArg(args)) {
+    printHelp();
+    return;
+  }
+  const config = await loadConfig(parseRequiredConfigArg(args));
+  const oidcClients = await fetchRowndOidcClients(config);
+  await provisionSuperTokensInfrastructure(config, oidcClients);
+  console.log("Successfully provisioned SuperTokens infrastructure.");
+}
+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 : "Provisioning failed"
+      );
+    }
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchRowndOidcClients,
+  provisionSuperTokensInfrastructure,
+  runCli
+});

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@supertokens-plugins/rownd-nodejs",
-  "version": "0.2.0",
+  "version": "0.3.0-beta.0",
   "description": "Rownd User Migration Plugin for SuperTokens",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "rownd-nodejs": "./dist/cli.js"
+  },
   "files": [
-    "dist",
-    "src",
-    "scripts"
+    "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "bulk-import": "tsx scripts/bulkMigrate.ts",
+    "build": "rm -rf dist && tsup",
+    "cli": "npm run build && node dist/cli.js",
+    "migrate-local-then-managed": "tsx scripts/migrateLocalThenManaged.ts",
+    "diff-users": "tsx scripts/diffUsers.ts",
     "lint": "eslint ./src --ext .ts",
     "test": "TEST_MODE=testing vitest run --pool=forks"
   },
@@ -25,7 +28,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@rownd/node": "^3.0.4"
+    "@rownd/node": "^3.0.4",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
     "supertokens-node": ">=23.0.0"
@@ -40,9 +45,7 @@
     "tsup": "^8.0.2",
     "tsx": "^4.21.0",
     "typescript": "^5.7.3",
-    "vitest": "^1.3.1",
-    "yaml": "^2.8.3",
-    "zod": "^4.3.6"
+    "vitest": "^1.3.1"
   },
   "publishConfig": {
     "access": "public"