@solidstarters/solid-core-ui 0.1.26

package/src/redux/api/reviewApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const reviewApi = createApi({
+    reducerPath: 'reviewApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getreview: builder.query({
+            query: (qs) => {
+                return `/radix-review-v2?${qs}`
+            }, 
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getreviewById: builder.query({
+            query: (id) => `/radix-review-v2/${id}?populate[]=user`,
+        }),
+        createreview: builder.mutation({
+            query: (review) => ({
+                url: '/radix-review-v2',
+                method: 'POST',
+                body: review
+            }),
+        }),
+        updatereview: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-review-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultiplereviews: builder.mutation({
+            query: (data) => ({
+                url: `/radix-review-v2/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletereview: builder.mutation({
+            query: (id) => ({
+                url: `/radix-review-v2/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetreviewQuery, useLazyGetreviewQuery, useDeleteMultiplereviewsMutation, useCreatereviewMutation, useGetreviewByIdQuery, useUpdatereviewMutation, useDeletereviewMutation } = reviewApi  

package/src/redux/api/roleApi.ts

@@ -0,0 +1,58 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+
+const resourceName = 'role-metadata';
+
+
+
+export const roleApi = createApi({
+  reducerPath: "roleApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getroles: builder.query({
+      query: (qs) => {
+        return `/${resourceName}?offset=0&limit=10&${qs}`
+      },
+    }),
+    getroleById: builder.query({
+      query: (id) => `/${resourceName}/${id}?offset=0&limit=5`,
+    }),
+    createrole: builder.mutation({
+      query: (role) => ({
+        url: '/${resourceName}',
+        method: 'POST',
+        body: role
+      }),
+    }),
+    updaterole: builder.mutation({
+      query: ({ id, data }) => ({
+        url: `/${resourceName}/${id}`,
+        method: 'PATCH',
+        body: data,
+      }),
+    }),
+    deleteMultipleRoles: builder.mutation({
+      query: (data) => ({
+        url: `/${resourceName}/bulk/`,
+        method: 'DELETE',
+        body: data
+      }),
+    }),
+    deleterole: builder.mutation({
+      query: (id) => ({
+        url: `/${resourceName}/${id}`,
+        method: 'DELETE',
+      }),
+    }),
+  }),
+});
+
+export const {
+  useGetrolesQuery,
+  useGetroleByIdQuery,
+  useCreateroleMutation,
+  useLazyGetrolesQuery,
+  useUpdateroleMutation,
+  useDeleteroleMutation
+} = roleApi;

package/src/redux/api/solidActionApi.ts

@@ -0,0 +1,66 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+const resourceName = 'action-metadata';
+
+export const solidActionsApi = createApi({
+    reducerPath: 'actionMetadataApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getSolidActions: 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
+                }
+            }
+        }),
+        getSolidActionById: builder.query({
+            query: (id) => `/${resourceName}/${id}?populate[0]=model&populate[1]=module&populate[2]=view`,
+        }),
+        createSolidAction: builder.mutation({
+            query: (solidAction) => ({
+                url: '/${resourceName}',
+                method: 'POST',
+                body: solidAction
+            }),
+        }),
+        updateSolidAction: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleSolidActions: builder.mutation({
+            query: (data) => ({
+                url: `/${resourceName}/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteSolidAction: builder.mutation({
+            query: (id) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    }),
+});
+
+export const {
+    useGetSolidActionsQuery,
+    useLazyGetSolidActionsQuery,
+    useLazyGetSolidActionByIdQuery,
+    useGetSolidActionByIdQuery,
+    useCreateSolidActionMutation,
+    useUpdateSolidActionMutation,
+    useDeleteSolidActionMutation,
+    useDeleteMultipleSolidActionsMutation
+} = solidActionsApi  

package/src/redux/api/solidEntityApi.tsx

@@ -0,0 +1,86 @@
+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
+                }),
+            }),
+            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',
+                }),
+            }),
+        }),
+    });
+};
+
+// export const {
+//     useCreateSolidEntityMutation,
+//     useDeleteMultipleSolidEntitiesMutation,
+//     useDeleteSolidEntityMutation,
+//     useGetSolidEntitiesQuery,
+//     useGetSolidEntityByIdQuery,
+//     useLazyGetSolidEntitiesQuery,
+//     useLazyGetSolidEntityByIdQuery,
+//     usePrefetch,
+//     useUpdateSolidEntityMutation
+// } = solidEntityApi;

package/src/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/src/redux/api/solidViewApi.ts

@@ -0,0 +1,72 @@
+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,
+    useCreateSolidViewMutation,
+    useUpdateSolidViewMutation,
+    useDeleteSolidViewMutation,
+    useDeleteMultipleSolidViewsMutation
+} = solidViewsApi;

package/src/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/src/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/src/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/src/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;