kratos-sdk.js

import { Configuration, FrontendApi } from "@ory/client";
import dotenv from "dotenv";
import axios from "axios";

dotenv.config();

const baseURL = process.env.KRATOS_PUBLIC_URL || "http://localhost:4433";

const axiosInstance = axios.create({
  baseURL,
  withCredentials: true,
  validateStatus: () => true,
});

const kratos = new FrontendApi(
  new Configuration({
    basePath: baseURL,
  }),
  undefined,
  axiosInstance
);

export class KratosSDK {
  static async register({
    username,
    password,
    email,
    roles = ["user"],
    firstName = null,
    lastName = null,
  }) {
    try {
      const { data: flow } = await kratos.createNativeRegistrationFlow();

      const traits = {
        username,
        email,
        roles,
      };

      if (firstName || lastName) {
        traits.name = {};
        if (firstName) traits.name.first = firstName;
        if (lastName) traits.name.last = lastName;
      }

      // Complete registration
      const { data: result } = await kratos.updateRegistrationFlow({
        flow: flow.id,
        updateRegistrationFlowBody: {
          method: "password",
          password,
          traits,
        },
      });

      if (!result.session && !result.session_token) {
        const errors =
          result.ui?.nodes
            ?.flatMap((node) => node.messages || [])
            .filter((msg) => msg.type === "error")
            .map((msg) => msg.text) || [];

        const uiMessages = result.ui?.messages?.map((msg) => msg.text) || [];
        const allErrors = [...errors, ...uiMessages];

        return {
          success: false,
          error:
            allErrors.length > 0 ? allErrors.join(", ") : "Registration failed",
          flow: result,
        };
      }

      return {
        success: true,
        session: result.session,
        identity: result.session?.identity || result.identity,
        sessionToken: result.session_token || result.session?.token,
      };
    } catch (error) {
      return {
        success: false,
        error: error.response?.data || error.message,
      };
    }
  }

  static async login({ username, password }) {
    try {
      const { data: flow } = await kratos.createNativeLoginFlow();

      const { data: result } = await kratos.updateLoginFlow({
        flow: flow.id,
        updateLoginFlowBody: {
          method: "password",
          password,
          identifier: username,
        },
      });

      if (!result.session && !result.session_token) {
        const errors =
          result.ui?.nodes
            ?.flatMap((node) => node.messages || [])
            .filter((msg) => msg.type === "error")
            .map((msg) => msg.text) || [];

        return {
          success: false,
          error: errors.length > 0 ? errors.join(", ") : "Login failed",
          flow: result,
        };
      }

      return {
        success: true,
        session: result.session,
        identity: result.session?.identity || result.identity,
        sessionToken: result.session_token || result.session?.token,
      };
    } catch (error) {
      return {
        success: false,
        error: error.response?.data || error.message,
      };
    }
  }

  static async getSession(sessionToken) {
    try {
      const { data: session } = await kratos.toSession({
        xSessionToken: sessionToken,
      });

      return {
        success: true,
        active: session.active,
        identity: session.identity,
        expiresAt: session.expires_at,
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
      };
    }
  }

  static async logout(sessionToken) {
    try {
      const { data: flow } = await kratos.createBrowserLogoutFlow({
        cookie: `ory_kratos_session=${sessionToken}`,
      });

      await kratos.updateLogoutFlow({
        token: flow.logout_token,
      });

      return {
        success: true,
        message: "Logout successful",
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
      };
    }
  }

  static async getUserRoles(sessionToken) {
    try {
      const { data: session } = await kratos.toSession({
        xSessionToken: sessionToken,
      });

      return {
        success: true,
        roles: session.identity.traits.roles || [],
        identity: session.identity,
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
      };
    }
  }
}