@solidxai/core-ui 0.1.1 → 0.1.2

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  

package/src/redux/api/roleApi.ts

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

package/src/redux/api/solidActionApi.ts

@@ -1,66 +0,0 @@
-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/solidChatterMessageApi.ts

@@ -1,25 +0,0 @@
-import { createApi } from '@reduxjs/toolkit/query/react';
-import { baseQueryWithAuth } from './fetchBaseQuery';
-
-export const solidChatterMessageApi = createApi({
-    reducerPath: 'solidChatterMessageApi',
-    baseQuery: baseQueryWithAuth,
-    endpoints: (builder) => ({
-        getchatterMessage: builder.query({
-            query: ({ entityId, entityName, qs }) => {
-                return `/chatter-message/getChatterMessages/${entityId}/${entityName}?populateMedia[0]=messageAttachments&${qs}`
-            },
-        }),
-        createChatterMessage: builder.mutation({
-            query: (data) => {
-                return {
-                    url: '/chatter-message',
-                    method: 'POST',
-                    body: data
-                }
-            }
-        })
-    })
-});
-
-export const { useGetchatterMessageQuery, useLazyGetchatterMessageQuery, useCreateChatterMessageMutation } = solidChatterMessageApi;

package/src/redux/api/solidEntityApi.tsx

@@ -1,164 +0,0 @@
-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,
-        tagTypes: [entityName],
-        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 : [],
-                    }
-                },
-                providesTags: (result) =>
-                    result?.records
-                        ? [
-                            ...result.records.map((record: { id: any; }) => ({
-                                type: entityName,
-                                id: record.id,
-                            })),
-                            { type: entityName, id: 'LIST' },
-                        ]
-                        : [{ type: entityName, id: 'LIST' }]
-            }),
-            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
-                    }
-                },
-                providesTags: [{ type: entityName, id: 'KANBAN' }],
-            }),
-            getSolidEntityById: builder.query({
-                query: ({ id, qs }) => {
-                    return `/${kebabEntityName}/${id}?${qs}`
-                },
-                // providesTags: () => [{ type: entityName }],
-                providesTags: (_result, _error, { id }) => [{ type: entityName, id }],
-            }),
-            createSolidEntity: builder.mutation({
-                query: (entity) => ({
-                    url: `/${kebabEntityName}`,
-                    method: 'POST',
-                    body: entity
-                }),
-                invalidatesTags: [{ type: entityName, id: 'LIST' }],
-            }),
-            upsertSolidEntity: builder.mutation({
-                query: (entity) => ({
-                    url: `/${kebabEntityName}/upsert`,
-                    method: 'POST',
-                    body: entity
-                }),
-                invalidatesTags: [{ type: entityName, id: 'LIST' }],
-            }),
-            updateSolidEntity: builder.mutation({
-                query: ({ id, data }) => ({
-                    url: `/${kebabEntityName}/${id}`,
-                    method: 'PUT',
-                    body: data,
-                }),
-                invalidatesTags: (_result, _error, { id }) => [
-                    { type: entityName, id },
-                    { type: entityName, id: 'LIST' },
-                ],
-            }),
-            deleteMultipleSolidEntities: builder.mutation({
-                query: (data) => ({
-                    url: `/${kebabEntityName}/bulk/`,
-                    method: 'DELETE',
-                    body: data
-                }),
-                invalidatesTags: [{ type: entityName, id: 'LIST' }]
-            }),
-            deleteSolidEntity: builder.mutation({
-                query: (id) => ({
-                    url: `/${kebabEntityName}/${id}`,
-                    method: 'DELETE',
-                }),
-                invalidatesTags: (_result, _error, id) => [
-                    { type: entityName, id },
-                    { type: entityName, id: 'LIST' },
-                ],
-            }),
-            recoverSolidEntityById: builder.query({
-                query: (id) => `/${kebabEntityName}/recover/${id}`,
-                providesTags: (_result, _error, id) => [{ type: entityName, id }],
-            }),
-            recoverSolidEntity: builder.mutation({
-                query: (data) => ({
-                    url: `/${kebabEntityName}/bulk-recover/`,
-                    method: 'POST',
-                    body: data
-                }),
-                invalidatesTags: [{ type: entityName, id: 'LIST' }],
-            }),
-            patchUpdateSolidEntity: builder.mutation({
-                query: ({ id, data }) => ({
-                    url: `/${kebabEntityName}/${id}`,
-                    method: 'PATCH',
-                    body: data,
-                }),
-                invalidatesTags: (_result, _error, { id }) => [
-                    { type: entityName, id },
-                    { type: entityName, id: 'LIST' },
-                ],
-            }),
-            publishSolidEntity: builder.mutation({
-                query: (id) => ({
-                    url: `/${kebabEntityName}/${id}/publish`,
-                    method: 'POST'
-                }),
-                invalidatesTags: (_result, _error, id) => [
-                    { type: entityName, id },
-                    { type: entityName, id: 'LIST' }
-                ]
-            }),
-            unpublishSolidEntity: builder.mutation({
-                query: (id) => ({
-                    url: `/${kebabEntityName}/${id}/unpublish`,
-                    method: 'POST'
-                }),
-                invalidatesTags: (_result, _error, id) => [
-                    { type: entityName, id },
-                    { type: entityName, id: 'LIST' }
-                ]
-            }),
-
-        }),
-    });
-};
-
-// export const {
-//     useCreateSolidEntityMutation,
-//     useDeleteMultipleSolidEntitiesMutation,
-//     useDeleteSolidEntityMutation,
-//     useGetSolidEntitiesQuery,
-//     useGetSolidEntityByIdQuery,
-//     useLazyGetSolidEntitiesQuery,
-//     useLazyGetSolidEntityByIdQuery,
-//     usePrefetch,
-//     useUpdateSolidEntityMutation
-// } = solidEntityApi;

package/src/redux/api/solidMenuApi.ts

@@ -1,71 +0,0 @@
-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/solidServiceApi.ts

@@ -1,31 +0,0 @@
-import { createApi } from '@reduxjs/toolkit/query/react';
-import { baseQueryWithAuth } from './fetchBaseQuery';
-
-export const solidServiceApi = createApi({
-    reducerPath: 'solidServiceApi',
-    baseQuery: baseQueryWithAuth,
-    endpoints: (builder) => ({
-        seeder: builder.mutation({
-            query: (name) => ({
-                url: '/seed',
-                method: 'POST',
-                body: {
-                    "seeder": name
-                }
-            }),
-        }),
-        // Add a mutation for calling /code-generation/post-process, which takes an empty body
-        codeGenerationPostProcess: builder.mutation<any, { "runModuleMetadataSeeder": boolean, "runSolidIngestion": boolean }>({
-            query: (payload) => ({
-                url: '/code-generation/post-process',
-                method: 'POST',
-                body: payload
-            }),
-        }),
-    }),
-});
-
-export const {
-    useSeederMutation,
-    useCodeGenerationPostProcessMutation
-} = solidServiceApi;

package/src/redux/api/solidSettingsApi.tsx

@@ -1,83 +0,0 @@
-import { createApi } from '@reduxjs/toolkit/query/react';
-import { baseQueryWithAuth } from './fetchBaseQuery';
-
-export const solidSettingsApi = createApi({
-    reducerPath: 'solidSettingsApi',
-    baseQuery: baseQueryWithAuth,
-    endpoints: (builder) => ({
-        createSolidSettings: builder.mutation({
-            query: (data) => ({
-                url: '/setting',
-                method: 'POST',
-                body: data
-            }),
-        }),
-        getSolidSettings: builder.query({
-            query: () => {
-                return `/setting`
-            },
-        }),
-        getAuthSettings: builder.query({
-            query: () => {
-                console.log(`builder.query running for endpoint /setting/wrapped`);
-                return `/setting/wrapped`;
-            },
-            async onQueryStarted(_arg, { queryFulfilled }) {
-                console.log("[solidSettingsApi] getAuthSettings onQueryStarted");
-                try {
-                    await queryFulfilled;
-                    console.log("[solidSettingsApi] getAuthSettings queryFulfilled");
-                } catch (err) {
-                    console.error("[solidSettingsApi] getAuthSettings queryFulfilled error", err);
-                }
-            },
-        }),
-        getSolidSettingsById: builder.query({
-            query: (id) => `/setting/${id}`,
-        }),
-        updateSolidSettings: builder.mutation({
-            query: ({ id, data }) => ({
-                url: `/setting/${id}`,
-                method: 'PUT',
-                body: data,
-            }),
-        }),
-        bulkUpdateSolidSettings: builder.mutation({
-            query: ({ data }) => ({
-                url: `/setting/bulk`,
-                method: 'PUT',
-                body: data,
-            }),
-        }),
-        bulkUpdateSolidUserSettings: builder.mutation({
-            query: ({ data }) => ({
-                url: `/setting/bulk/user`,
-                method: 'POST',
-                body: data,
-            }),
-        }),
-        getMcpUrl: builder.query({
-            query: (qs) => `/setting/get-mcp-url?${qs}`,
-        }),
-
-    })
-});
-
-if (typeof window !== "undefined") {
-    (window as any).__solidSettingsApi = solidSettingsApi;
-}
-
-export const {
-    useCreateSolidSettingsMutation,
-    useGetSolidSettingsByIdQuery,
-    useGetSolidSettingsQuery,
-    useGetAuthSettingsQuery,
-    useLazyGetAuthSettingsQuery,
-    useLazyGetSolidSettingsQuery,
-    useLazyGetSolidSettingsByIdQuery,
-    useUpdateSolidSettingsMutation,
-    useBulkUpdateSolidSettingsMutation,
-    useBulkUpdateSolidUserSettingsMutation,
-    useGetMcpUrlQuery,
-    useLazyGetMcpUrlQuery
-} = solidSettingsApi;

package/src/redux/api/solidViewApi.ts

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

package/src/redux/api/stateApi.tsx

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