@explita/cloud-auth-client 0.0.1

package/dist/lib/utils.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = cn;
+exports.unstuckPointerEvents = unstuckPointerEvents;
+exports.buildRouteContext = buildRouteContext;
+exports.getClientToken = getClientToken;
+exports.hasPermission = hasPermission;
+exports.parseMessage = parseMessage;
+exports.parseJwt = parseJwt;
+exports.isOtpAvailable = isOtpAvailable;
+exports.shouldPassFullUserObject = shouldPassFullUserObject;
+exports.getPublicTokenEnv = getPublicTokenEnv;
+exports.getPrivateTokenEnv = getPrivateTokenEnv;
+function cn(...classes) {
+    return classes.filter(Boolean).join(" ");
+}
+function unstuckPointerEvents() {
+    // Fix Radix edge case: pointer-events stuck after opening controlled Dialog from Dropdown
+    setTimeout(() => {
+        if (document.body.style.pointerEvents === "none") {
+            document.body.style.pointerEvents = "";
+        }
+    }, 10);
+}
+const defaultAuthConfig = {
+    loginPath: "/login",
+    signupPath: "/signup",
+    dashboardPath: "/dashboard",
+    resetPasswordPath: "/forgot-password",
+    excludedPaths: [],
+};
+function buildRouteContext(config, currentPath = "") {
+    var _a;
+    const finalConfig = { ...defaultAuthConfig, ...config };
+    const hostOverride = finalConfig.hostOverride;
+    currentPath =
+        typeof window !== "undefined" ? window.location.pathname : currentPath;
+    const normalize = (input) => {
+        try {
+            return new URL(input).pathname.replace(/\/+$/, "");
+        }
+        catch {
+            return input.replace(/\/+$/, "");
+        }
+    };
+    const loginUrl = getAbsoluteUrl(finalConfig.loginPath, hostOverride);
+    const signupUrl = getAbsoluteUrl(finalConfig.signupPath, hostOverride);
+    const dashboardUrl = getAbsoluteUrl(finalConfig.dashboardPath, hostOverride);
+    const resetPasswordUrl = getAbsoluteUrl(finalConfig.resetPasswordPath, hostOverride);
+    const excludedPaths = [
+        normalize(loginUrl),
+        normalize(signupUrl),
+        ...((_a = config === null || config === void 0 ? void 0 : config.excludedPaths) !== null && _a !== void 0 ? _a : []),
+    ];
+    try {
+        if (resetPasswordUrl) {
+            excludedPaths.push(normalize(resetPasswordUrl));
+        }
+    }
+    catch (e) {
+        console.warn("Invalid resetPasswordUrl:", e.message);
+    }
+    const normalizedCurrentPath = normalize(currentPath);
+    const isExcluded = excludedPaths.includes(normalizedCurrentPath);
+    const returnPath = typeof window !== "undefined"
+        ? encodeURIComponent(`${window.location.pathname}${window.location.search}`)
+        : encodeURIComponent(currentPath);
+    return {
+        loginUrl,
+        signupUrl,
+        dashboardUrl,
+        resetPasswordUrl,
+        returnPath,
+        currentPath: normalizedCurrentPath,
+        excludedPaths,
+        isExcluded,
+    };
+}
+function getAbsoluteUrl(pathOrUrl, hostOverride) {
+    try {
+        const url = new URL(pathOrUrl, hostOverride !== null && hostOverride !== void 0 ? hostOverride : "");
+        return url.toString();
+    }
+    catch {
+        if (typeof window !== "undefined") {
+            const base = hostOverride !== null && hostOverride !== void 0 ? hostOverride : window.location.origin;
+            return new URL(pathOrUrl.replace(/^\/+/, "/"), base).toString();
+        }
+        return `http://localhost${pathOrUrl.startsWith("/") ? "" : "/"}${pathOrUrl}`;
+    }
+}
+function getClientToken() {
+    var _a;
+    return typeof localStorage !== "undefined"
+        ? ((_a = localStorage.getItem("_ecp_auth_token")) !== null && _a !== void 0 ? _a : "")
+        : "";
+}
+function hasPermission(user, permission) {
+    var _a;
+    if (!user)
+        return false;
+    return ((_a = user.role.permissions) === null || _a === void 0 ? void 0 : _a.includes(permission)) || user.isSuperAdmin;
+}
+function parseMessage(message) {
+    return message == "fetch failed" || message == "Failed to fetch"
+        ? "Please check your internet connection"
+        : message;
+}
+function base64UrlDecode(b64url) {
+    // Replace URL-safe chars
+    let base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+    // Pad with "=" if needed
+    while (base64.length % 4 !== 0) {
+        base64 += "=";
+    }
+    return atob(base64);
+}
+function parseJwt(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        throw new Error("Invalid JWT format");
+    const payload = base64UrlDecode(parts[1]);
+    return JSON.parse(payload);
+}
+function isOtpAvailable() {
+    try {
+        require.resolve("@explita/cloud-otp-client");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shouldPassFullUserObject() {
+    return (process.env.NEXT_PUBLIC_ECP_PASS_FULL_USER_OBJECT === "true" ||
+        process.env.VITE_ECP_PASS_FULL_USER_OBJECT === "true" ||
+        process.env.ECP_PASS_FULL_USER_OBJECT === "true");
+}
+function getPublicTokenEnv() {
+    return (process.env.NEXT_PUBLIC_ECP_AUTH_PUBLIC_TOKEN ||
+        process.env.VITE_ECP_AUTH_PUBLIC_TOKEN ||
+        process.env.ECP_AUTH_PUBLIC_TOKEN ||
+        "");
+}
+function getPrivateTokenEnv() {
+    var _a;
+    return (_a = process.env.ECP_AUTH_PRIVATE_TOKEN) !== null && _a !== void 0 ? _a : "";
+}

package/dist/server/cookie.d.ts

@@ -0,0 +1 @@
+export declare function setCookie(value?: string): Promise<void>;

package/dist/server/cookie.js

@@ -0,0 +1,29 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCookie = setCookie;
+async function setCookie(value) {
+    try {
+        // Dynamically import to avoid bundling next in non-Next environments
+        const { cookies } = require("next/headers");
+        const cookieStore = await cookies();
+        if (!value) {
+            cookieStore.delete("_ecp_auth_token");
+        }
+        else {
+            cookieStore.set("_ecp_auth_token", value, {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: process.env.NODE_ENV === "production",
+                expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+                path: "/",
+            });
+        }
+    }
+    catch (error) {
+        // In non-Next environments, this silently fails (as intended)
+        if (process.env.NODE_ENV === "development") {
+            console.warn("[setCookie] Could not set cookie:", error);
+        }
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./toggle-2fa";
+export * from "./reset-password";
+export * from "./users-accounts";
+export * from "./cookie";
+export * from "./server-session";
+export * from "./server-token";
+export * from "./role";

package/dist/server/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./toggle-2fa"), exports);
+__exportStar(require("./reset-password"), exports);
+__exportStar(require("./users-accounts"), exports);
+__exportStar(require("./cookie"), exports);
+__exportStar(require("./server-session"), exports);
+__exportStar(require("./server-token"), exports);
+__exportStar(require("./role"), exports);

package/dist/server/reset-password.d.ts

@@ -0,0 +1,3 @@
+import { ResetPasswordWithToken, GeneralResponse, ResetPasswordWithUserId, FormResponse } from "../types";
+export declare function resetPassword(data: ResetPasswordWithToken): Promise<GeneralResponse>;
+export declare function changePassword(data: ResetPasswordWithUserId): Promise<FormResponse>;

package/dist/server/reset-password.js

@@ -0,0 +1,41 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetPassword = resetPassword;
+exports.changePassword = changePassword;
+const utils_1 = require("../lib/utils");
+const api_1 = require("../lib/api");
+const error_1 = require("../lib/error");
+async function resetPassword(data) {
+    try {
+        const res = await (0, api_1.apiFactory)("/reset-password", {
+            body: { ...data },
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: (0, utils_1.parseMessage)(error.message), status: "failure" };
+    }
+}
+async function changePassword(data) {
+    try {
+        const res = await (0, api_1.apiFactory)("/change-password", {
+            method: "PUT",
+            body: {
+                password: data.password,
+                confirmPassword: data.confirmPassword,
+                selectedUserId: data.userId,
+            },
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: (0, utils_1.parseMessage)(error.message), status: "failure" };
+    }
+}

package/dist/server/role.d.ts

@@ -0,0 +1,7 @@
+import { Role, NewRole, FormResponse } from "../types";
+export declare function getRoles(options?: {
+    groupId: string;
+}): Promise<Role[]>;
+export declare function addRole(role: NewRole): Promise<FormResponse<Role>>;
+export declare function updateRole(roleId: string, role: NewRole): Promise<FormResponse<Role>>;
+export declare function assignPermission(roleId: string, permissions: string[]): Promise<FormResponse<Role>>;

package/dist/server/role.js

@@ -0,0 +1,63 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoles = getRoles;
+exports.addRole = addRole;
+exports.updateRole = updateRole;
+exports.assignPermission = assignPermission;
+const api_1 = require("../lib/api");
+const error_1 = require("../lib/error");
+async function getRoles(options) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/roles?groupId=${(options === null || options === void 0 ? void 0 : options.groupId) || ""}`, {
+            method: "GET",
+        });
+        return res.data;
+    }
+    catch (error) {
+        console.log(error);
+        return [];
+    }
+}
+async function addRole(role) {
+    try {
+        const res = await (0, api_1.apiFactory)("/roles", { method: "POST", body: role });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: error.message, status: "failure" };
+    }
+}
+async function updateRole(roleId, role) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/roles/${roleId}`, {
+            method: "PUT",
+            body: role,
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: error.message, status: "failure" };
+    }
+}
+async function assignPermission(roleId, permissions) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/assign-permissions/${roleId}`, {
+            method: "PUT",
+            body: { permissions },
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: error.message, status: "failure" };
+    }
+}

package/dist/server/server-session.d.ts

@@ -0,0 +1,8 @@
+import { User } from "../types";
+export declare function getServerSession(): Promise<(User & {
+    meta: {
+        sessionId: string;
+        exp: number;
+        iat: number;
+    };
+}) | null>;

package/dist/server/server-session.js

@@ -0,0 +1,31 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerSession = getServerSession;
+const utils_1 = require("../lib/utils");
+const server_token_1 = require("./server-token");
+async function getServerSession() {
+    try {
+        const token = await (0, server_token_1.getServerToken)();
+        if (!token)
+            return null;
+        const session = (0, utils_1.parseJwt)(token);
+        return {
+            ...session.user,
+            meta: {
+                sessionId: session.sessionId,
+                exp: session.exp,
+                iat: session.iat,
+            },
+        };
+        // const res = await apiFactory("/me-server", {
+        //   method: "GET",
+        //   cache: "no-store",
+        // });
+        // return res.user;
+    }
+    catch (error) {
+        console.log(error);
+        return null;
+    }
+}

package/dist/server/server-token.d.ts

@@ -0,0 +1,4 @@
+import { NextAppCookies } from "../types";
+export declare function getServerToken(source?: Request | {
+    cookies: NextAppCookies | Record<string, string>;
+}): Promise<string | undefined>;

package/dist/server/server-token.js

@@ -0,0 +1,39 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerToken = getServerToken;
+async function getServerToken(source) {
+    var _a, _b;
+    const cookieName = "_ecp_auth_token";
+    // Case 1: No source, assume App Router (next/headers)
+    if (!source) {
+        try {
+            // Dynamically import to avoid bundling next in non-Next environments
+            const { cookies } = require("next/headers");
+            const cookieStore = await cookies();
+            return (_a = cookieStore.get(cookieName)) === null || _a === void 0 ? void 0 : _a.value;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Case 2: Middleware or Edge API
+    if (source instanceof Request) {
+        const cookieHeader = source.headers.get("cookie") || "";
+        const cookies = Object.fromEntries(cookieHeader.split("; ").map((c) => {
+            const [k, ...v] = c.split("=");
+            return [k, v.join("=")];
+        }));
+        return cookies[cookieName];
+    }
+    // Case 3: API routes or custom cookie objects
+    const cookieSource = source.cookies;
+    if (typeof (cookieSource === null || cookieSource === void 0 ? void 0 : cookieSource.get) === "function") {
+        return (_b = cookieSource.get(cookieName)) === null || _b === void 0 ? void 0 : _b.value; // next/headers-style
+    }
+    if (typeof cookieSource === "object") {
+        //@ts-ignore
+        return cookieSource[cookieName]; // plain object
+    }
+    return undefined;
+}

package/dist/server/toggle-2fa.d.ts

@@ -0,0 +1,4 @@
+import { GeneralResponse } from "../types";
+export declare function toggle2FA(userId?: string): Promise<GeneralResponse>;
+export declare function enable2FA(userId?: string): Promise<GeneralResponse>;
+export declare function disable2FA(userId?: string): Promise<GeneralResponse>;

package/dist/server/toggle-2fa.js

@@ -0,0 +1,33 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggle2FA = toggle2FA;
+exports.enable2FA = enable2FA;
+exports.disable2FA = disable2FA;
+const utils_1 = require("../lib/utils");
+const api_1 = require("../lib/api");
+const error_1 = require("../lib/error");
+async function toggle2FA(userId) {
+    try {
+        const res = await (0, api_1.apiFactory)("/2fa", {
+            method: "PUT",
+            body: {
+                selectedUserId: userId,
+            },
+            adminCall: !!userId,
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: (0, utils_1.parseMessage)(error.message), status: "failure" };
+    }
+}
+async function enable2FA(userId) {
+    return await toggle2FA(userId);
+}
+async function disable2FA(userId) {
+    return await toggle2FA(userId);
+}

package/dist/server/users-accounts.d.ts

@@ -0,0 +1,11 @@
+import { VerifyUser, VerifyUserResponse, Signup, UpdateUser, User, GeneralResponse, FormResponse } from "../types";
+export declare function verifyUser(data: VerifyUser): Promise<VerifyUserResponse>;
+export declare function registerUser(data: Signup, options?: {
+    isSuperAdmin?: boolean;
+}): Promise<FormResponse<User>>;
+export declare function updateUser(userId: string, data: UpdateUser): Promise<FormResponse<User>>;
+export declare function getUsers(options?: {
+    groupId: string;
+}): Promise<User[]>;
+export declare function getUserById(userId: string): Promise<User | null>;
+export declare function toggleUserStatus(userId: string): Promise<GeneralResponse>;

package/dist/server/users-accounts.js

@@ -0,0 +1,94 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyUser = verifyUser;
+exports.registerUser = registerUser;
+exports.updateUser = updateUser;
+exports.getUsers = getUsers;
+exports.getUserById = getUserById;
+exports.toggleUserStatus = toggleUserStatus;
+const utils_1 = require("../lib/utils");
+const api_1 = require("../lib/api");
+const error_1 = require("../lib/error");
+async function verifyUser(data) {
+    try {
+        const res = await (0, api_1.apiFactory)("/users/verify", {
+            body: { actions: data },
+        });
+        return res;
+    }
+    catch (error) {
+        return error;
+    }
+}
+async function registerUser(data, options) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/signup?isSuperAdmin=${(options === null || options === void 0 ? void 0 : options.isSuperAdmin) || false}`, {
+            body: { ...data },
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return {
+            message: (0, utils_1.parseMessage)(error.message),
+            status: "failure",
+        };
+    }
+}
+async function updateUser(userId, data) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/update-user/${userId}`, {
+            body: { ...data },
+            method: "PUT",
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: (0, utils_1.parseMessage)(error.message), status: "failure" };
+    }
+}
+async function getUsers(options) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/users?groupId=${(options === null || options === void 0 ? void 0 : options.groupId) || ""}`, {
+            method: "GET",
+        });
+        return res.data;
+    }
+    catch (err) {
+        console.log(err.message);
+        return [];
+    }
+}
+async function getUserById(userId) {
+    try {
+        const res = await (0, api_1.apiFactory)(`/users/${userId}`, { method: "GET" });
+        return res.user;
+    }
+    catch (err) {
+        console.log(err.message);
+        return null;
+    }
+}
+async function toggleUserStatus(userId) {
+    try {
+        const res = await (0, api_1.apiFactory)("/toggle-user-status", {
+            method: "PUT",
+            body: {
+                selectedUserId: userId,
+            },
+        });
+        return res;
+    }
+    catch (error) {
+        if ((0, error_1.isAPIError)(error)) {
+            return error.data;
+        }
+        return { message: (0, utils_1.parseMessage)(error.message), status: "failure" };
+    }
+}