@svadmin/kinde 0.0.0-stage → 0.2.0

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@svadmin/kinde",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Kinde AuthProvider adapter for svadmin",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*"
+  ],
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "@svadmin/core": "^0.78.0"
+  },
+  "keywords": [
+    "svadmin",
+    "kinde",
+    "auth",
+    "auth-provider",
+    "identity",
+    "rbac"
+  ],
+  "license": "MIT",
+  "author": "zuohuadong",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vibeunion/svadmin.git",
+    "directory": "packages/kinde"
+  },
+  "homepage": "https://github.com/vibeunion/svadmin#readme",
+  "bugs": {
+    "url": "https://github.com/vibeunion/svadmin/issues"
+  },
+  "svadmin": {
+    "capabilities": [
+      "auth"
+    ],
+    "core": "^0.55.0",
+    "stability": "stable",
+    "migration": null
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { createKindeAuthProvider } from './kinde-auth-provider.js';
+export type {
+  KindeUserLike,
+  KindeClientLike,
+  KindeAuthOptions,
+} from './kinde-auth-provider.js';

package/src/kinde-auth-provider.ts

@@ -0,0 +1,136 @@
+import type {
+  AuthProvider,
+  AuthActionResult,
+  CheckResult,
+  Identity,
+  AuthErrorResult,
+} from '@svadmin/core';
+
+export interface KindeUserLike {
+  id: string;
+  given_name?: string | null;
+  family_name?: string | null;
+  email?: string | null;
+  picture?: string | null;
+  [key: string]: unknown;
+}
+
+export interface KindeClientLike {
+  isAuthenticated: () => Promise<boolean>;
+  getUser: () => Promise<KindeUserLike | undefined>;
+  getUserProfile?: () => Promise<KindeUserLike | undefined>;
+  login?: (options?: Record<string, unknown>) => Promise<void>;
+  register?: (options?: Record<string, unknown>) => Promise<void>;
+  logout?: (options?: Record<string, unknown>) => Promise<void> | void;
+  getToken?: () => Promise<string>;
+  getPermissions?: () => Promise<{ permissions: string[]; orgCode?: string } | undefined>;
+  getOrganization?: () => Promise<{ orgCode: string } | undefined>;
+}
+
+export interface KindeAuthOptions {
+  /** Fallback login redirect path or URL */
+  loginUrl?: string;
+  /** Return URI after logout. Defaults to '/' */
+  logoutRedirectUri?: string;
+  /** Default fallback role when no permissions are found. Defaults to 'user' */
+  defaultRole?: string;
+}
+
+export function createKindeAuthProvider(
+  kinde: KindeClientLike,
+  options: KindeAuthOptions = {},
+): AuthProvider {
+  const defaultRole = options.defaultRole ?? 'user';
+
+  return {
+    async login(params: Record<string, unknown> = {}): Promise<AuthActionResult> {
+      try {
+        if (kinde.login) {
+          await kinde.login(params);
+          return { success: true };
+        }
+        if (options.loginUrl && typeof window !== 'undefined') {
+          window.location.href = options.loginUrl;
+          return { success: true };
+        }
+        return {
+          success: false,
+          error: {
+            name: 'KINDE_NOT_CONFIGURED',
+            message: 'Kinde client login method is not available.',
+          },
+        };
+      } catch (err: unknown) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return {
+          success: false,
+          error: {
+            name: error.name || 'KINDE_LOGIN_ERROR',
+            message: error.message,
+          },
+        };
+      }
+    },
+
+    async logout(params?: Record<string, unknown>): Promise<AuthActionResult> {
+      const returnTo = options.logoutRedirectUri ?? (typeof window !== 'undefined' ? window.location.origin : '/');
+      if (kinde.logout) {
+        await kinde.logout(params);
+      }
+      return { success: true, redirectTo: returnTo };
+    },
+
+    async check(): Promise<CheckResult> {
+      try {
+        const authenticated = await kinde.isAuthenticated();
+        if (authenticated) {
+          return { authenticated: true };
+        }
+        return {
+          authenticated: false,
+          ...(options.loginUrl ? { redirectTo: options.loginUrl } : {}),
+        };
+      } catch {
+        return {
+          authenticated: false,
+          ...(options.loginUrl ? { redirectTo: options.loginUrl } : {}),
+        };
+      }
+    },
+
+    async getIdentity(): Promise<Identity | null> {
+      const user = (await kinde.getUserProfile?.()) ?? (await kinde.getUser());
+      if (!user) return null;
+
+      const parts = [user.given_name, user.family_name].filter(Boolean);
+      const computedName = parts.length > 0 ? parts.join(' ') : 'Anonymous User';
+
+      return {
+        id: user.id ?? 'unknown',
+        name: computedName,
+        ...(user.email ? { email: user.email } : {}),
+        ...(user.picture ? { avatar: user.picture } : {}),
+      };
+    },
+
+    async getPermissions(): Promise<unknown> {
+      const perms = await kinde.getPermissions?.();
+      if (perms?.permissions && perms.permissions.length > 0) {
+        return perms.permissions;
+      }
+      return [defaultRole];
+    },
+
+    async onError(error: unknown): Promise<AuthErrorResult> {
+      const status = (error as { status?: number; statusCode?: number })?.status ??
+        (error as { status?: number; statusCode?: number })?.statusCode;
+      if (status === 401 || status === 403) {
+        return {
+          logout: true,
+          redirectTo: options.loginUrl ?? '/login',
+        };
+      }
+      return {};
+    },
+  };
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.