@solidstarters/solid-core-ui 1.1.211 → 1.1.212

package/dist/nextAuth/authProviders.tsx

@@ -0,0 +1,232 @@
+import CredentialsProvider from "next-auth/providers/credentials";
+import GoogleProvider from "next-auth/providers/google";
+import { NextRequest } from "next/server";
+import { jwtDecode } from "jwt-decode";
+import { JWT } from "next-auth/jwt";
+import axios from "axios";
+import { signOut } from "next-auth/react";
+import { refreshAccessToken } from "./refreshAccessToken";
+import { NextAuthOptions } from "next-auth";
+
+type Credentials = {
+    username: string,
+    email: string,
+    password: string,
+    identifier:string,
+    accessToken: string,
+    accessCode: string,
+};
+
+const authProviders: NextAuthOptions = {
+    session: {
+        strategy: "jwt",
+    },
+    providers: [
+        GoogleProvider({
+            clientId: process.env.GOOGLE_ID!,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET!
+        }),
+        CredentialsProvider({
+            // @ts-ignore
+            async authorize(credentials: Credentials, req: any) {
+                const userAgent = req.headers['user-agent'];
+
+                const { username, email, password, identifier, accessToken, accessCode } = credentials;
+                try {
+                    if (accessCode) {
+                        let config = {
+                            method: 'get',
+                            url: `${process.env.API_URL}/api/iam/google/authenticate?accessCode=${accessCode}`,
+                            headers: {
+                                'User-Agent': userAgent,
+                            }
+                        };
+                        const loginResponse = await axios.request(config);
+                        if (loginResponse.status == 400) {
+                            throw new Error(loginResponse.data.message);
+                        }
+                        if (loginResponse.status == 401) {
+                            throw new Error(loginResponse.data.message);
+                        }
+
+                        let base64decoded = jwtDecode(loginResponse.data.data.accessToken);
+                        // let accessTokenExpires = base64decoded.exp;
+                        let accessTokenExpires = base64decoded.exp && base64decoded.exp * 1000;
+
+                        return {
+                            accessToken: loginResponse.data.data.accessToken,
+                            refreshToken: loginResponse.data.data.refreshToken,
+                            accessTokenExpires: accessTokenExpires,
+                            ...loginResponse.data.data,
+                        };
+
+                    } else {
+                        if (accessToken) {
+                            let data = JSON.stringify({
+                                username: identifier,
+                                email: identifier.includes('@')? identifier : null,
+                                password: password
+                            });
+
+                            let config = {
+                                method: 'get',
+                                url: `${process.env.API_URL}/api/iam/me`,
+                                headers: {
+                                    'accept': '*/*',
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${accessToken}`
+                                }
+                            };
+
+
+                            const loginResponse = await axios.request(config);
+
+                            if (loginResponse.status == 400) {
+                                throw new Error(loginResponse.data.message);
+                            }
+                            if (loginResponse.status == 401) {
+                                throw new Error(loginResponse.data.message);
+                            }
+                            
+                            let base64decoded = jwtDecode(accessToken);
+                            // let accessTokenExpires = base64decoded.exp;
+                            let accessTokenExpires = base64decoded.exp && base64decoded.exp * 1000;
+
+                            return {
+                                accessToken: accessToken,
+                                refreshToken: loginResponse.data.data.refreshToken,
+                                accessTokenExpires: accessTokenExpires,
+                                ...loginResponse.data.data,
+                            };
+
+                        } else {
+
+                            let data = JSON.stringify({
+                                username: identifier,
+                                email: identifier.includes('@')? identifier : null,
+                                password: password
+                            });
+
+                            let config = {
+                                method: 'post',
+                                maxBodyLength: Infinity,
+                                url: `${process.env.API_URL}/api/iam/authenticate`,
+                                headers: {
+                                    'accept': '*/*',
+                                    'Content-Type': 'application/json',
+                                    'User-Agent': userAgent,
+                                },
+                                data: data
+                            };
+
+
+                            const loginResponse = await axios.request(config);
+
+                            // const authenticateResponse = await fetch(
+                            //   `${process.env.API_URL}/api/iam/authenticate`,
+                            //   {
+                            //     method: "Post",
+                            //     headers: {
+                            //     'accept': '*/*', 
+                            //       "Content-Type": "application/json"
+                            //     },
+                            //     body: JSON.stringify({
+                            //       username: email,
+                            //       email: email,
+                            //       password: password
+                            //     })
+                            //   }
+                            // );
+
+                            // const loginResponse = await authenticateResponse.json();
+
+                            // const response = await fetch(
+                            //   `${process.env.API_URL}/api/iam/me`,
+                            //   {
+                            //     method: "Get",
+                            //     headers: {
+                            //       "Content-Type": "application/json",
+                            //       "Authorization": `Bearer ${loginResponse.data.accessToken}`,
+                            //     },
+                            //   }
+                            // );
+
+                            // const responseData = await response.json();
+
+                            if (loginResponse.status == 400) {
+                                throw new Error(loginResponse.data.message);
+                            }
+                            if (loginResponse.status == 401) {
+                                throw new Error(loginResponse.data.data.message);
+                            }
+                            let base64decoded = jwtDecode(loginResponse.data.data.accessToken);
+                            // let accessTokenExpires = base64decoded.exp;
+                            let accessTokenExpires = base64decoded.exp && base64decoded.exp * 1000;
+                            const returnResponse = {
+                                accessToken: loginResponse.data.data.accessToken,
+                                refreshToken: loginResponse.data.data.refreshToken,
+                                accessTokenExpires: accessTokenExpires,
+                                ...loginResponse.data.data,
+                            }
+                            return returnResponse;
+                        }
+                    }
+                } catch (error: any) {
+                    throw new Error(error?.response?.data?.message);
+                }
+            },
+        }),
+    ],
+    callbacks: {
+        // @ts-ignore
+        jwt: async ({ token, user }) => {
+            // console.log("JWT callback called");
+            const bufferTime = 60000;
+            if (Date.now() >= (token.accessTokenExpires as number - bufferTime)) {
+                // Call the refresh token function
+                return await refreshAccessToken(token);
+            }
+
+            // If there is no user (first time login or session), we return the user data
+            if (user) {
+                // const base64decoded = jwtDecode(user.accessToken);
+                // Convert from seconds to milliseconds
+                // const accessTokenExpires = base64decoded.exp && base64decoded.exp * 1000; 
+                // const accessTokenExpires = user.accessTokenExpires * 1000; 
+                return {
+                    ...token,
+                    accessToken: user.accessToken,
+                    refreshToken: user.refreshToken,
+                    accessTokenExpires: user.accessTokenExpires,
+                    user: user,  // Include the user data here
+                };
+            }
+
+            return token; // If no update needed, just return the existing token
+        },
+        // @ts-ignore
+        session: async ({ session, token }) => {
+            // console.log("Session callback called");
+
+            const user = token.user || {};  // Default to an empty object if user is undefined or null
+            session.error = token.error ? token.error : null;
+            // if (token.error) {
+            //   return null
+            // }
+            session.user = {
+                ...user, // Include the user info from the token
+                accessToken: token?.accessToken,  // Add the access token to session for client use
+                refreshToken: token?.refreshToken,  // Add refresh token to session for future use
+                accessTokenExpires: token?.accessTokenExpires && token?.accessTokenExpires,  // Store the expiry time
+            };
+            return session;
+
+        },
+    },
+    pages: {
+        signIn: "/auth/login",
+    },
+    secret: process.env.NEXTAUTH_SECRET,
+}
+
+export default authProviders

package/dist/nextAuth/handleLogout.tsx

@@ -0,0 +1,39 @@
+import { ERROR_MESSAGES } from '../constants/error-messages';
+import axios, { AxiosError } from 'axios';
+import { getSession, signOut } from 'next-auth/react';
+
+export async function handleLogout({ toast }: any) {
+    const session = await getSession();
+    // const token = session?.user?.accessToken;
+    const refreshToken = session?.user?.refreshToken; 
+    try {
+        const response = await axios.post(`${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api/iam/logout`, 
+        {
+            refreshToken: refreshToken, // Pass refresh token in body
+        }
+        );
+        console.log("logout response", response);
+
+        if (response?.data?.statusCode === 200) {
+            await signOut({ callbackUrl: '/auth/login' });
+        } else {
+            toast?.current?.show({
+                severity: 'error',
+                summary: ERROR_MESSAGES.LOGOUT_FAILED,
+                detail: `${response?.data?.data?.status}`,
+                life: 3000,
+            });
+        }
+    } catch (error) {
+        const err = error as any;
+        const message =
+            err.response?.data?.data?.message || err.message || ERROR_MESSAGES.LOGOUT_FAILED;
+
+        toast?.current?.show({
+            severity: 'error',
+            summary: ERROR_MESSAGES.LOGOUT_FAILED,
+            detail: message,
+            life: 3000,
+        });
+    }
+}

package/dist/nextAuth/refreshAccessToken.tsx

@@ -0,0 +1,28 @@
+import { ERROR_MESSAGES } from "../constants/error-messages";
+import axios from "axios";
+import { jwtDecode } from "jwt-decode";
+
+export async function refreshAccessToken(token: any) {
+    try {
+      const response = await axios.post(
+        `${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api/iam/refresh-tokens`,
+        { refreshToken: token.refreshToken }
+      );
+  
+      const { accessToken, refreshToken } = response.data.data;
+      const { exp: accessTokenExpires } = jwtDecode<{ exp: number }>(accessToken);
+  
+      return {
+        ...token,
+        accessToken,
+        refreshToken,
+        accessTokenExpires: accessTokenExpires * 1000, // Convert seconds to milliseconds
+      };
+    } catch (error: any) {
+      console.error(ERROR_MESSAGES.FAILED_REFRESH_TOKEN, error.message || error.response?.data);
+      return {
+        // ...token,
+        error: "RefreshAccessTokenError",
+      };
+    }
+  }

package/dist/redux/api/aiInteractionApi.ts

@@ -0,0 +1,59 @@
+import { createApi } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+interface TriggerMcpClientJobRequest {
+    prompt: string;
+    moduleName?:string;
+}
+
+interface TriggerMcpClientJobResponse {
+    statusCode: number;
+    message: string[];
+    error: string;
+    data: any;
+}
+
+interface ApplySolidAiInteractionRequest {
+    id: number;
+}
+
+interface ApplySolidAiInteractionResponse {
+    statusCode: number;
+    message: string[];
+    error: string;
+    data: any; 
+}
+
+
+export type {
+    ApplySolidAiInteractionRequest,
+    ApplySolidAiInteractionResponse,
+    TriggerMcpClientJobRequest,
+    TriggerMcpClientJobResponse
+  };
+
+export const aiInteractionApi = createApi({
+    reducerPath: "aiInteractionApi",
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        triggerMcpClientJob: builder.mutation<TriggerMcpClientJobResponse, TriggerMcpClientJobRequest>({
+            query: (body) => ({
+                url: "/ai-interaction/trigger-mcp-client-job",
+                method: "POST",
+                body,
+            }),
+        }),
+        applySolidAiInteraction: builder.mutation<ApplySolidAiInteractionResponse, ApplySolidAiInteractionRequest>({
+            query: (body) => ({
+                url: `/ai-interaction/${body.id}/apply-solid-ai-interaction`,
+                method: "POST",
+                // body,
+            }),
+        }),
+    }),
+});
+
+export const {
+    useTriggerMcpClientJobMutation,
+    useApplySolidAiInteractionMutation,
+} = aiInteractionApi;

package/dist/redux/api/authApi.ts

@@ -0,0 +1,131 @@
+
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+export const authApi = createApi({
+  reducerPath: "authApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    initateLogin: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/login/initiate",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    confirmOtpLogin: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/login/confirm",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    register: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/register",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    initateRegister: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/register/initiate",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    confirmOtpRegister: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/otp/register/confirm",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    registerPrivate: builder.mutation({
+      query(body) {
+        return {
+          url: "/iam/register-private",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    updateUser: builder.mutation({
+      query: ({ id, data }) => ({
+        url: `/user/${id}/update-user-and-roles`,
+        method: 'PATCH',
+        body: data,
+      }),
+    }),
+    forgotPassword: builder.mutation({
+      query(body) {
+        return {
+          url: "/password/forgot",
+          method: "POST",
+          body,
+        };
+      },
+    }),
+    resetPassword: builder.mutation({
+      query({ token, body }) {
+        return {
+          url: `/password/reset/${token}`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    initiateChangePassword: builder.mutation({
+      query(body) {
+        return {
+          url: '/iam/initiate/forgot-password',
+          method: "POST",
+          body,
+        }
+      }
+    }),
+    confirmForgotPassword: builder.mutation({
+      query(body) {
+        return {
+          url: '/iam/confirm/forgot-password',
+          method: "POST",
+          body
+        }
+      }
+    }),
+    changePassword: builder.mutation({
+      query(body) {
+        return {
+          url: `/iam/change-password`,
+          method: "POST",
+          body,
+        };
+      },
+    }),
+  }),
+});
+
+export const {
+  useRegisterMutation,
+  useRegisterPrivateMutation,
+  useUpdateUserMutation,
+  useForgotPasswordMutation,
+  useResetPasswordMutation,
+  useInitiateChangePasswordMutation,
+  useConfirmForgotPasswordMutation,
+  useChangePasswordMutation,
+  useInitateLoginMutation,
+  useConfirmOtpLoginMutation,
+  useInitateRegisterMutation,
+  useConfirmOtpRegisterMutation,
+} = authApi;

package/dist/redux/api/dashboardApi.ts

@@ -0,0 +1,56 @@
+import { createApi } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+// Types
+interface Dashboard {
+  id: string;
+  name: string;
+  [key: string]: any;
+}
+
+export interface DashboardResponse {
+  records: Dashboard[];
+  meta: {
+    totalCount: number;
+    [key: string]: any;
+  };
+}
+
+export interface SelectionDynamicOption {
+  value: string;
+  label: string;
+}
+
+// API Definition
+export const dashboardApi = createApi({
+  reducerPath: "dashboardApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getDashboard: builder.query<DashboardResponse, string>({
+      query: (qs) => `/dashboard?${qs}`,
+      transformResponse: (response: any) => {
+        // console.log(`Dashboard Response:`, response);
+        if (response.error) {
+          throw new Error(response.error);
+        }
+        return {
+          records: response.data.records,
+          meta: response.data.meta,
+        };
+      },
+    }),
+    getDashboardVariableSelectionDynamicValues: builder.query<SelectionDynamicOption[], string>({
+      query: (qs) => `/dashboard/selection-dynamic-values?${qs}`,
+      transformResponse: (response: any) => {
+        // console.log(`Dashboard Variable Selection Dynamic Values Response:`, response);
+        if (response.error) {
+          throw new Error(response.error);
+        }
+        return response.data;
+      },
+    }),
+  }),
+});
+
+// Hooks
+export const { useGetDashboardQuery, useLazyGetDashboardQuery, useGetDashboardVariableSelectionDynamicValuesQuery, useLazyGetDashboardVariableSelectionDynamicValuesQuery } = dashboardApi;

package/dist/redux/api/dashboardQuestionApi.ts

@@ -0,0 +1,17 @@
+import { createApi } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+// API Definition
+export const dashboardQuestionApi = createApi({
+  reducerPath: "dashboardQuestionApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getDashboardQuestionDataById: builder.query({
+      query: ({ id, qs }) => `/dashboard-question/${id}/data?${qs}`,
+    }),
+
+  }),
+});
+
+// Hooks
+export const { useGetDashboardQuestionDataByIdQuery, useLazyGetDashboardQuestionDataByIdQuery } = dashboardQuestionApi;

package/dist/redux/api/exportTemplateApi.tsx

@@ -0,0 +1,59 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const exportTemplateApi = createApi({
+    reducerPath: 'exportTemplateApi',
+    baseQuery: baseQueryWithAuth,
+    tagTypes: ['ExportTemplates'],
+    endpoints: (builder) => ({
+        createExportTemplate: builder.mutation({
+            query: (templateData) => ({
+                url: '/export-template',
+                method: 'POST',
+                body: templateData
+            }),
+            invalidatesTags: ['ExportTemplates'],
+        }),
+        getExportTemplates: builder.query({
+            query: () => {
+                return `/export-template`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            },
+            providesTags: ['ExportTemplates'],
+        }),
+        createExportSync: builder.mutation({
+            query: ({id}) => ({
+                url: `/export-template/${id}/startExport/sync`,
+            }),
+            transformResponse: (response: any) => {
+                return {
+                    file: response
+                }
+            }
+        }),
+        createExportAsync: builder.mutation({
+            query: ({id,templateData}) => ({
+                url: `/export-template/${id}/startExport/async`,
+                method: 'POST',
+                body: templateData
+            }),
+        }),
+         deleteExportTemplate: builder.mutation({
+            query: (id) => ({
+                url: `/export-template/${id}`,
+                method: 'DELETE',
+            }),
+            invalidatesTags: ['ExportTemplates'],
+        }),
+    })
+})
+
+export const { useCreateExportTemplateMutation,useGetExportTemplatesQuery,useCreateExportSyncMutation,useCreateExportAsyncMutation,useDeleteExportTemplateMutation } = exportTemplateApi