@solidstarters/solid-core-ui 1.1.210 → 1.1.212

package/src/redux/api/fetchBaseQuery.tsx

@@ -0,0 +1,98 @@
+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;
+    },
+});
+
+// @ts-nocheck
+// import { fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+// import type { FetchBaseQueryError, BaseQueryFn } from "@reduxjs/toolkit/query";
+// import type { FetchArgs } from "@reduxjs/toolkit/query";
+// import { getSession } from "next-auth/react";
+
+// const baseUrl = `${process.env.NEXT_PUBLIC_BACKEND_API_URL}/api`;
+
+// const rawBaseQuery = fetchBaseQuery({
+//     baseUrl,
+//     prepareHeaders: async (headers) => {
+//         const session = await getSession();
+//         if (session?.user.accessToken) {
+//             headers.set('authorization', `Bearer ${session?.user?.accessToken}`);
+//         }
+//         return headers;
+//     },
+// });
+
+// // Wrapper with error handling
+// export const baseQueryWithAuth: BaseQueryFn<string | FetchArgs, unknown, FetchBaseQueryError, {}, {}> = async (args, api, extraOptions) => {
+//     const result = await rawBaseQuery(args, api, extraOptions);
+
+//     if (result.error) {
+//         const status = result.error.status;
+//         const isFetchError = typeof status === 'string' && status === 'FETCH_ERROR';
+
+//         if (typeof window !== 'undefined') {
+//             switch (true) {
+//                 case isFetchError:
+//                     window.location.href = '/offline';
+//                     break;
+//                 case typeof status === 'number' && status >= 500:
+//                     window.location.href = '/server-error';
+//                     break;
+//                 case typeof status === 'number' && status >= 400:
+//                     window.location.href = '/client-error';
+//                     break;
+//             }
+//         }
+//     }
+
+//     return result;
+// };
+
+// // Wrapper fetch to include authentication and error handling
+// export async function baseFetchWithAuth(input: RequestInfo, init: RequestInit = {}) {
+//     const session = await getSession();
+
+//     const headers = new Headers(init.headers || {});
+//     if (session?.user?.accessToken) {
+//         headers.set("Authorization", `Bearer ${session.user.accessToken}`);
+//     }
+
+//     try {
+//         const response = await fetch(input, { ...init, headers });
+
+//         if (!response.ok) {
+//             const status = response.status;
+//             if (typeof window !== 'undefined') {
+//                 if (status >= 500) {
+//                     window.location.href = "/server-error";
+//                 } else if (status >= 400) {
+//                     window.location.href = "/client-error";
+//                 }
+//             }
+//             throw new Error(`HTTP error! status: ${status}`);
+//         }
+
+//         return response;
+//     } catch (error: any) {
+//         console.error('Fetch failed:', error);
+
+//         // You could redirect or render a fallback error here
+//         if (typeof window !== 'undefined') {
+//             window.location.href = "/offline"; // Create this route
+//         }
+
+//         // Re-throw for potential higher-level handling
+//         // throw new Error(`Network error: ${error.message}`);
+//     }
+// }

package/src/redux/api/fieldApi.ts

@@ -0,0 +1,86 @@
+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',
+            }),
+        }),
+        resolveS3Url: builder.mutation({
+            query: (data) => ({
+                url: '/field-metadata/resolve-s3-url',
+                method: 'POST',
+                body: data
+            }),
+        }),
+    })
+})
+
+export const {
+    useGetfieldsQuery,
+    useLazyGetfieldsQuery,
+    useLazyGetfieldByIdQuery,
+    useGetFieldDefaultMetaDataQuery,
+    useGetSelectionDynamicValuesQuery,
+    useLazyGetSelectionDynamicValuesQuery,
+    useGetSelectionDynamicValueQuery,
+    useLazyGetSelectionDynamicValueQuery,
+    useLazyGetFieldDefaultMetaDataQuery,
+    useGetfieldByIdQuery,
+    useCreatefieldMutation,
+    useDeletefieldMutation,
+    useResolveS3UrlMutation
+} = fieldsApi  

package/src/redux/api/importTransactionApi.tsx

@@ -0,0 +1,69 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const importTransactionApi = createApi({
+    reducerPath: 'importTransactionApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        // Get instructions
+        getImportInstructions: builder.query({
+            query: ({ id }) => {
+                return `/import-transaction/import-instructions/${id}`
+            },
+        }),
+        // Get import templates
+        getImportTemplate: builder.query({
+            query: ({ id, format }) => {
+                return `/import-transaction/import-template/${id}/${format}`
+            }
+        }),
+        // create transaction / upload file here
+        createImportTransaction: builder.mutation({
+            query: (templateData) => ({
+                url: '/import-transaction',
+                method: 'POST',
+                body: templateData
+            }),
+        }),
+        // After getting response getting id patch that here and pass     "status": "mapping_created",
+        patchUpdateImportTransaction: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/import-transaction/${id}`,
+                method: 'PATCH',
+                body: data,
+            }),
+        }),
+        // Get Mattping info
+        // Get import templates
+        getImportMappingInfo: builder.query({
+            query: ({ id }) => {
+                return `/import-transaction/${id}/import-mapping-info`
+            }
+        }),
+        createImportSync: builder.mutation({
+            query: ({ id }) => ({
+                url: `/import-transaction/${id}/start-import/sync`,
+                method: 'POST',
+            }),
+        }),
+        createImportAsync: builder.mutation({
+            query: ({ id }) => ({
+                url: `/import-transaction/${id}/start-import/async`,
+                method: 'POST',
+            }),
+        }),
+    })
+})
+
+export const {
+    useGetImportInstructionsQuery,
+    useLazyGetImportInstructionsQuery,
+    useGetImportTemplateQuery,
+    useLazyGetImportTemplateQuery,
+    useCreateImportTransactionMutation,
+    usePatchUpdateImportTransactionMutation,
+    useGetImportMappingInfoQuery,
+    useLazyGetImportMappingInfoQuery,
+    useCreateImportAsyncMutation,
+    useCreateImportSyncMutation
+} = importTransactionApi

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

@@ -0,0 +1,80 @@
+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,
+            }), 
+        }),
+        navigation: builder.query({
+            query: (qs) => `/model-metadata/navigation?${qs}`,
+        }),
+    })
+})
+
+export const { useGetModelsQuery,useLazyGetModelsQuery, useLazyGetmodelByIdQuery, useGetmodelByIdQuery, useCreatemodelMutation,useGenerateCodeForModelMutation,useUpdatemodelMutation, useDeleteMultipleModelsMutation ,useDeletemodelMutation, useUpdateUserKeyMutation,useLazyNavigationQuery } = modelsApi  

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

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=1000&${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;