@solidstarters/solid-core-ui 1.1.69 → 1.1.71

package/dist/redux/api/countryApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const countriesApi = createApi({
+    reducerPath: 'countriesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getCountries: builder.query({
+            query: (qs) => {
+                return `/custom-countries?&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getCountryById: builder.query({
+            query: (id) => `/custom-countries/${id}`,
+        }),
+        createCountry: builder.mutation({
+            query: (country) => ({
+                url: '/custom-countries',
+                method: 'POST',
+                body: country
+            }),
+        }),
+        updateCountry: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/custom-countries/${id}`,
+                method: 'Patch',
+                body: data,
+            }),
+        }),
+
+        deleteMultipleCountries: builder.mutation({
+            query: (data) => ({
+                url: `/custom-countries/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteCountry: builder.mutation({
+            query: (id) => ({
+                url: `/custom-countries/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetCountriesQuery, useCreateCountryMutation, useDeleteCountryMutation, useDeleteMultipleCountriesMutation, useGetCountriesQuery, useGetCountryByIdQuery, useLazyGetCountryByIdQuery, usePrefetch, useUpdateCountryMutation } = countriesApi  

package/dist/redux/api/fetchBaseQuery.tsx

@@ -0,0 +1,15 @@
+import { fetchBaseQuery } from "@reduxjs/toolkit/dist/query";
+import { getSession } from "next-auth/react";
+
+const baseUrl = `${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api`; // Base URL for the API endpoints
+// Updated fetchBaseQuery to include accessToken in headers
+export const baseQueryWithAuth = fetchBaseQuery({
+    baseUrl,
+    prepareHeaders: async (headers) => {
+        const session = await getSession(); // Fetch session data
+        if (session?.user.accessToken) {
+            headers.set('authorization', `Bearer ${session?.user?.accessToken}`); // Add access token to headers
+        }
+        return headers;
+    },
+});

package/dist/redux/api/fieldApi.ts

@@ -0,0 +1,78 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const fieldsApi = createApi({
+    reducerPath: 'fieldApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getfields: builder.query({
+            query: (qs) => {
+                return `/field-metadata?populate[0]=model&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+
+        getfieldById: builder.query({
+            query: (id) => `/field-metadata/${id}`,
+        }),
+        getFieldDefaultMetaData: builder.query({
+            query: () => `/field-metadata/default`,
+        }),
+        getSelectionDynamicValues: builder.query({
+            query: (qs) => `/field-metadata/selection-dynamic-values?${qs}`,
+        }),
+        getSelectionDynamicValue: builder.query({
+            query: (qs) => `/field-metadata/selection-dynamic-value?${qs}`,
+        }),
+        createfield: builder.mutation({
+            query: (field) => ({
+                url: '/field-metadata',
+                method: 'POST',
+                body: field
+            }),
+        }),
+        // updatefield: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/field-metadata/${id}`,
+        //         method: 'PUT',
+        //         body: data,
+        //     }), 
+        // }),
+        // deleteMultiplefields: builder.mutation({
+        //     query: (data) => ({
+        //         url: `/field/bulk/`,
+        //         method: 'DELETE',
+        //         body:data
+        //     }),
+        // }),
+        deletefield: builder.mutation({
+            query: (id) => ({
+                url: `/field/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const {
+    useGetfieldsQuery,
+    useLazyGetfieldsQuery,
+    useLazyGetfieldByIdQuery,
+    useGetFieldDefaultMetaDataQuery,
+    useGetSelectionDynamicValuesQuery,
+    useLazyGetSelectionDynamicValuesQuery,
+    useGetSelectionDynamicValueQuery,
+    useLazyGetSelectionDynamicValueQuery,
+    useLazyGetFieldDefaultMetaDataQuery,
+    useGetfieldByIdQuery,
+    useCreatefieldMutation,
+    useDeletefieldMutation
+} = fieldsApi  

package/dist/redux/api/mediaApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const mediaApi = createApi({
+    reducerPath: 'mediaApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getMedias: builder.query({
+            query: (qs) => {
+                return `/media?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getMediaById: builder.query({
+            query: (id) => `/media/${id}`,
+        }),
+        createMedia: builder.mutation({
+            query: (Media) => ({
+                url: '/media',
+                method: 'POST',
+                body: Media
+            }),
+        }),
+        updateMedia: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/media/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMedias: builder.mutation({
+            query: (data) => ({
+                url: `/media/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteMedia: builder.mutation({
+            query: (id) => ({
+                url: `/media/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetMediasQuery, useLazyGetMediaByIdQuery, useLazyGetMediasQuery, useGetMediaByIdQuery, useCreateMediaMutation, useUpdateMediaMutation, useDeleteMediaMutation, useDeleteMultipleMediasMutation } = mediaApi  

package/dist/redux/api/mediaStorageProviderApi.ts

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const mediaStorageProviderApi = createApi({
+    reducerPath: 'mediaStorageProviderApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getMediaStorageProviders: builder.query({
+            query: (qs) => {
+                return `/media-storage-provider-metadata?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getMediaStorageProivderById: builder.query({
+            query: (id) => `/media-storage-provider-metadata/${id}`,
+        }),
+        createMediaStorageProivder: builder.mutation({
+            query: (MediaStorageProivder) => ({
+                url: '/media-storage-provider-metadata',
+                method: 'POST',
+                body: MediaStorageProivder
+            }),
+        }),
+        updateMediaStorageProivder: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/media-storage-provider-metadata/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMediaStorageProviders: builder.mutation({
+            query: (data) => ({
+                url: `/media-storage-provider-metadata/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteMediaStorageProivder: builder.mutation({
+            query: (id) => ({
+                url: `/media-storage-provider-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetMediaStorageProvidersQuery, useLazyGetMediaStorageProivderByIdQuery, useLazyGetMediaStorageProvidersQuery, useGetMediaStorageProivderByIdQuery, useCreateMediaStorageProivderMutation, useUpdateMediaStorageProivderMutation, useDeleteMediaStorageProivderMutation, useDeleteMultipleMediaStorageProvidersMutation } = mediaStorageProviderApi  

package/dist/redux/api/menuApi.tsx

@@ -0,0 +1,55 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const menusApi = createApi({
+    reducerPath: 'menuApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmenus: builder.query({
+            query: (qs) => {
+                return `/radix-menu-v2?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmenuById: builder.query({
+            query: (id) => `/menu/${id}`,
+        }),
+        createmenu: builder.mutation({
+            query: (menu) => ({
+                url: '/menu',
+                method: 'POST',
+                body: menu
+            }),
+        }),
+        updatemenu: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/menu/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMenus: builder.mutation({
+            query: (data) => ({
+                url: `/menu/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletemenu: builder.mutation({
+            query: (id) => ({
+                url: `/menu/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetmenusQuery, useLazyGetmenusQuery, useLazyGetmenuByIdQuery, useGetmenuByIdQuery, useUpdatemenuMutation, useCreatemenuMutation, useDeletemenuMutation, useDeleteMultipleMenusMutation } = menusApi  

package/dist/redux/api/menuItemsApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const menuItemsApi = createApi({
+    reducerPath: 'menuItemApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmenuItems: builder.query({
+            query: (qs) => {
+                return `/radix-menu-item-v2?populate[]=menu&populate[]=parentMenuItems&populate[]=category&${qs}`
+            },
+            // query: () => '/menuItem?populate[]=menu&populate[]=parentMenuItem',
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmenuItemById: builder.query({
+            query: (id) => `/radix-menu-item-v2/${id}?populate[]=menu&populate[]=parentMenuItems&populate[]=category&populateMedia[]=menuIcon`,
+        }),
+        createmenuItem: builder.mutation({
+            query: (menuItem) => ({
+                url: '/radix-menu-item-v2',
+                method: 'POST',
+                body: menuItem
+            })
+        }),
+        updatemenuItem: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-menu-item-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleMenuItems: builder.mutation({
+            query: (data) => ({
+                url: `/menuItem/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletemenuItem: builder.mutation({
+            query: (id) => ({
+                url: `/menuItem/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useGetmenuItemsQuery, useLazyGetmenuItemsQuery,useLazyGetmenuItemByIdQuery, useDeleteMultipleMenuItemsMutation, useGetmenuItemByIdQuery, useUpdatemenuItemMutation, useCreatemenuItemMutation, useDeletemenuItemMutation } = menuItemsApi  

package/dist/redux/api/modelApi.ts

@@ -0,0 +1,77 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const modelsApi = createApi({
+    reducerPath: 'modelApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getModels: builder.query({
+            query: (qs) => {
+                return `/model-metadata?&populate[1]=userKeyField&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmodelById: builder.query({
+            query: (id) => `/model-metadata/${id}?populate[0]=fields&populate[1]=module&&populate[2]=fields.mediaStorageProvider&populate[3]=parentModel`,
+        }),
+        createmodel: builder.mutation({
+            query: (model) => ({
+                url: '/model-metadata',
+                method: 'POST',
+                body: model
+            }),
+        }),
+        generateCodeForModel: builder.mutation({
+            query: (model) => ({
+                url: `/model-metadata/${model.id}/generate-code`,
+                method: 'POST',
+                body: model
+            }),
+        }),
+       
+        updatemodel: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/model-metadata/${id}`,
+                method: 'Put',
+                body: data,
+            }), 
+        }),
+        // deleteMultiplemodels: builder.mutation({
+        //     query: (data) => ({
+        //         url: `/model/bulk/`,
+        //         method: 'DELETE',
+        //         body:data
+        //     }),
+        // }),
+        deleteMultipleModels: builder.mutation({
+            query: (data) => ({
+                url: `/model-metadata/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        deletemodel: builder.mutation({
+            query: (id) => ({
+                url: `/model-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+        updateUserKey: builder.mutation({
+            query: (data) => ({
+                url: `/model-metadata/update-user-key`,
+                method: 'POST',
+                body: data,
+            }), 
+        }),
+    })
+})
+
+export const { useGetModelsQuery,useLazyGetModelsQuery, useLazyGetmodelByIdQuery, useGetmodelByIdQuery, useCreatemodelMutation,useGenerateCodeForModelMutation,useUpdatemodelMutation, useDeleteMultipleModelsMutation ,useDeletemodelMutation, useUpdateUserKeyMutation } = modelsApi  

package/dist/redux/api/moduleApi.ts

@@ -0,0 +1,72 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const modulesApi = createApi({
+    reducerPath: 'moduleApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getmodules: builder.query({
+            query: (qs) => {
+                return `/module-metadata?${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getmoduleById: builder.query({
+            query: (id) => `/module-metadata/${id}`,
+        }),
+        createmodule: builder.mutation({
+            query: (module) => ({
+                url: '/module-metadata',
+                method: 'POST',
+                body: module
+            }),
+        }),
+        generateCodeFormodule: builder.mutation({
+            query: (module) => ({
+                url: `/module-metadata/${module.id}/generate-code`,
+                method: 'POST',
+                body: module
+            }),
+        }),
+        refreshPermissions: builder.mutation({
+            query: (module) => ({
+                url: `/module-metadata/refresh-permission`,
+                method: 'POST',
+                body: module
+            }),
+        }),
+        updatemodule: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/module-metadata/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultiplemodules: builder.mutation({
+            query: (data) => ({
+                url: `/module-metadata/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletemodule: builder.mutation({
+            query: (id) => ({
+                url: `/module-metadata/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+        getDefaultDataSource: builder.query({
+            query: () => `/module-metadata/fetch-default-datasource`,
+        }),
+    })
+})
+
+export const { useGetmodulesQuery, useLazyGetmodulesQuery, useLazyGetmoduleByIdQuery, useGetmoduleByIdQuery, useCreatemoduleMutation, useGenerateCodeFormoduleMutation, useRefreshPermissionsMutation, useUpdatemoduleMutation, useDeletemoduleMutation, useDeleteMultiplemodulesMutation, useGetDefaultDataSourceQuery, useLazyGetDefaultDataSourceQuery } = modulesApi  

package/dist/redux/api/orderAttributeApi.tsx

@@ -0,0 +1,37 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const orderAttributeApi = createApi({
+    reducerPath: 'orderAttribute',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getRadixModelMetadataOrderAttributes: builder.query({
+            query: (radixModelMetadata) => {
+                return `radix-model-metadata-v2?populate[]=orderAttributeMetadatas&filters[name][$eqi]=${radixModelMetadata}`
+            }
+        }),
+        createOrderAttribute: builder.mutation({
+            query: (orderAttribute) => ({
+                url: '/radix-order-attribute-metadata-v2',
+                method: 'POST',
+                body: orderAttribute
+            })
+        }),
+        deleteMultipleOrderAttributes: builder.mutation({
+            query: (data) => ({
+                url: `/radix-order-attribute-metadata-v2/bulk/`,
+                method: 'DELETE',
+                body:data
+            }),
+        }),
+        updateOrderAttribute: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/radix-order-attribute-metadata-v2/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+    })
+})
+
+export const { useUpdateOrderAttributeMutation, useLazyGetRadixModelMetadataOrderAttributesQuery } = orderAttributeApi  

package/dist/redux/api/permissionApi.ts

@@ -0,0 +1,32 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { baseQueryWithAuth } from "./fetchBaseQuery";
+
+export const permissionApi = createApi({
+  reducerPath: "permissionApi",
+  baseQuery: baseQueryWithAuth,
+  endpoints: (builder) => ({
+    getpermissions: builder.query({
+      query: (qs) => {
+        return `/permissions?${qs}`
+      },
+      transformResponse: (response: any) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return {
+            records: response.data.records,
+            meta: response.data.meta
+        }
+      }
+    }),
+    getpermissionsById: builder.query({
+        query: (id) => `/permissions/${id}?offset=0&limit=5`,
+    }),
+  }),
+});
+
+export const {
+  useGetpermissionsByIdQuery,
+  useGetpermissionsQuery,
+  useLazyGetpermissionsQuery
+} = permissionApi;

package/dist/redux/api/pincodeApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const pincodesApi = createApi({
+    reducerPath: 'pincodesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getPincodes: builder.query({
+            query: (qs) => {
+                return `/pincode?populate[]=city&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getPincodeById: builder.query({
+            query: (id) => `/pincode/${id}?populate[]=city`,
+        }),
+        createPincode: builder.mutation({
+            query: (pincode) => ({
+                url: '/pincode',
+                method: 'POST',
+                body: pincode
+            }),
+        }),
+        // updatePincode: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/pincode/${id}`,
+        //         method: 'Patch',
+        //         body: data,
+        //     }),
+        // }),
+
+        deleteMultiplePincodes: builder.mutation({
+            query: (data) => ({
+                url: `/pincode/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deletePincode: builder.mutation({
+            query: (id) => ({
+                url: `/pincode/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetPincodesQuery, useCreatePincodeMutation, useDeletePincodeMutation, useDeleteMultiplePincodesMutation, useGetPincodesQuery, useGetPincodeByIdQuery, useLazyGetPincodeByIdQuery, usePrefetch } = pincodesApi