@nexys/user-management-sdk 0.0.7 → 0.0.10

package/dist/client.d.ts

@@ -1,8 +1,13 @@
-import { Locale, Profile, SSOService, UserAdmin, Permission } from "./type";
+import { Locale, Permission, Profile, SSOService, UserAdmin } from "./type";
+export declare const redirectUrl: (ssoService: SSOService) => string;
 declare class AuthClient {
     apiBasename: string;
     constructor(apiBasename: string);
-    authSSOUrl: (service: SSOService) => Promise<{
+    authSSOUrl: (service: SSOService, params?: Partial<{
+        isSignup: boolean;
+        redirectUrl: string;
+        instance: string;
+    }>) => Promise<{
         url: string;
     }>;
     authGoogleRedirect: (ssoService: SSOService, code: string, state: string) => Promise<{
@@ -21,6 +26,12 @@ declare class AuthClient {
         locale: Locale;
     }>;
     authLogout: () => Promise<any>;
+    tenantExists: (data: {
+        name: string;
+    }) => Promise<{
+        uuid: string;
+        name: string;
+    }>;
     adminUserList: () => Promise<UserAdmin[]>;
     authRefresh: () => Promise<{
         message: string;

package/dist/client.js

@@ -1,13 +1,19 @@
+import { paramsToString } from "./utils";
 // auth stuff
-const redirectUrl = (ssoService) => [window.location.origin, "auth", "sso", ssoService, "redirect"].join("/");
+const headers = { "content-type": "application/json" };
+export const redirectUrl = (ssoService) => [window.location.origin, "auth", "sso", ssoService, "redirect"].join("/");
 class AuthClient {
     apiBasename;
     constructor(apiBasename) {
         this.apiBasename = apiBasename;
     }
-    authSSOUrl = async (service) => {
-        const response = await fetch(`${this.apiBasename}/auth/${service}/url?redirectUrl=${encodeURIComponent(redirectUrl(service))}`);
-        return response.json();
+    authSSOUrl = async (service, params = {}) => {
+        const url = `${this.apiBasename}/auth/${service}/url?${paramsToString(params)}`;
+        const response = await fetch(url);
+        if (response.ok) {
+            return response.json();
+        }
+        return Promise.reject(response.json());
     };
     authGoogleRedirect = async (ssoService, code, state) => {
         const response = await fetch(this.apiBasename +
@@ -35,9 +41,21 @@ class AuthClient {
         const response = await fetch(this.apiBasename + "/auth/logout");
         return response.json();
     };
+    tenantExists = async (data) => {
+        const response = await fetch("/napi/instance/exists", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(data),
+        });
+        if (response.ok) {
+            return response.json();
+        }
+        return Promise.reject(response.json());
+    };
     adminUserList = async () => {
         const response = await fetch(this.apiBasename + "/admin/user/list", {
             method: "POST",
+            headers,
         });
         return response.json();
     };

package/dist/context.d.ts

@@ -1,8 +1,10 @@
-import React, { ReactNode } from "react";
+import React, { JSX, ReactNode } from "react";
 import AuthClient from "./client.js";
-import { Profile } from "./type.js";
+import { Locale, Permission, Profile } from "./type.js";
 export type AuthContextType = {
     profile: Profile;
+    permissions: Permission[];
+    locale: Locale;
     logout: () => void;
 };
 export declare const AdminContext: React.Context<AuthContextType | undefined>;

package/dist/context.js

@@ -6,6 +6,8 @@ const REFRESH_INTERVAL = 5 * 60 * 1000; // 5 minutes in milliseconds
 export const AuthProvider = ({ authClient, Spinner, loginPath, }) => ({ children }) => {
     const navigate = useNavigate();
     const [profile, setProfile] = useState(null);
+    const [permissions, setPermissions] = useState([]);
+    const [locale, setLocale] = useState({ country: "US", lang: "en" });
     const refreshToken = useCallback(async () => {
         try {
             await authClient.authRefresh();
@@ -25,8 +27,10 @@ export const AuthProvider = ({ authClient, Spinner, loginPath, }) => ({ children
                 .catch(async () => {
                 try {
                     await authClient.authRefresh();
-                    const { profile } = await authClient.getProfile();
+                    const { profile, permissions, locale } = await authClient.getProfile();
                     setProfile(profile);
+                    setPermissions(permissions);
+                    setLocale(locale);
                 }
                 catch (e) {
                     console.log("e1", e);
@@ -47,9 +51,6 @@ export const AuthProvider = ({ authClient, Spinner, loginPath, }) => ({ children
             return navigate(loginPath, { state: navigationMessage });
         }
     }, []);
-    if (profile === null) {
-        return _jsx(Spinner, {});
-    }
     // Set up refresh interval when profile exists
     React.useEffect(() => {
         if (!profile)
@@ -59,6 +60,9 @@ export const AuthProvider = ({ authClient, Spinner, loginPath, }) => ({ children
             clearInterval(intervalId);
         };
     }, [profile, refreshToken]);
+    if (profile === null) {
+        return _jsx(Spinner, {});
+    }
     const logout = () => {
         setProfile(null);
         authClient.authLogout();
@@ -73,6 +77,8 @@ export const AuthProvider = ({ authClient, Spinner, loginPath, }) => ({ children
     };
     const value = {
         profile,
+        permissions,
+        locale,
         logout,
     };
     return (_jsx(AdminContext.Provider, { value: value, children: children }));

package/dist/sso-response.d.ts

@@ -1,3 +1,4 @@
+import { JSX } from "react";
 import AuthClient from "./client.js";
 declare const SsoResponse: ({ authClient, links, Banner, Spinner, }: {
     authClient: AuthClient;

package/dist/utils.d.ts

@@ -4,3 +4,4 @@ export declare const getLoginInfoFromQuery: (lSearch: string) => {
 } | null;
 export declare const base64UrlToUint8Array: (base64Url: string) => Uint8Array;
 export declare const arrayBufferToBase64: (buffer: ArrayBuffer) => string;
+export declare const paramsToString: (params: Record<string, any>) => string;

package/dist/utils.js

@@ -32,3 +32,6 @@ export const arrayBufferToBase64 = (buffer) => {
     // by replacing "+" with "-", "/" with "_", and stripping "=" padding
     return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
+export const paramsToString = (params) => Object.entries(params)
+    .map(([k, v]) => [k, encodeURIComponent(v)].join("="))
+    .join("&");

package/dist/utils.test.js

@@ -1,25 +1,23 @@
-// Import necessary modules
-import { strict as assert } from "node:assert";
-import { describe, it } from "node:test";
-import { getLoginInfoFromQuery, base64UrlToUint8Array, arrayBufferToBase64, } from "./utils.js";
-// Mock browser's atob and btoa for Node.js
+// utils.test.js
+import { describe, expect, it } from "bun:test";
+import { arrayBufferToBase64, base64UrlToUint8Array, getLoginInfoFromQuery, } from "./utils.js";
+// Mock browser's atob and btoa for Node.js/Bun environment
 global.atob = (base64) => Buffer.from(base64, "base64").toString("binary");
 global.btoa = (binary) => Buffer.from(binary, "binary").toString("base64");
-// Describe the test suite
 describe("getLoginInfoFromQuery", () => {
     it('should return null if the query does not contain the "q" parameter', () => {
         const result = getLoginInfoFromQuery("?someOtherParam=abc");
-        assert.strictEqual(result, null);
+        expect(result).toBe(null);
     });
     it('should return null if the "q" parameter is missing', () => {
         const result = getLoginInfoFromQuery("");
-        assert.strictEqual(result, null);
+        expect(result).toBe(null);
     });
     it('should decode the "q" parameter and return the correct userId and instanceId', () => {
         const encodedParam = Buffer.from("user123:instance456").toString("base64");
         const query = `?q=${encodedParam}`;
         const result = getLoginInfoFromQuery(query);
-        assert.deepStrictEqual(result, {
+        expect(result).toEqual({
             userId: "user123",
             instanceId: "instance456",
         });
@@ -28,13 +26,12 @@ describe("getLoginInfoFromQuery", () => {
         const encodedParam = Buffer.from("user123").toString("base64");
         const query = `?q=${encodedParam}`;
         const result = getLoginInfoFromQuery(query);
-        assert.deepStrictEqual(result, {
+        expect(result).toEqual({
             userId: "user123",
             instanceId: undefined,
         });
     });
 });
-// Tests for base64UrlToUint8Array
 describe("base64UrlToUint8Array", () => {
     it("should correctly convert Base64URL string to Uint8Array", () => {
         const base64Url = "SGVsbG8td29ybGQ_"; // Base64URL for "Hello-world?"
@@ -42,7 +39,7 @@ describe("base64UrlToUint8Array", () => {
             72, 101, 108, 108, 111, 45, 119, 111, 114, 108, 100, 63,
         ]);
         const result = base64UrlToUint8Array(base64Url);
-        assert.deepStrictEqual(result, expectedArray);
+        expect(result).toEqual(expectedArray);
     });
     it("should handle padding correctly", () => {
         const base64Url = "SGVsbG8gd29ybGQ"; // Base64URL for "Hello world" without padding
@@ -50,10 +47,9 @@ describe("base64UrlToUint8Array", () => {
             72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100,
         ]);
         const result = base64UrlToUint8Array(base64Url);
-        assert.deepStrictEqual(result, expectedArray);
+        expect(result).toEqual(expectedArray);
     });
 });
-// Tests for arrayBufferToBase64
 describe("arrayBufferToBase64", () => {
     it("should correctly convert ArrayBuffer to Base64URL string", () => {
         const buffer = new Uint8Array([
@@ -61,18 +57,18 @@ describe("arrayBufferToBase64", () => {
         ]).buffer;
         const expectedBase64Url = "SGVsbG8td29ybGQ_";
         const result = arrayBufferToBase64(buffer);
-        assert.strictEqual(result, expectedBase64Url);
+        expect(result).toBe(expectedBase64Url);
     });
     it("should handle empty ArrayBuffer", () => {
         const buffer = new ArrayBuffer(0);
         const expectedBase64Url = "";
         const result = arrayBufferToBase64(buffer);
-        assert.strictEqual(result, expectedBase64Url);
+        expect(result).toBe(expectedBase64Url);
     });
     it("should handle large ArrayBuffer", () => {
         const buffer = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).buffer;
         const expectedBase64Url = "AAECAwQFBgcICQ";
         const result = arrayBufferToBase64(buffer);
-        assert.strictEqual(result, expectedBase64Url);
+        expect(result).toBe(expectedBase64Url);
     });
 });

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@nexys/user-management-sdk",
-  "version": "0.0.7",
+  "version": "0.0.10",
   "private": false,
   "description": "react client/sdk that faciliates connecting to the user management",
   "main": "dist/index.js",
   "devDependencies": {
+    "@types/bun": "^1.1.14",
     "@types/node": "^22.5.4",
-    "@types/react": "^18.3.5",
-    "react": "^18.3.1",
+    "@types/react": "^19.0.2",
+    "@types/react-dom": "^19.0.2",
+    "react": "^19.0.0",
     "react-router-dom": "^6.26.2",
     "typescript": "^5.6.2"
   },
@@ -17,7 +19,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "node dist/*.test.js",
+    "test": "bun test",
     "buildPackage": "yarn build; rm dist/*.test.js; rm dist/*.test.d.ts"
   },
   "repository": {
@@ -29,5 +31,10 @@
   "bugs": {
     "url": "https://github.com/nexys-system/user-management-client/issues"
   },
-  "homepage": "https://github.com/nexys-system/user-management-client#readme"
+  "homepage": "https://github.com/nexys-system/user-management-client#readme",
+  "dependencies": {
+    "@nexys/user-management-aas": "^0.6.8",
+    "@nexys/validation": "^2.1.8",
+    "react-dom": "^19.0.0"
+  }
 }

package/dist/login-utils.d.ts

@@ -1,4 +0,0 @@
-export declare const getLoginInfoFromQuery: (lSearch: string) => {
-    userId: string;
-    instanceId: string;
-} | null;

package/dist/login-utils.js

@@ -1,9 +0,0 @@
-export const getLoginInfoFromQuery = (lSearch) => {
-    const queryParams = new URLSearchParams(lSearch);
-    const paramValue = queryParams.get("q");
-    if (!paramValue) {
-        return null;
-    }
-    const [userId, instanceId] = atob(paramValue).split(":");
-    return { userId, instanceId };
-};