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

package/src/plugin.ts

@@ -1,189 +0,0 @@
-import { SuperTokensPlugin } from "supertokens-node/types";
-import { createPluginInitFunction } from "@shared/js";
-import { withRequestHandler } from "@shared/nodejs";
-import { createInstance } from "@rownd/node";
-import supertokens from "supertokens-node";
-import {
-  PLUGIN_ID,
-  PLUGIN_SDK_VERSION,
-  HANDLE_BASE_PATH,
-  PUBLIC_TENANT_ID,
-} from "./constants";
-import { RowndPluginConfig, RowndPluginNormalisedConfig } from "./types";
-import { enableDebugLogs, logDebugMessage } from "./logger";
-import Session from "supertokens-node/recipe/session";
-import { createClient } from "./telemetry/createTelemetryClient";
-import { RowndPluginError } from "./errors";
-import {
-  parseRequest,
-  mapRowndUserToSuperTokens,
-  importUser,
-  setRowndClient,
-  validateRowndToken,
-  fetchRowndUserInfo,
-} from "./pluginImplementation";
-
-export const init = createPluginInitFunction<
-  SuperTokensPlugin,
-  RowndPluginConfig,
-  {},
-  RowndPluginNormalisedConfig
->(
-  (config) => {
-    const rowndClient = createInstance({
-      app_key: config.rowndAppKey,
-      app_secret: config.rowndAppSecret,
-    });
-    const telemetryClient = createClient(config.telemetry);
-
-    setRowndClient(rowndClient);
-
-    if (config.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(config) {
-        const apiBasePath = config.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: string | undefined = PUBLIC_TENANT_ID;
-                  let rowndUserId: string | undefined;
-                  let superTokensUserId: string | undefined;
-                  let user: Awaited<ReturnType<typeof supertokens.getUser>>;
-                  let recipeUserId:
-                    | Parameters<typeof Session.createNewSession>[3]
-                    | undefined;
-                  try {
-                    if (!config.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,
-                        config.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",
-                    };
-                  }
-                },
-              ),
-            },
-          ],
-        };
-      },
-    };
-  },
-  () => ({}),
-  (config: RowndPluginConfig) => {
-    if (!config?.rowndAppKey || !config?.rowndAppSecret) {
-      throw new Error("Missing rowndAppKey or rowndAppSecret in plugin config");
-    }
-    if (config.telemetry?.provider === "axiom") {
-      if (!config.telemetry.token || !config.telemetry.dataset) {
-        throw new Error(
-          "Missing telemetry axiom token or dataset in plugin config",
-        );
-      }
-    }
-    if (config.telemetry?.provider === "custom") {
-      if (typeof config.telemetry.factory !== "function") {
-        throw new Error(
-          "Missing telemetry custom factory function in plugin config",
-        );
-      }
-    }
-    return {
-      rowndAppKey: config.rowndAppKey,
-      rowndAppSecret: config.rowndAppSecret,
-      enableDebugLogs: config.enableDebugLogs,
-      telemetry: config.telemetry,
-    };
-  },
-);

package/src/pluginImplementation.ts

@@ -1,187 +0,0 @@
-import { BaseRequest } from "supertokens-node/lib/build/framework/request";
-import { RowndUser, SuperTokensUserImport, IRowndClient } from "./types";
-import { RowndPluginError } from "./errors";
-import type {
-  JSONObject,
-  SuperTokensPublicConfig,
-} from "supertokens-node/types";
-
-let rowndClient: IRowndClient | undefined;
-
-export function setRowndClient(client: IRowndClient) {
-  rowndClient = client;
-}
-
-export function getRowndClient() {
-  if (!rowndClient) {
-    throw new Error("Rownd client not initialized");
-  }
-  return rowndClient;
-}
-
-export async function parseRequest(req: BaseRequest): Promise<{
-  token: string;
-}> {
-  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,
-  };
-}
-
-export function mapRowndUserToSuperTokens(
-  rowndUser: RowndUser,
-): SuperTokensUserImport {
-  const loginMethods: SuperTokensUserImport["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: JSONObject = {
-    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,
-  };
-}
-
-export async function importUser(
-  stUser: SuperTokensUserImport,
-  config: NonNullable<SuperTokensPublicConfig["supertokens"]>,
-): Promise<{
-  id: string;
-  loginMethods: Array<{
-    recipeUserId: string;
-  }>;
-}> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-  if (config.apiKey) {
-    headers["api-key"] = config.apiKey;
-  }
-
-  const response = await fetch(`${config.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()) as {
-    status: string;
-    message?: string;
-    user?: {
-      id: string;
-      loginMethods: Array<{
-        recipeUserId: string;
-      }>;
-    };
-  };
-
-  if (importResponse.status !== "OK" || !importResponse.user) {
-    throw new Error(
-      `Bulk import failed: ${importResponse.message || "Missing user in response"}`,
-    );
-  }
-
-  return importResponse.user;
-}
-
-export async function validateRowndToken(token: string): Promise<string> {
-  const client = getRowndClient();
-  const tokenInfo = await client.validateToken(token);
-  return tokenInfo.user_id;
-}
-
-export async function fetchRowndUserInfo(userId: string): Promise<RowndUser> {
-  const client = getRowndClient();
-  const rowndUser = await client.fetchUserInfo({ user_id: userId });
-  if (!rowndUser) {
-    throw new RowndPluginError("ROWND_USER_NOT_FOUND");
-  }
-  return rowndUser;
-}

package/src/telemetry/axiomTelemetryClient.ts

@@ -1,34 +0,0 @@
-import { PLUGIN_ID } from "../constants";
-import { RowndTelemetryClient, RowndTelemetryEvent } from "../types";
-
-const DEFAULT_AXIOM_URL = "https://api.axiom.co/v1/datasets";
-
-export class AxiomTelemetryClient implements RowndTelemetryClient {
-  private readonly url: string;
-
-  constructor(
-    private readonly token: string,
-    private readonly dataset: string,
-    endpoint?: string,
-  ) {
-    const baseUrl = (endpoint ?? DEFAULT_AXIOM_URL).replace(/\/$/, "");
-    this.url = `${baseUrl}/${dataset}/ingest`;
-  }
-
-  async recordEvent(event: RowndTelemetryEvent): Promise<void> {
-    await fetch(this.url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify([
-        {
-          ts: new Date().toISOString(),
-          plugin: PLUGIN_ID,
-          ...event,
-        },
-      ]),
-    });
-  }
-}

package/src/telemetry/createTelemetryClient.ts

@@ -1,87 +0,0 @@
-import {
-  RowndTelemetryClient,
-  RowndTelemetryConfig,
-  RowndTelemetryEvent,
-} from "../types";
-import { logDebugMessage } from "../logger";
-import { AxiomTelemetryClient } from "./axiomTelemetryClient";
-import { OpenTelemetryClient } from "./openTelemetryClient";
-
-type SuccessEvent = Extract<RowndTelemetryEvent, { outcome: "success" }>;
-type ErrorEvent = Extract<RowndTelemetryEvent, { outcome: "error" }>;
-
-export function createClient(
-  telemetryConfig: RowndTelemetryConfig | undefined,
-) {
-  let client: RowndTelemetryClient | undefined;
-
-  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: SuccessEvent) => {
-      if (!client) {
-        return;
-      }
-      safeRecordEvent(client, event, "success");
-    },
-    recordError: (input: {
-      error: unknown;
-      startedAt: number;
-      tenantId?: string;
-      rowndUserId?: string;
-      superTokensUserId?: string;
-    }) => {
-      if (!client) {
-        return;
-      }
-
-      const event: ErrorEvent = {
-        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 : undefined,
-        },
-      };
-      safeRecordEvent(client, event, "error");
-    },
-  };
-}
-
-function safeRecordEvent(
-  client: RowndTelemetryClient,
-  event: RowndTelemetryEvent,
-  outcome: "success" | "error",
-) {
-  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"
-      }`,
-    );
-  }
-}

package/src/telemetry/openTelemetryClient.ts

@@ -1,32 +0,0 @@
-import { SpanStatusCode, trace } from "@opentelemetry/api";
-import { RowndTelemetryClient, RowndTelemetryEvent } from "../types";
-
-export class OpenTelemetryClient implements RowndTelemetryClient {
-  recordEvent(event: RowndTelemetryEvent): void {
-    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();
-  }
-}

package/src/types.ts

@@ -1,124 +0,0 @@
-import type { JSONObject } from "supertokens-node/types";
-
-export interface RowndPluginConfig {
-  rowndAppKey: string;
-  rowndAppSecret: string;
-  enableDebugLogs?: boolean;
-  telemetry?: RowndTelemetryConfig;
-}
-
-export type RowndTelemetryEvent =
-  | {
-      outcome: "success";
-      durationMs: number;
-      tenantId?: string;
-      rowndUserId?: string;
-      superTokensUserId?: string;
-    }
-  | {
-      outcome: "error";
-      durationMs: number;
-      tenantId?: string;
-      rowndUserId?: string;
-      superTokensUserId?: string;
-      error: {
-        message: string;
-        name?: string;
-      };
-    };
-
-export interface RowndTelemetryClient {
-  recordEvent: (event: RowndTelemetryEvent) => Promise<void> | void;
-}
-
-export type RowndTelemetryConfig =
-  | {
-      provider: "opentelemetry";
-    }
-  | {
-      provider: "axiom";
-      token: string;
-      dataset: string;
-      url?: string;
-    }
-  | {
-      provider: "custom";
-      factory: () => RowndTelemetryClient;
-    };
-
-export interface RowndUser {
-  state: string;
-  auth_level: string;
-  data: {
-    user_id: string;
-    email?: string;
-    phone_number?: string;
-    google_id?: string;
-    apple_id?: string;
-    first_name?: string;
-    last_name?: string;
-  };
-  attributes?: Record<string, string>;
-  verified_data: {
-    email?: string;
-    phone_number?: string;
-    google_id?: string;
-    apple_id?: string;
-  };
-  groups?: string[];
-  meta?: {
-    created?: string;
-    modified?: string;
-    first_sign_in?: string;
-    last_sign_in?: string;
-  };
-}
-
-export interface MigrationResponse {
-  status: "OK" | "ERROR";
-  message?: string;
-}
-
-export interface RowndPluginNormalisedConfig {
-  rowndAppKey: string;
-  rowndAppSecret: string;
-  enableDebugLogs?: boolean;
-  telemetry?: RowndTelemetryConfig;
-}
-
-export interface SuperTokensUserImport {
-  externalUserId: string;
-  timeJoined?: number;
-  userMetadata: JSONObject;
-  loginMethods: (
-    | {
-        recipeId: "emailpassword";
-        email: string;
-        passwordHash: string;
-        isVerified: boolean;
-      }
-    | {
-        recipeId: "thirdparty";
-        thirdPartyId: string;
-        thirdPartyUserId: string;
-        email: string;
-        isVerified: boolean;
-      }
-    | {
-        recipeId: "passwordless";
-        email?: string;
-        phoneNumber?: string;
-        isVerified: boolean;
-      }
-  )[];
-}
-
-export interface IRowndClient {
-  validateToken: (token: string) => Promise<{
-    user_id: string;
-  }>;
-  fetchUserInfo: (opts: {
-    user_id: string;
-    app_id?: string;
-  }) => Promise<RowndUser | undefined>;
-}