@nexys/user-management-sdk 0.1.2 → 0.1.4

package/dist/client.d.ts

@@ -1,8 +1,10 @@
-import { type Locale, type Profile, type SSOService, type UserAdmin, Permission } from "./type";
+import * as R from "./request.js";
+import { type Locale, type Profile, type SSOService, type UserAdmin, Permission, UserStatus } from "./type.js";
 export declare const redirectUrl: (ssoService: SSOService) => string;
 declare class AuthClient {
-    apiBasename: string;
-    constructor(apiBasename: string);
+    private apiBasename;
+    makeRequest: <A>(params: R.MakeRequestParams) => Promise<A>;
+    constructor(apiBasename: string, makeRequestOverride?: <A>(params: R.MakeRequestParams) => Promise<A>);
     authSSOUrl: (service: SSOService, params?: Partial<{
         isSignup: boolean;
         redirectUrl: string;
@@ -25,8 +27,46 @@ declare class AuthClient {
         permissions: Permission[];
         locale: Locale;
     }>;
-    authLogout: () => Promise<any>;
+    authLogout: () => Promise<unknown>;
     adminUserList: () => Promise<UserAdmin[]>;
+    adminUserInsert: (data: {
+        profile: {
+            firstName: string;
+            lastName: string;
+            email: string;
+        };
+        locale?: Locale;
+        status?: UserStatus;
+    }) => Promise<{
+        uuid: string;
+    }>;
+    adminUserDelete: (uuid: string) => Promise<{
+        success: boolean;
+    }>;
+    superadminUserList: (params?: {
+        uuid?: string;
+        order?: {
+            by: "firstName" | "lastName" | "logDateAdded";
+            desc: boolean;
+        };
+        take?: number;
+    }) => Promise<UserAdmin[]>;
+    superadminUserInsert: (data: {
+        firstName: string;
+        lastName: string;
+        email: string;
+        instance: {
+            uuid: string;
+        };
+        status?: UserStatus;
+        localeCountry?: string;
+        localeLang?: string;
+    }) => Promise<{
+        uuid: string;
+    }>;
+    superadminUserDelete: (uuid: string) => Promise<{
+        success: boolean;
+    }>;
     authRefresh: () => Promise<{
         message: string;
     }>;
@@ -36,5 +76,10 @@ declare class AuthClient {
         uuid: string;
         name: string;
     }>;
+    loadAvailableProviders: () => Promise<Array<{
+        service: SSOService;
+        name: string;
+        enabled: boolean;
+    }>>;
 }
 export default AuthClient;

package/dist/client.js

@@ -1,70 +1,103 @@
-import { paramsToString } from "./utils";
-// auth stuff
-const headers = { "content-type": "application/json" };
+import * as R from "./request.js";
 export const redirectUrl = (ssoService) => [window.location.origin, "auth", "sso", ssoService, "redirect"].join("/");
 class AuthClient {
     apiBasename;
-    constructor(apiBasename) {
+    makeRequest;
+    constructor(apiBasename, makeRequestOverride) {
         this.apiBasename = apiBasename;
+        this.makeRequest = makeRequestOverride || R.makeRequest(this.apiBasename);
+        console.log("api base name", this.apiBasename);
     }
     authSSOUrl = async (service, params) => {
-        const url = `${this.apiBasename}/auth/oauth/${service}/url?${paramsToString(params)}`;
-        const response = await fetch(url);
-        if (response.ok) {
-            return response.json();
-        }
-        return Promise.reject(response.json());
+        return this.makeRequest({
+            path: `/auth/oauth/${service}/url`,
+            method: "GET",
+            queryParams: params,
+        });
     };
     authGoogleRedirect = async (ssoService, code, state) => {
-        const response = await fetch(this.apiBasename +
-            "/auth/oauth/" +
-            ssoService +
-            "/callback?code=" +
-            encodeURIComponent(code) +
-            "&state=" +
-            encodeURIComponent(state));
-        const j = await response.json();
-        if (response.ok) {
-            // here refresh to get access token
-            await this.authRefresh();
-            return j;
-        }
+        const j = await this.makeRequest({
+            path: `/auth/oauth/${ssoService}/callback`,
+            method: "GET",
+            queryParams: { code, state },
+        });
+        // here refresh to get access token
+        await this.authRefresh();
         return j;
     };
     getProfile = async () => {
-        const response = await fetch(this.apiBasename + "/profile");
-        const j = await response.json();
-        if (!response.ok) {
-            throw j;
-        }
-        return j;
+        return this.makeRequest({
+            path: "/profile",
+            method: "GET",
+        });
     };
     authLogout = async () => {
-        const response = await fetch(this.apiBasename + "/auth/logout");
-        return response.json();
+        return this.makeRequest({
+            path: "/auth/logout",
+            method: "GET",
+        });
     };
+    // Admin routes (tenant implicit from authenticated user context)
     adminUserList = async () => {
-        const response = await fetch(this.apiBasename + "/admin/user/list", {
+        return this.makeRequest({
+            path: "/admin/user/list",
             method: "POST",
         });
-        return response.json();
+    };
+    adminUserInsert = async (data) => {
+        return this.makeRequest({
+            path: "/admin/user/insert",
+            method: "POST",
+            data,
+        });
+    };
+    adminUserDelete = async (uuid) => {
+        return this.makeRequest({
+            path: "/admin/users/delete",
+            method: "POST",
+            data: { uuid },
+        });
+    };
+    // Superadmin routes (tenant must be explicitly provided)
+    superadminUserList = async (params) => {
+        return this.makeRequest({
+            path: "/superadmin/user/list",
+            method: "POST",
+            data: params || {},
+        });
+    };
+    superadminUserInsert = async (data) => {
+        return this.makeRequest({
+            path: "/superadmin/user/",
+            method: "POST",
+            data,
+        });
+    };
+    superadminUserDelete = async (uuid) => {
+        return this.makeRequest({
+            path: "/superadmin/user/delete",
+            method: "POST",
+            data: { uuid },
+        });
     };
     authRefresh = async () => {
-        const response = await fetch(this.apiBasename + "/auth/refresh");
-        return response.json();
+        return this.makeRequest({
+            path: "/auth/refresh",
+            method: "GET",
+        });
     };
     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());
-        }
+        return this.makeRequest({
+            path: "/instance/exists",
+            method: "POST",
+            data,
+        });
+    };
+    loadAvailableProviders = async () => {
+        return this.makeRequest({
+            path: "/auth/oauth/providers",
+            method: "GET",
+        });
     };
 }
 export default AuthClient;

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import React, { type ReactNode } from "react";
-import AuthClient from "./client";
-import type { Locale, Permission, Profile } from "./type";
+import AuthClient from "./client.js";
+import type { Locale, Permission, Profile } from "./type.js";
 export type AuthContextType = {
     profile: Profile;
     permissions: Permission[];
@@ -14,5 +14,5 @@ export declare const AuthProvider: ({ authClient, Spinner, loginPath, }: {
     loginPath: string;
 }) => ({ children }: {
     children: ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react/jsx-runtime.js").JSX.Element;
 export declare const useAuth: () => AuthContextType;

package/dist/request.d.ts

@@ -0,0 +1,9 @@
+export interface MakeRequestParams {
+    path: string;
+    queryParams?: Record<string, any>;
+    data?: Record<string, any>;
+    method: "GET" | "POST" | "DELETE" | "PUT";
+}
+export declare const makeRequest: (apiBasename: string, headers?: {
+    "content-type": string;
+}) => <Out = any>({ path, data, queryParams, method, }: MakeRequestParams) => Promise<Out>;

package/dist/request.js

@@ -0,0 +1,17 @@
+import { paramsToString } from "./utils";
+export const makeRequest = (apiBasename, headers = { "content-type": "application/json" }) => async ({ path, data, queryParams, method = "GET", }) => {
+    const queryParamsString = queryParams
+        ? "?" + paramsToString(queryParams)
+        : "";
+    const body = data && JSON.stringify(data);
+    const url = apiBasename + path + queryParamsString;
+    const response = await fetch(url, {
+        headers,
+        method,
+        body,
+    });
+    if (response.ok) {
+        return response.json();
+    }
+    return Promise.reject(response.json());
+};

package/dist/webauthn.js

@@ -1,4 +1,4 @@
-import * as U from "./utils";
+import * as U from "./utils.js";
 // webauthn  client
 const getPreLogin = async (user, instance) => {
     const r = await fetch("/napi/auth/webauthn/prelogin", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexys/user-management-sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "description": "react client/sdk that faciliates connecting to the user management",
   "main": "dist/index.js",