@spacemade/ui 0.0.1

package/src/store/slice/api/userApiSlice.ts

@@ -0,0 +1,305 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { PaymentMethod, User, UserPayload, UserPermissionBundle, UserPermissionRow } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiEntityNames, ApiPagingResponse } from '@helpers/types'
+
+type GetUsersParams = {
+	nameLike?: string
+	limit?: number
+	page?: number
+	include?: ApiEntityNames[]
+	isAdmin?: boolean
+	isEditor?: boolean
+	flagFetchCondition?: 'OR' | 'AND'
+	skipUserIds?: string[]
+	orgId?: string
+}
+
+type AdminBillingSummaryParams = {
+	userId?: string
+	orgId?: string
+	months?: number
+}
+
+type AdminBillingSummary = {
+	plan: {
+		id: string
+		slug: string | null
+		name: string | null
+		amount: number
+		billingPeriod: string | null
+		productType: string | null
+	} | null
+	monthlyRevenue: number
+	billingHistory: Array<{
+		monthKey: string
+		label: string
+		totalAmount: number
+		paidAmount: number
+		invoiceCount: number
+		paidInvoiceCount: number
+	}>
+	recentInvoices: Array<{
+		id: string
+		stripeInvoiceId: string | null
+		stripeInvoiceNumber: string | null
+		amount: number
+		status: string
+		createdAt: string
+		pdfUrl: string | null
+	}>
+	monthsCount: number
+	scope: {
+		userId: string | null
+		orgId: string | null
+	}
+}
+
+export const userApiSlice = createApi({
+	reducerPath: 'api/admin/users',
+	baseQuery: fetchBaseQuery({
+		baseUrl: BASE_API_URL,
+		credentials: 'include',
+	}),
+	extractRehydrationInfo(action, { reducerPath }) {
+		if (action.type === HYDRATE) {
+			return action.payload[reducerPath]
+		}
+	},
+	tagTypes: ['LocalUsers', 'PaymentMethod'],
+	endpoints: (builder) => ({
+		getUsersForAdmin: builder.query<ApiPagingResponse<User>, GetUsersParams>({
+			query: (params) => ({
+				url: `/admin/users`,
+				params,
+			}),
+			providesTags: ['LocalUsers'],
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		getAdminBillingSummary: builder.query<AdminBillingSummary, AdminBillingSummaryParams>({
+			query: (params) => ({
+				url: `/admin/billing/summary`,
+				params,
+			}),
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		checkUserFieldAvailability: builder.query<
+			{ value: string; field: string; isAvailable: boolean },
+			{ field: 'email' | 'name'; value: string }
+		>({
+			query: ({ field, value }) => ({
+				url: '/search/availability/user',
+				params: {
+					field,
+					value,
+				},
+			}),
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		getUsers: builder.query<ApiPagingResponse<User>, GetUsersParams>({
+			query: (params) => ({
+				url: `/users`,
+				params,
+			}),
+			providesTags: ['LocalUsers'],
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		searchUsers: builder.query<ApiPagingResponse<User>, { nameLike: string; limit?: number; page?: number; orgId?: string }>({
+			query: (params) => ({
+				url: `/users/search`,
+				params,
+			}),
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		getUserPaymentMethod: builder.query<PaymentMethod | null, { userId: string }>({
+			query: ({ userId }) => ({
+				url: `/subscription/users/${userId}/payment-method`,
+			}),
+			providesTags: ['PaymentMethod'],
+			// ⬅️ return the inner object so the component gets the PM directly
+			transformResponse: (res: { paymentMethod: any | null }) => {
+				const pm = res?.paymentMethod ?? null;
+				if (!pm) return null;
+				// (server already returns flattened fields; just pass through)
+				return pm as PaymentMethod;
+			},
+		}),
+
+		updatePaymentDetails: builder.mutation<{ message: string }, { paymentMethodId: string, userId: string }>({
+			query: ({ userId, paymentMethodId }) => ({
+				url: `/subscription/users/${userId}/update-payment`,
+				method: 'POST',
+				body: { payment_method_id: paymentMethodId },
+			}),
+			invalidatesTags: ['PaymentMethod'],
+		}),
+
+		getUserByIdOrName: builder.query<
+			User,
+			{ idOrName: string; entities?: ApiEntityNames[] }
+		>({
+			query: ({ idOrName, entities }) => ({
+				url: `/users/${idOrName}`,
+				params: {
+					include: entities,
+				},
+			}),
+			providesTags: ['LocalUsers'],
+			transformResponse: ({ user }: { user: User }) => keysToCamel(user),
+		}),
+
+		updateUser: builder.mutation<User, UserPayload>({
+			query: ({ id, ...patch }) => ({
+				url: `/users/${id}`,
+				method: 'PATCH',
+				body: {
+					name: patch.name,
+					first_name: patch.firstName,
+					last_name: patch.lastName,
+					nonce: patch.nonce,
+					email: patch.email,
+					bio: patch.bio,
+					short_bio: patch.shortBio,
+					timezone: patch.timezone,
+					time_zone: patch.timeZone,
+					twitter_username: patch.twitterUsername,
+					instagram_username: patch.instagramUsername,
+					linkedin_username: patch.linkedinUsername,
+					site_url: patch.siteUrl,
+					rpm_glb_url: patch.rpmGlbUrl,
+					street_address: patch.streetAddress,
+					street_address2: patch.streetAddress2,
+					city: patch.city,
+					state: patch.state,
+					postal_code: patch.postalCode,
+					country: patch.country,
+					system_role: patch.systemRole,
+					is_suspended: patch.isSuspended,
+					featured_links: patch.featuredLinks,
+					profile_media_id: patch.profileMediaId,
+					banner_media_id: patch.bannerMediaId,
+					company_logo_media_id: patch.companyLogoMediaId,
+					huggingface_api_token: patch.huggingfaceApiToken,
+					openai_api_key: patch.openaiApiKey,
+					bedrock_aws_access_key_id: patch.bedrockAwsAccessKeyId,
+					bedrock_aws_secret_access_key: patch.bedrockAwsSecretAccessKey,
+					bedrock_aws_region: patch.bedrockAwsRegion,
+				},
+			}),
+			invalidatesTags: ['LocalUsers'],
+			transformResponse: ({ user }: { user: User }) => keysToCamel(user),
+		}),
+
+	updateUserForAdmin: builder.mutation<User, { payload: UserPayload }>({
+			query: ({ payload: { id, ...patch } }) => ({
+				url: `/admin/users/${id}`,
+				method: 'PATCH',
+				body: {
+					name: patch.name,
+					first_name: patch.firstName,
+					last_name: patch.lastName,
+					nonce: patch.nonce,
+					email: patch.email,
+					bio: patch.bio,
+					short_bio: patch.shortBio,
+					timezone: patch.timezone,
+					time_zone: patch.timeZone,
+					twitter_username: patch.twitterUsername,
+					instagram_username: patch.instagramUsername,
+					linkedin_username: patch.linkedinUsername,
+					site_url: patch.siteUrl,
+					rpm_glb_url: patch.rpmGlbUrl,
+					street_address: patch.streetAddress,
+					street_address2: patch.streetAddress2,
+					city: patch.city,
+					state: patch.state,
+					postal_code: patch.postalCode,
+					country: patch.country,
+					system_role: patch.systemRole,
+					is_suspended: patch.isSuspended,
+					featured_links: patch.featuredLinks,
+					profile_media_id: patch.profileMediaId,
+					banner_media_id: patch.bannerMediaId,
+					company_logo_media_id: patch.companyLogoMediaId,
+					huggingface_api_token: patch.huggingfaceApiToken,
+					openai_api_key: patch.openaiApiKey,
+					bedrock_aws_access_key_id: patch.bedrockAwsAccessKeyId,
+					bedrock_aws_secret_access_key: patch.bedrockAwsSecretAccessKey,
+					bedrock_aws_region: patch.bedrockAwsRegion,
+				},
+			}),
+			invalidatesTags: ['LocalUsers'],
+			transformResponse: ({ user }: { user: User }) => keysToCamel(user),
+		}),
+
+	deleteUserForAdmin: builder.mutation<void, { user: User }>({
+			query: ({ user }) => ({
+				url: `/admin/users/${user.id}`,
+				method: 'DELETE',
+			}),
+			invalidatesTags: ['LocalUsers'],
+		}),
+
+		getUserPermissions: builder.query<UserPermissionBundle, { userId: string }>({
+			query: ({ userId }) => ({
+				url: `/users/${userId}/permissions`,
+			}),
+			transformResponse: (response: {
+				permissions: UserPermissionRow[]
+				direct_permissions: UserPermissionRow[]
+				group_permissions: UserPermissionRow[]
+				group_permissions_by_group: Array<{ group_id: string; permissions: UserPermissionRow[] }>
+			}) => keysToCamel(response) as UserPermissionBundle,
+		}),
+
+		updateUserPermissions: builder.mutation<
+			UserPermissionBundle,
+			{ userId: string; permissions: UserPermissionRow[] }
+		>({
+			query: ({ userId, permissions }) => ({
+				url: `/users/${userId}/permissions`,
+				method: 'PATCH',
+				body: {
+					permissions: permissions.map((permission) => ({
+						app_key: permission.appKey,
+						action: permission.action,
+						allowed: permission.allowed,
+						role: permission.role,
+					})),
+				},
+			}),
+			transformResponse: (response: {
+				permissions: UserPermissionRow[]
+				direct_permissions: UserPermissionRow[]
+				group_permissions: UserPermissionRow[]
+				group_permissions_by_group: Array<{ group_id: string; permissions: UserPermissionRow[] }>
+			}) => keysToCamel(response) as UserPermissionBundle,
+		}),
+	}),
+})
+
+export const {
+	useGetUsersForAdminQuery,
+	useGetUserPaymentMethodQuery,
+	useUpdatePaymentDetailsMutation,
+	useUpdateUserForAdminMutation,
+	useDeleteUserForAdminMutation,
+	useGetUserPermissionsQuery,
+	useUpdateUserPermissionsMutation,
+	useUpdateUserMutation,
+	useLazyCheckUserFieldAvailabilityQuery,
+	useGetUserByIdOrNameQuery,
+	useGetUsersQuery,
+	useLazySearchUsersQuery,
+	useGetAdminBillingSummaryQuery,
+	util: { getRunningQueriesThunk },
+} = userApiSlice
+
+export const { getUsers, getUserByIdOrName } = userApiSlice.endpoints

package/src/store/slice/api/vectorStoreApiSlice.ts

@@ -0,0 +1,119 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import type { ApiPagingResponse } from '@helpers/types'
+import type {
+  VectorStore,
+  VectorStorePayload,
+} from '@store/model/vector-store.model'
+
+type GetParams = {
+  nameLike?: string
+  limit?: number
+  page?: number
+  projectId?: string
+  providerSettingId?: string
+}
+
+type UpdateVectorStoreArgs = {
+  id: string
+  payload: Partial<VectorStorePayload>
+}
+
+export const vectorStoreApiSlice = createApi({
+  reducerPath: 'api/vectorStore',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['VectorStores'],
+  endpoints: (builder) => ({
+    getVectorStores: builder.query<
+      ApiPagingResponse<VectorStore>,
+      GetParams | void
+    >({
+      query: (params) => ({
+        url: `/storage`,
+        params: params
+          ? {
+              nameLike: params.nameLike,
+              limit: params.limit,
+              page: params.page,
+              project_id: params.projectId,
+              provider_setting_id: params.providerSettingId,
+            }
+          : undefined,
+      }),
+      providesTags: ['VectorStores'],
+      transformResponse: (res: any) => keysToCamel(res),
+    }),
+
+    getOneVectorStore: builder.query<VectorStore, { id: string }>({
+      query: ({ id }) => `/storage/${id}`,
+      transformResponse: ({ store }: { store: VectorStore }) =>
+        keysToCamel(store),
+    }),
+
+    createVectorStore: builder.mutation<
+      VectorStore,
+      { payload: VectorStorePayload }
+    >({
+      query: ({ payload }) => ({
+        url: `/storage`,
+        method: 'POST',
+        body: {
+          name: payload.name,
+          description: payload.description,
+          provider_setting_id: payload.providerSettingId,
+          provider_store_id: payload.providerStoreId,
+          provider_status: payload.providerStatus,
+          provider_created_at: payload.providerCreatedAt,
+        },
+      }),
+      invalidatesTags: ['VectorStores'],
+      transformResponse: ({ vectorStore }: { vectorStore: VectorStore }) =>
+        keysToCamel(vectorStore),
+    }),
+
+    updateVectorStore: builder.mutation<VectorStore, UpdateVectorStoreArgs>({
+      query: ({ id, payload }) => ({
+        url: `/storage/${id}`,
+        method: 'PATCH',
+        body: {
+          name: payload.name,
+          description: payload.description,
+          provider_setting_id: payload.providerSettingId,
+          provider_store_id: payload.providerStoreId,
+          provider_status: payload.providerStatus,
+          provider_created_at: payload.providerCreatedAt,
+        },
+      }),
+      invalidatesTags: ['VectorStores'],
+      transformResponse: ({ vectorStore }: { vectorStore: VectorStore }) =>
+        keysToCamel(vectorStore),
+    }),
+
+    deleteVectorStore: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/storage/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['VectorStores'],
+    }),
+  }),
+})
+
+export const {
+  useGetVectorStoresQuery,
+  useGetOneVectorStoreQuery,
+  useCreateVectorStoreMutation,
+  useUpdateVectorStoreMutation,
+  useDeleteVectorStoreMutation,
+  util: { getRunningQueriesThunk },
+} = vectorStoreApiSlice

package/src/store/slice/api/vectorStoreFileApiSlice.ts

@@ -0,0 +1,127 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import type { ApiPagingResponse } from '@helpers/types'
+import type { VectorStoreFile } from '@store/model/vector-store-file.model'
+
+export const vectorStoreFileApiSlice = createApi({
+  reducerPath: 'api/vectorStoreFile',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  tagTypes: ['VectorStoreFile'],
+
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any)?.payload?.[reducerPath]
+    }
+  },
+  endpoints: (builder) => ({
+    getVectorStoreFiles: builder.query<
+      ApiPagingResponse<VectorStoreFile>,
+      { vectorStoreId: string; page?: number; limit?: number }
+    >({
+      query: ({ vectorStoreId, page = 1, limit = 20 }) => ({
+        url: `/storage/${vectorStoreId}/files`,
+        params: { page, limit },
+      }),
+
+      transformResponse: (res: any) =>
+        keysToCamel({
+          results: res.files || [],
+          count: res.count ?? 0,
+          page: res.page,
+          limit: res.limit,
+        }),
+
+      providesTags: (result, error, { vectorStoreId }) =>
+        result
+          ? [
+            ...result.results.map((file) => ({
+              type: 'VectorStoreFile' as const,
+              id: file.id,
+            })),
+            { type: 'VectorStoreFile', id: `LIST-${vectorStoreId}` },
+          ]
+          : [{ type: 'VectorStoreFile', id: `LIST-${vectorStoreId}` }],
+    }),
+
+    getOneVectorStoreFile: builder.query<
+      VectorStoreFile,
+      { vectorStoreId: string; fileId: string }
+    >({
+      query: ({ vectorStoreId, fileId }) =>
+        `/storage/${vectorStoreId}/files/${fileId}`,
+
+      transformResponse: (res: { file: any }) =>
+        keysToCamel(res.file),
+
+      providesTags: (result, error, { fileId }) =>
+        result ? [{ type: 'VectorStoreFile', id: fileId }] : [],
+    }),
+    createVectorStoreFile: builder.mutation<
+      VectorStoreFile,
+      { vectorStoreId: string; file: File }
+    >({
+      query: ({ vectorStoreId, file }) => {
+        const formData = new FormData()
+        formData.append('file', file)
+
+        return {
+          url: `/storage/${vectorStoreId}/files`,
+          method: 'POST',
+          body: formData,
+        }
+      },
+
+      transformResponse: (res: { dbFile: any }) =>
+        keysToCamel(res.dbFile),
+
+      invalidatesTags: (result, error, { vectorStoreId }) => [
+        { type: 'VectorStoreFile', id: `LIST-${vectorStoreId}` },
+      ],
+    }),
+    updateVectorStoreFile: builder.mutation<
+      VectorStoreFile,
+      { vectorStoreId: string; fileId: string; fileName: string }
+    >({
+      query: ({ vectorStoreId, fileId, fileName }) => ({
+        url: `/storage/${vectorStoreId}/files/${fileId}`,
+        method: 'PATCH',
+        body: { file_name: fileName },
+      }),
+
+      transformResponse: (res: { file: any }) =>
+        keysToCamel(res.file),
+
+      invalidatesTags: (result, error, { vectorStoreId, fileId }) => [
+        { type: 'VectorStoreFile', id: fileId },
+        { type: 'VectorStoreFile', id: `LIST-${vectorStoreId}` },
+      ],
+    }),
+    deleteVectorStoreFile: builder.mutation<
+      { message: string },
+      { vectorStoreId: string; fileId: string }
+    >({
+      query: ({ vectorStoreId, fileId }) => ({
+        url: `/storage/${vectorStoreId}/files/${fileId}`,
+        method: 'DELETE',
+      }),
+
+      invalidatesTags: (result, error, { vectorStoreId, fileId }) => [
+        { type: 'VectorStoreFile', id: fileId },
+        { type: 'VectorStoreFile', id: `LIST-${vectorStoreId}` },
+      ],
+    }),
+  }),
+})
+
+export const {
+  useGetVectorStoreFilesQuery,
+  useGetOneVectorStoreFileQuery,
+  useCreateVectorStoreFileMutation,
+  useUpdateVectorStoreFileMutation,
+  useDeleteVectorStoreFileMutation,
+} = vectorStoreFileApiSlice

package/src/store/store.ts

@@ -0,0 +1,130 @@
+import { configureStore } from '@reduxjs/toolkit'
+import type {
+	GetServerSideProps,
+	GetServerSidePropsContext,
+	GetServerSidePropsResult,
+} from 'next'
+import accountSlice from '@store/slice/api/accountSlice'
+import { accountApiSlice } from '@store/slice/api/accountApiSlice'
+import { authApiSlice } from '@store/slice/api/authApiSlice'
+import { categoriesApiSlice } from '@store/slice/api/categoriesApiSlice'
+import { mediaApiSlice } from '@store/slice/api/mediaApiSlice'
+import { paymentApiSlice } from '@store/slice/api/paymentApiSlice'
+import { postApiSlice } from '@store/slice/api/postApiSlice'
+import { tagsApiSlice } from '@store/slice/api/tagsApiSlice'
+import { userApiSlice } from '@store/slice/api/userApiSlice'
+import { siteApiSlice } from '@store/slice/api/siteApiSlice'
+import { bootstrapIconApiSlice } from '@store/slice/api/bootstrapIconApiSlice'
+import { stripeApiSlice } from '@store/slice/api/stripeApiSlice'
+import { invoiceApiSlice } from '@store/slice/api/invoiceApiSlice'
+import { productsApiSlice } from '@store/slice/api/productsApiSlice'
+import { productPlansApiSlice } from '@store/slice/api/productPlansApiSlice'
+import { productVersionsApiSlice } from '@store/slice/api/productVersionsApiSlice'
+import { productFeaturesApiSlice } from '@store/slice/api/productFeaturesApiSlice'
+import { productCouponsApiSlice } from '@store/slice/api/productCouponsApiSlice'
+import { billingUnitTypesApiSlice } from '@store/slice/api/billingUnitTypesApiSlice'
+import { projectApiSlice } from './slice/api/projectApiSlice'
+import { apiTokenApiSlice } from './slice/api/apiTokenSlice'
+import { providerApi } from './slice/api/providerApiSlice'
+import { providerSettingApi } from './slice/api/providerSettingApiSlice'
+import {vectorStoreApiSlice} from './slice/api/vectorStoreApiSlice'
+import {vectorStoreFileApiSlice} from './slice/api/vectorStoreFileApiSlice'
+import {projectFileApiSlice} from './slice/api/projectFileApiSlice'
+import { projectUserPermissionsApiSlice } from './slice/api/projectUserPermissionApiSlice'
+import { orgApiSlice } from './slice/api/orgApiSlice'
+import { leadApiSlice } from './slice/api/leadApiSlice'
+import { activityApiSlice } from './slice/api/activityApiSlice'
+import { pageApiSlice } from './slice/api/pageApiSlice'
+
+export const makeStore = () =>
+	configureStore({
+		reducer: {
+			account: accountSlice,
+
+			// API
+			[accountApiSlice.reducerPath]: accountApiSlice.reducer,
+			[authApiSlice.reducerPath]: authApiSlice.reducer,
+			[categoriesApiSlice.reducerPath]: categoriesApiSlice.reducer,
+			[paymentApiSlice.reducerPath]: paymentApiSlice.reducer,
+			[postApiSlice.reducerPath]: postApiSlice.reducer,
+			[tagsApiSlice.reducerPath]: tagsApiSlice.reducer,
+			[userApiSlice.reducerPath]: userApiSlice.reducer,
+			[mediaApiSlice.reducerPath]: mediaApiSlice.reducer,
+			[bootstrapIconApiSlice.reducerPath]: bootstrapIconApiSlice.reducer,
+			[siteApiSlice.reducerPath]: siteApiSlice.reducer,
+			[stripeApiSlice.reducerPath]: stripeApiSlice.reducer,
+			[invoiceApiSlice.reducerPath]: invoiceApiSlice.reducer,
+			[productsApiSlice.reducerPath]: productsApiSlice.reducer,
+			[productPlansApiSlice.reducerPath]: productPlansApiSlice.reducer,
+			[productVersionsApiSlice.reducerPath]: productVersionsApiSlice.reducer,
+			[productFeaturesApiSlice.reducerPath]: productFeaturesApiSlice.reducer,
+			[productCouponsApiSlice.reducerPath]: productCouponsApiSlice.reducer,
+			[billingUnitTypesApiSlice.reducerPath]: billingUnitTypesApiSlice.reducer,
+			[projectApiSlice.reducerPath]:projectApiSlice.reducer,
+			[apiTokenApiSlice.reducerPath]: apiTokenApiSlice.reducer,
+			[providerApi.reducerPath]: providerApi.reducer,
+			[providerSettingApi.reducerPath]: providerSettingApi.reducer,
+			[vectorStoreApiSlice.reducerPath]: vectorStoreApiSlice.reducer,
+			[vectorStoreFileApiSlice.reducerPath]: vectorStoreFileApiSlice.reducer,
+			[projectFileApiSlice.reducerPath]: projectFileApiSlice.reducer,
+			[projectUserPermissionsApiSlice.reducerPath]:projectUserPermissionsApiSlice.reducer,
+			[orgApiSlice.reducerPath]: orgApiSlice.reducer,
+			[leadApiSlice.reducerPath]: leadApiSlice.reducer,
+			[activityApiSlice.reducerPath]: activityApiSlice.reducer,
+			[pageApiSlice.reducerPath]: pageApiSlice.reducer,
+
+		},
+		middleware: (getDefaultMiddleware) =>
+			getDefaultMiddleware().concat(
+				accountApiSlice.middleware,
+				authApiSlice.middleware,
+				postApiSlice.middleware,
+				categoriesApiSlice.middleware,
+				tagsApiSlice.middleware,
+				userApiSlice.middleware,
+				mediaApiSlice.middleware,
+				bootstrapIconApiSlice.middleware,
+				siteApiSlice.middleware,
+				stripeApiSlice.middleware,
+				invoiceApiSlice.middleware,
+				productsApiSlice.middleware,
+				productPlansApiSlice.middleware,
+				productVersionsApiSlice.middleware,
+				productFeaturesApiSlice.middleware,
+				productCouponsApiSlice.middleware,
+				billingUnitTypesApiSlice.middleware,
+				projectApiSlice.middleware,
+				apiTokenApiSlice.middleware,
+				providerApi.middleware,
+				providerSettingApi.middleware,
+				vectorStoreApiSlice.middleware,
+				vectorStoreFileApiSlice.middleware,
+				projectFileApiSlice.middleware,
+				projectUserPermissionsApiSlice.middleware,
+				orgApiSlice.middleware,
+				leadApiSlice.middleware,
+				activityApiSlice.middleware,
+				pageApiSlice.middleware,
+			),
+	})
+
+type Store = ReturnType<typeof makeStore>
+export type AppDispatch = Store['dispatch']
+export type RootState = ReturnType<Store['getState']>
+
+type WrappedGetServerSideProps<P extends { [key: string]: any }> = (
+	store: Store
+) => (
+	context: GetServerSidePropsContext
+) => Promise<GetServerSidePropsResult<P>> | GetServerSidePropsResult<P>
+
+export const wrapper = {
+	getServerSideProps:
+		<P extends { [key: string]: any } = { [key: string]: any }>(
+			callback: WrappedGetServerSideProps<P>
+		): GetServerSideProps<P> =>
+		async (context) => {
+			const store = makeStore()
+			return callback(store)(context)
+		},
+}