@solidstarters/solid-core-ui 1.1.74 → 1.1.75

package/src/redux/api/countryApi.tsx

@@ -1,56 +0,0 @@
-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/src/redux/api/fetchBaseQuery.tsx

@@ -1,15 +0,0 @@
-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/src/redux/api/fieldApi.ts

@@ -1,78 +0,0 @@
-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/src/redux/api/mediaApi.ts

@@ -1,55 +0,0 @@
-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/src/redux/api/mediaStorageProviderApi.ts

@@ -1,55 +0,0 @@
-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/src/redux/api/menuApi.tsx

@@ -1,55 +0,0 @@
-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/src/redux/api/menuItemsApi.tsx

@@ -1,56 +0,0 @@
-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/src/redux/api/modelApi.ts

@@ -1,77 +0,0 @@
-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/src/redux/api/moduleApi.ts

@@ -1,72 +0,0 @@
-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/src/redux/api/orderAttributeApi.tsx

@@ -1,37 +0,0 @@
-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/src/redux/api/permissionApi.ts

@@ -1,32 +0,0 @@
-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/src/redux/api/pincodeApi.tsx

@@ -1,56 +0,0 @@
-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