@solidstarters/solid-core-ui 1.1.211 → 1.1.212

package/dist/redux/api/solidActionApi.ts

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

package/dist/redux/api/solidChatterMessageApi.ts

@@ -0,0 +1,25 @@
+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/dist/redux/api/solidEntityApi.tsx

@@ -0,0 +1,164 @@
+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/dist/redux/api/solidMenuApi.ts

@@ -0,0 +1,71 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+const resourceName = 'menu-item-metadata';
+
+export const solidMenusApi = createApi({
+    reducerPath: 'solidMenuApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getSolidMenus: builder.query({
+            query: (qs) => {
+                return `/${resourceName}?populate[0]=module&populate[1]=action&populate[2]=parentMenuItem&populate[3]=roles&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getSolidMenuById: builder.query({
+            query: (id) => `/${resourceName}/${id}?populate[0]=module&populate[1]=action&populate[2]=parentMenuItem&populate[3]=roles`,
+        }),
+        getSolidMenuBasedOnRole: builder.query({
+            query: () => `/${resourceName}/me`,
+        }),
+        createSolidMenu: builder.mutation({
+            query: (solidMenu) => ({
+                url: '/${resourceName}',
+                method: 'POST',
+                body: solidMenu
+            }),
+        }),
+        updateSolidMenu: builder.mutation({
+            query: ({ id, data }) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'PUT',
+                body: data,
+            }),
+        }),
+        deleteMultipleSolidMenus: builder.mutation({
+            query: (data) => ({
+                url: `/${resourceName}/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteSolidMenu: builder.mutation({
+            query: (id) => ({
+                url: `/${resourceName}/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+});
+
+export const {
+    useGetSolidMenusQuery,
+    useLazyGetSolidMenusQuery,
+    useLazyGetSolidMenuByIdQuery,
+    useGetSolidMenuBasedOnRoleQuery,
+    useLazyGetSolidMenuBasedOnRoleQuery,
+    useGetSolidMenuByIdQuery,
+    useCreateSolidMenuMutation,
+    useUpdateSolidMenuMutation,
+    useDeleteSolidMenuMutation,
+    useDeleteMultipleSolidMenusMutation
+} = solidMenusApi;

package/dist/redux/api/solidServiceApi.ts

@@ -0,0 +1,31 @@
+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/dist/redux/api/solidSettingsApi.tsx

@@ -0,0 +1,83 @@
+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/dist/redux/api/solidViewApi.ts

@@ -0,0 +1,73 @@
+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/dist/redux/api/stateApi.tsx

@@ -0,0 +1,56 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const statesApi = createApi({
+    reducerPath: 'statesApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        getStates: builder.query({
+            query: (qs) => {
+                return `/state?populate[]=country&${qs}`
+            },
+            transformResponse: (response: any) => {
+                if (response.error) {
+                    throw new Error(response.error);
+                }
+                return {
+                    records: response.data.records,
+                    meta: response.data.meta
+                }
+            }
+        }),
+        getStateById: builder.query({
+            query: (id) => `/state/${id}?populate[]=country`,
+        }),
+        createState: builder.mutation({
+            query: (state) => ({
+                url: '/state',
+                method: 'POST',
+                body: state
+            }),
+        }),
+        // updateState: builder.mutation({
+        //     query: ({ id, data }) => ({
+        //         url: `/state/${id}`,
+        //         method: 'Patch',
+        //         body: data,
+        //     }),
+        // }),
+
+        deleteMultipleStates: builder.mutation({
+            query: (data) => ({
+                url: `/state/bulk/`,
+                method: 'DELETE',
+                body: data
+            }),
+        }),
+        deleteState: builder.mutation({
+            query: (id) => ({
+                url: `/state/${id}`,
+                method: 'DELETE',
+            }),
+        }),
+    })
+})
+
+export const { useLazyGetStatesQuery, useCreateStateMutation, useDeleteStateMutation, useDeleteMultipleStatesMutation, useGetStatesQuery, useGetStateByIdQuery, useLazyGetStateByIdQuery, usePrefetch } = statesApi  

package/dist/redux/api/testApi.ts

@@ -0,0 +1,21 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+import { baseQueryWithAuth } from './fetchBaseQuery';
+
+export const testApi = createApi({
+    reducerPath: 'testApi',
+    baseQuery: baseQueryWithAuth,
+    endpoints: (builder) => ({
+        seeder: builder.mutation({
+            query: (name) => ({
+                url: '/test/seed',
+                method: 'POST',
+                body: {
+                    "seeder": name
+                }
+            }),
+        }),
+    })
+
+});
+
+export const {useSeederMutation} = testApi