@solidstarters/solid-core-ui 1.1.69 → 1.1.71

package/dist/redux/api/solidEntityApi.tsx

@@ -0,0 +1,110 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+import { kebabCase } from 'change-case';
+
+export const createSolidEntityApi = (entityName: string) => {
+    const kebabEntityName = kebabCase(entityName);
+
+    return createApi({
+        reducerPath: `genericSolid${entityName}Api`,
+        baseQuery: baseQueryWithAuth,
+        endpoints: (builder) => ({
+            getSolidEntities: builder.query({
+                query: (qs) => {
+                    return `/${kebabEntityName}?&${qs}`
+                },
+                transformResponse: (response: any) => {
+                    if (response.error) {
+                        throw new Error(response.error);
+                    }
+                    return {
+                        records: response.data.records,
+                        meta: response.data.meta,
+                        groupMeta: response?.data?.groupMeta,
+                        groupRecords: response?.data?.groupRecords ? response.data.groupRecords : [],
+                    }
+                }
+            }),
+            getSolidKanbanEntities: builder.query({
+                query: (qs) => {
+                    return `/${kebabEntityName}/group-kanban?&${qs}`
+                },
+                transformResponse: (response: any) => {
+                    if (response.error) {
+                        throw new Error(response.error);
+                    }
+                    return {
+                        records: response.data.records.groupedData,
+                        meta: response.data.meta
+                    }
+                }
+            }),
+            getSolidEntityById: builder.query({
+                query: ({ id, qs }) => `/${kebabEntityName}/${id}?${qs}`,
+            }),
+            createSolidEntity: builder.mutation({
+                query: (entity) => ({
+                    url: `/${kebabEntityName}`,
+                    method: 'POST',
+                    body: entity
+                }),
+            }),
+            upsertSolidEntity: builder.mutation({
+                query: (entity) => ({
+                    url: `/${kebabEntityName}/upsert`,
+                    method: 'POST',
+                    body: entity
+                }),
+            }),
+            updateSolidEntity: builder.mutation({
+                query: ({ id, data }) => ({
+                    url: `/${kebabEntityName}/${id}`,
+                    method: 'PUT',
+                    body: data,
+                }),
+            }),
+            deleteMultipleSolidEntities: builder.mutation({
+                query: (data) => ({
+                    url: `/${kebabEntityName}/bulk/`,
+                    method: 'DELETE',
+                    body: data
+                }),
+            }),
+            deleteSolidEntity: builder.mutation({
+                query: (id) => ({
+                    url: `/${kebabEntityName}/${id}`,
+                    method: 'DELETE',
+                }),
+            }),
+            recoverSolidEntityById: builder.query({
+                query: (id) => `/${kebabEntityName}/recover/${id}`,
+            }),
+            recoverSolidEntity: builder.mutation({
+                query: (data) => ({
+                    url: `/${kebabEntityName}/bulk-recover/`,
+                    method: 'POST',
+                    body: data
+                })
+            }),
+            patchUpdateSolidEntity: builder.mutation({
+                query: ({ id, data }) => ({
+                    url: `/${kebabEntityName}/${id}`,
+                    method: 'PATCH',
+                    body: data,
+                }),
+            }),
+        }),
+    });
+};
+
+// export const {
+//     useCreateSolidEntityMutation,
+//     useDeleteMultipleSolidEntitiesMutation,
+//     useDeleteSolidEntityMutation,
+//     useGetSolidEntitiesQuery,
+//     useGetSolidEntityByIdQuery,
+//     useLazyGetSolidEntitiesQuery,
+//     useLazyGetSolidEntityByIdQuery,
+//     usePrefetch,
+//     useUpdateSolidEntityMutation
+// } = solidEntityApi;

package/dist/redux/api/solidMenuApi.ts

@@ -0,0 +1,71 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+const resourceName = 'menu-item-metadata';
+
+export const solidMenusApi = createApi({
+    reducerPath: 'solidMenuApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getSolidMenus: builder.query({
+            query: (qs) => {
+                return `/${resourceName}?populate[0]=module&populate[1]=action&populate[2]=parentMenuItem&populate[3]=roles&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getSolidMenuById: builder.query({
+            query: (id) => `/${resourceName}/${id}?populate[0]=module&populate[1]=action&populate[2]=parentMenuItem&populate[3]=roles`,
+        }),
+        getSolidMenuBasedOnRole: builder.query({
+            query: () => `/${resourceName}/me`,
+        }),
+        createSolidMenu: builder.mutation({
+            query: (solidMenu) => ({
+                url: '/${resourceName}',
+                method: 'POST',
+                body: solidMenu
+            }),
+        }),
+        updateSolidMenu: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleSolidMenus: builder.mutation({
+            query: (data) => ({
+                url: `/${resourceName}/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteSolidMenu: builder.mutation({
+            query: (id) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+});
+
+export const {
+    useGetSolidMenusQuery,
+    useLazyGetSolidMenusQuery,
+    useLazyGetSolidMenuByIdQuery,
+    useGetSolidMenuBasedOnRoleQuery,
+    useLazyGetSolidMenuBasedOnRoleQuery,
+    useGetSolidMenuByIdQuery,
+    useCreateSolidMenuMutation,
+    useUpdateSolidMenuMutation,
+    useDeleteSolidMenuMutation,
+    useDeleteMultipleSolidMenusMutation
+} = solidMenusApi;

package/dist/redux/api/solidSettingsApi.tsx

@@ -0,0 +1,47 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const solidSettingsApi = createApi({
+    reducerPath: 'solidSettingsApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        createSolidSettings: builder.mutation({
+            query: (data) => ({
+                url: '/setting',
+                method: 'POST',
+                body: data
+            }),
+        }),
+        getSolidSettings: builder.query({
+            query: () => {
+                return `/setting`
+            },
+        }),
+        getAuthSettings: builder.query({
+            query: () => {
+                return `/setting/wrapped`
+            },
+        }),
+        getSolidSettingsById: builder.query({
+            query: (id) => `/setting/${id}`,
+        }),
+        updateSolidSettings: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/setting/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+    })
+});
+
+export const {
+    useCreateSolidSettingsMutation,
+    useGetSolidSettingsByIdQuery,
+    useGetSolidSettingsQuery,
+    useGetAuthSettingsQuery,
+    useLazyGetAuthSettingsQuery,
+    useLazyGetSolidSettingsQuery,
+    useLazyGetSolidSettingsByIdQuery,
+    useUpdateSolidSettingsMutation,
+} = solidSettingsApi;

package/dist/redux/api/solidViewApi.ts

@@ -0,0 +1,73 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+const resourceName = 'view-metadata';
+
+export const solidViewsApi = createApi({
+    reducerPath: 'viewMetadataApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getSolidViews: builder.query({
+            query: (qs) => {
+                return `/${resourceName}?populate[0]=model&populate[1]=module&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getSolidViewLayout: builder.query({
+            query: (qs) => {
+                return `/${resourceName}/custom/layout?${qs}`;
+            }
+        }),
+        getSolidViewById: builder.query({
+            query: (id) => `/${resourceName}/${id}?populate[0]=model&populate[1]=module`,
+        }),
+        createSolidView: builder.mutation({
+            query: (solidView) => ({
+                url: '/${resourceName}',
+                method: 'POST',
+                body: solidView
+            }),
+        }),
+        updateSolidView: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleSolidViews: builder.mutation({
+            query: (data) => ({
+                url: `/${resourceName}/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteSolidView: builder.mutation({
+            query: (id) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    }),
+});
+
+export const {
+    useGetSolidViewsQuery,
+    useLazyGetSolidViewsQuery,
+    useLazyGetSolidViewByIdQuery,
+    useGetSolidViewByIdQuery,
+    useGetSolidViewLayoutQuery,
+    useLazyGetSolidViewLayoutQuery,
+    useCreateSolidViewMutation,
+    useUpdateSolidViewMutation,
+    useDeleteSolidViewMutation,
+    useDeleteMultipleSolidViewsMutation
+} = solidViewsApi;

package/dist/redux/api/stateApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const statesApi = createApi({
+    reducerPath: 'statesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getStates: builder.query({
+            query: (qs) => {
+                return `/state?populate[]=country&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getStateById: builder.query({
+            query: (id) => `/state/${id}?populate[]=country`,
+        }),
+        createState: builder.mutation({
+            query: (state) => ({
+                url: '/state',
+                method: 'POST',
+                body: state
+            }),
+        }),
+        // updateState: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/state/${id}`,
+        //         method: 'Patch',
+        //         body: data,
+        //     }),
+        // }),
+
+        deleteMultipleStates: builder.mutation({
+            query: (data) => ({
+                url: `/state/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteState: builder.mutation({
+            query: (id) => ({
+                url: `/state/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetStatesQuery, useCreateStateMutation, useDeleteStateMutation, useDeleteMultipleStatesMutation, useGetStatesQuery, useGetStateByIdQuery, useLazyGetStateByIdQuery, usePrefetch } = statesApi  

package/dist/redux/api/tagApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const tagApi = createApi({
+    reducerPath: 'tagApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        gettags: builder.query({
+            query: (qs) => {
+                return `/radix-tag-v2`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        gettagById: builder.query({
+            query: (id) => `/radix-tag-v2/${id}`,
+        }),
+        createtag: builder.mutation({
+            query: (tag) => ({
+                url: '/radix-tag-v2',
+                method: 'POST',
+                body: tag
+            })
+        }),
+        updatetag: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-tag-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleTags: builder.mutation({
+            query: (data) => ({
+                url: `/radix-tag-v2/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletetag: builder.mutation({
+            query: (id) => ({
+                url: `/radix-tag-v2/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGettagsQuery, useLazyGettagsQuery, useDeleteMultipleTagsMutation, useGettagByIdQuery, useUpdatetagMutation, useCreatetagMutation, useDeletetagMutation } = tagApi  

package/dist/redux/api/tagGroupApi.tsx

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const tagGroupApi = createApi({
+    reducerPath: 'tagGroupApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        gettagGroups: builder.query({
+            query: (qs) => {
+                return `/tagGroup?populate[]=tags&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        gettagGroupById: builder.query({
+            query: (id) => `/tagGroup/${id}?populate[]=tags`,
+        }),
+        createtagGroup: builder.mutation({
+            query: (tagGroup) => ({
+                url: '/tagGroup',
+                method: 'POST',
+                body: tagGroup
+            })
+        }),
+        updatetagGroup: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/tagGroup/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleTagGroups: builder.mutation({
+            query: (data) => ({
+                url: `/tagGroup/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletetagGroup: builder.mutation({
+            query: (id) => ({
+                url: `/tagGroup/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGettagGroupsQuery, useLazyGettagGroupsQuery, useGettagGroupByIdQuery, useUpdatetagGroupMutation, useCreatetagGroupMutation, useDeletetagGroupMutation, useDeleteMultipleTagGroupsMutation } = tagGroupApi  

package/dist/redux/api/testApi.ts

@@ -0,0 +1,21 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const testApi = createApi({
+    reducerPath: 'testApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        seeder: builder.mutation({
+            query: (name) => ({
+                url: '/test/seed',
+                method: 'POST',
+                body: {
+                    "seeder": name
+                }
+            }),
+        }),
+    })
+
+});
+
+export const {useSeederMutation} = testApi

package/dist/redux/api/userApi.ts

@@ -0,0 +1,120 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+const resourceName = 'user';
+
+export const userApi = createApi({
+  reducerPath: "userApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getusers: builder.query({
+      query: (qs) => {
+        return `/${resourceName}?${qs}`
+      },
+      // query: () => '/${resourceName}?offset=0&limit=5',
+    }),
+    getusersById: builder.query({
+      query: (id) => `/${resourceName}/${id}?populate[0]=roles`,
+    }),
+    checkIfPermissionExists: builder.query({
+      query: (query) => `/${resourceName}/permissions-exists?${query}`,
+    }),
+    
+    registerUser: builder.mutation({
+      query: (user) => ({
+        url: `/${resourceName}/roles`,
+        method: 'POST',
+        body: user
+      }),
+    }),
+    createuserrole: builder.mutation({
+      query: (role) => ({
+        url: `/${resourceName}/roles`,
+        method: 'POST',
+        body: role
+      }),
+    }),
+    createuserrolebulk: builder.mutation({
+      query: (role) => ({
+        url: `/${resourceName}/roles/bulk`,
+        method: 'POST',
+        body: role
+      }),
+    }),
+    updateProfile: builder.mutation({
+      query(body) {
+        return {
+          url: `/me/update`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    updateSession: builder.query({
+      query() {
+        return {
+          url: `/auth/session?update`,
+        };
+      },
+    }),
+    updatePassword: builder.mutation({
+      query(body) {
+        return {
+          url: `/me/update_password`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    uploadAvatar: builder.mutation({
+      query(body) {
+        return {
+          url: `/me/upload_avatar`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    updateUser: builder.mutation({
+      query({ id, body }) {
+        return {
+          url: `/admin/${resourceName}/${id}`,
+          method: "PUT",
+          body,
+        };
+      },
+    }),
+    deleteMultipleUsers: builder.mutation({
+      query: (data) => ({
+        url: `/${resourceName}/bulk/`,
+        method: 'DELETE',
+        body: data
+      }),
+    }),
+    deleteUser: builder.mutation({
+      query: (id) => ({
+        url: `/${resourceName}/${id}`,
+        method: 'DELETE',
+      }),
+    }),
+  }),
+});
+
+export const {
+  useUpdateProfileMutation,
+  useLazyUpdateSessionQuery,
+  useLazyCheckIfPermissionExistsQuery,
+  useUpdatePasswordMutation,
+  useUploadAvatarMutation,
+  // useUpdateUserMutation,
+  useDeleteUserMutation,
+  useGetusersQuery,
+  useLazyGetusersQuery,
+  useGetusersByIdQuery,
+  useCreateuserroleMutation,
+  useCreateuserrolebulkMutation,
+  useDeleteMultipleUsersMutation,
+  useLazyGetusersByIdQuery,
+  useRegisterUserMutation,
+  useUpdateSessionQuery
+} = userApi;

package/dist/redux/features/authSlice.ts

@@ -0,0 +1,19 @@
+import { createSlice } from '@reduxjs/toolkit';
+
+const authSlice = createSlice({
+    name: 'authentication',
+    initialState: {
+        token: null, // Store the JWT token here
+    },
+    reducers: {
+        setToken: (state, action) => {
+            state.token = action.payload;
+        },
+        logout: (state) => {
+            state.token = null;
+        },
+    },
+});
+
+export const { setToken, logout } = authSlice.actions;
+export default authSlice.reducer;

package/dist/redux/features/dataViewSlice.ts

@@ -0,0 +1,26 @@
+// store/features/dataViewSlice.ts
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+
+export interface DataViewState {
+  dataView: 'LIST' | 'GRID';
+}
+
+const initialState: DataViewState = {
+  dataView: 'LIST',
+};
+
+const dataViewSlice = createSlice({
+  name: 'view',
+  initialState,
+  reducers: {
+    gridView: (state) => {
+      state.dataView = 'GRID';
+    },
+    listView: (state) => {
+      state.dataView = 'LIST';
+    },
+  },
+});
+
+export const { gridView, listView } = dataViewSlice.actions;
+export default dataViewSlice.reducer;

package/dist/redux/features/navbarSlice.ts

@@ -0,0 +1,21 @@
+import { createSlice } from '@reduxjs/toolkit';
+const navbarSlice = createSlice({
+    name: 'navbar',
+    initialState: {
+        visibleNavbar: false,
+    },
+    reducers: {
+        showNavbar: (state) => {
+            state.visibleNavbar = true
+        },
+        hideNavbar: (state) => {
+            state.visibleNavbar = false
+        },
+        toggleNavbar(state) {
+            state.visibleNavbar = state.visibleNavbar === true ? false : true;
+        },
+    }
+})
+
+export const { showNavbar, hideNavbar, toggleNavbar } = navbarSlice.actions;
+export default navbarSlice.reducer