@spacemade/ui 0.0.1

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

@@ -0,0 +1,27 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+
+export const paymentApiSlice = createApi({
+	reducerPath: 'api/payments',
+	baseQuery: fetchBaseQuery({
+		baseUrl: '/api',
+	}),
+	extractRehydrationInfo(action, { reducerPath }) {
+		if (action.type === HYDRATE) {
+			return action.payload[reducerPath]
+		}
+	},
+	endpoints: (builder) => ({
+		getClientSecret: builder.mutation<{ clientSecret: string }, number>({
+			query: (amount) => ({
+				url: `/payment/intent`,
+				method: 'POST',
+				body: {
+					amount,
+				},
+			}),
+		}),
+	}),
+})
+
+export const { useGetClientSecretMutation } = paymentApiSlice

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

@@ -0,0 +1,369 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { EntityStatus, Post, PostPayload } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import {
+	cleanEmptyValues,
+	ensureNoDuplicateData,
+	keysToCamel,
+} from '@helpers/data-transform'
+import { createUniqueTokenByObject } from '@helpers/string'
+import { ApiEntityNames, ApiPagingResponse, Either } from '@helpers/types'
+
+type GetParams = {
+	nameLike?: string
+	isFeatured?: boolean
+	limit?: number
+	page?: number
+	categoryIds?: string[]
+	categorySlugs?: string[]
+	tagIds?: string[]
+	skipPostIds?: string[]
+	ownerId?: string
+	campaignId?: string
+	includeAds?: boolean
+	getForTagOnly?: boolean
+	cookie?: string
+	productId?: string
+	providerId?: string
+	providerModelId?: string
+	searchId?: string
+}
+
+export const postApiSlice = createApi({
+	reducerPath: 'api/posts',
+	baseQuery: fetchBaseQuery({
+		baseUrl: BASE_API_URL,
+		credentials: 'include',
+	}),
+	extractRehydrationInfo(action, { reducerPath }) {
+		if (action.type === HYDRATE) {
+			return (action as any).payload[reducerPath]
+		}
+	},
+	tagTypes: ['UserPosts'],
+	endpoints: (builder) => ({
+		/**
+		 * Get public posts
+		 */
+			getInfinityApprovedPosts: builder.query<ApiPagingResponse<Post>, GetParams>(
+				{
+					query: ({
+						limit = 50,
+						cookie,
+						...rest
+					}) => ({
+						url: `/posts`,
+						headers: cookie
+							? {
+									Cookie: cookie,
+							  }
+							: undefined,
+						params: {
+							limit,
+							...cleanEmptyValues(rest),
+						},
+					}),
+				serializeQueryArgs: ({
+					endpointName,
+					queryArgs: {
+						nameLike,
+						isFeatured,
+						limit,
+						page,
+						categoryIds,
+						categorySlugs,
+						ownerId,
+						skipPostIds,
+						tagIds,
+						productId,
+						providerId,
+						providerModelId,
+						searchId,
+					},
+				}) => {
+					const token = createUniqueTokenByObject(
+						cleanEmptyValues({
+							nameLike,
+							limit,
+							isFeatured,
+							categoryIds,
+							categorySlugs,
+							skipPostIds,
+							tagIds,
+							ownerId,
+							productId,
+							providerId,
+							providerModelId,
+							searchId,
+						})
+					)
+
+					return endpointName + `-${token}`
+				},
+				merge: (currentCache, newItems) => {
+					const newResults = ensureNoDuplicateData(
+						currentCache.results,
+						newItems.results
+					)
+					currentCache.results.push(...newResults)
+					currentCache.next = newItems.next
+					currentCache.previous = newItems.previous
+					currentCache.count = newItems.count
+				},
+				forceRefetch({ currentArg, previousArg }) {
+					return currentArg?.page !== previousArg?.page
+				},
+				transformResponse: (res) => keysToCamel(res),
+			}
+		),
+
+			getApprovedPosts: builder.query<ApiPagingResponse<Post>, GetParams>({
+				query: ({
+					limit = 50,
+					cookie,
+					...rest
+				}) => ({
+					url: `/posts`,
+					headers: cookie
+						? {
+								Cookie: cookie,
+						  }
+						: undefined,
+					params: {
+						limit,
+						...cleanEmptyValues(rest),
+					},
+				}),
+			serializeQueryArgs: ({
+				endpointName,
+				queryArgs: {
+					nameLike,
+					isFeatured,
+					limit,
+					page,
+					categoryIds,
+					categorySlugs,
+					tagIds,
+					skipPostIds,
+					ownerId,
+					campaignId,
+					includeAds,
+					getForTagOnly,
+					productId,
+					providerId,
+					providerModelId,
+					searchId,
+				},
+			}) => {
+				const token = createUniqueTokenByObject(
+					cleanEmptyValues({
+						nameLike,
+						isFeatured,
+						limit,
+						page,
+						categoryIds,
+						categorySlugs,
+						tagIds,
+						skipPostIds,
+						ownerId,
+						campaignId,
+						includeAds,
+						getForTagOnly,
+						productId,
+						providerId,
+						providerModelId,
+						searchId,
+					})
+				)
+				return endpointName + `-${token}`
+			},
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		/**
+		 * Get posts that belongs the user logged in
+		 */
+		getAccountPosts: builder.query<
+			ApiPagingResponse<Post>,
+			{
+				limit?: number
+				page?: number
+				categoryIds?: string[]
+				isFeatured?: boolean
+				status?: EntityStatus
+				nameLike?: string
+			}
+		>({
+			query: (params) => ({
+				url: '/admin/posts',
+				params,
+			}),
+			providesTags: ['UserPosts'],
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		getOnePost: builder.query<
+			Post,
+			Either<{ id: string }, { slug: string }> & {
+				entities?: ApiEntityNames[]
+				getForAccount: boolean
+				cookie?: string
+			}
+		>({
+			query: ({ id, slug, entities, getForAccount = false, cookie }) => ({
+				url: (getForAccount ? '/admin/posts'  : '/posts') + `/${id || slug}`,
+				headers: cookie
+					? {
+							Cookie: cookie,
+					  }
+					: undefined,
+				params: {
+					include: entities,
+				},
+			}),
+			serializeQueryArgs: ({
+				endpointName,
+				queryArgs: { id, slug, entities, getForAccount },
+			}) => {
+				const token = createUniqueTokenByObject(
+					cleanEmptyValues({
+						id,
+						slug,
+						entities,
+						getForAccount,
+					})
+				)
+
+				return endpointName + `-${token}`
+			},
+			providesTags: ['UserPosts'],
+			transformResponse: ({ post }: { post: Post }) => keysToCamel(post),
+		}),
+
+		checkPostSlugAvailability: builder.query<
+			{ value: string; isAvailable: boolean },
+			string
+		>({
+			query: (value) => ({
+				url: '/search/availability/post',
+				params: {
+					value,
+				},
+			}),
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		getPreviousAndNextPost: builder.query<
+			{ previous: string; next: string },
+			{ postId: string }
+		>({
+			query: ({ postId }) => {
+				let params = {}
+				try {
+					const paramsAsString = localStorage.getItem('posts_search_params')
+					params = JSON.parse(paramsAsString || '{}')
+				} catch (error) {
+					// ignore
+					console.error(error)
+				}
+
+				return {
+					url: `/admin/posts/next-and-prev/${postId}`,
+					params,
+				}
+			},
+			transformResponse: (res) => keysToCamel(res),
+		}),
+
+		approvePost: builder.mutation<{ message: string }, { post: Post }>({
+			query: ({ post }) => ({
+				url: `/posts/account/${post.id}/approve-post`,
+				method: 'POST',
+			}),
+			invalidatesTags: ['UserPosts'],
+		}),
+
+		createPost: builder.mutation<Post, { payload: PostPayload }>({
+			query: ({ payload }) => ({
+				url: `/posts`,
+				method: 'POST',
+				body: {
+					slug: payload.slug,
+					name: payload.name,
+					intro: payload.intro,
+					content: payload.content,
+					status: payload.status,
+					start_datetime: payload.startDatetime,
+					end_datetime: payload.endDatetime,
+					is_featured: payload.isFeatured,
+					categories: payload.categories,
+					owner_id: payload.ownerId,
+					approved_status: payload.approvedStatus,
+					featured_media_id: payload.featuredMediaId,
+					product_id: payload.productId,
+					provider_id: payload.providerId,
+					provider_model_id: payload.providerModelId,
+				},
+			}),
+			invalidatesTags: ['UserPosts'],
+			transformResponse: ({ post }: { post: Post }) => keysToCamel(post),
+		}),
+
+		updatePost: builder.mutation<Post, { payload: PostPayload }>({
+			query: ({ payload: { id, ...patch } }) => ({
+				url: `/posts/${id}`,
+				method: 'PATCH',
+				body: {
+					slug: patch.slug,
+					name: patch.name,
+					intro: patch.intro,
+					content: patch.content,
+					status: patch.status,
+					start_datetime: patch.startDatetime,
+					end_datetime: patch.endDatetime,
+					is_featured: patch.isFeatured,
+					categories: patch.categories,
+					owner_id: patch.ownerId,
+					approved_status: patch.approvedStatus,
+					featured_media_id: patch.featuredMediaId,
+					product_id: patch.productId,
+					provider_id: patch.providerId,
+					provider_model_id: patch.providerModelId,
+				},
+			}),
+			invalidatesTags: ['UserPosts'],
+			transformResponse: ({ post }: { post: Post }) => keysToCamel(post),
+		}),
+
+		deletePost: builder.mutation<void, { post: Post }>({
+			query: ({ post }) => ({
+				url: `/posts/${post.id}`,
+				method: 'DELETE',
+			}),
+			invalidatesTags: ['UserPosts'],
+		}),
+	}),
+})
+
+export const {
+	useGetInfinityApprovedPostsQuery,
+	useGetApprovedPostsQuery,
+	useGetAccountPostsQuery,
+	useGetOnePostQuery,
+	useGetPreviousAndNextPostQuery,
+	useLazyGetOnePostQuery,
+	useLazyCheckPostSlugAvailabilityQuery,
+	useApprovePostMutation,
+	useCreatePostMutation,
+	useUpdatePostMutation,
+	useDeletePostMutation,
+	util: { getRunningQueriesThunk },
+} = postApiSlice
+
+export const {
+	getApprovedPosts,
+	getAccountPosts,
+	getOnePost,
+	getInfinityApprovedPosts,
+} = postApiSlice.endpoints

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

@@ -0,0 +1,101 @@
+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 { ApiPagingResponse } from '@helpers/types'
+import { ProductCoupon, ProductCouponPayload } from '@store/model'
+
+export const productCouponsApiSlice = createApi({
+  reducerPath: 'api/product-coupons',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['ProductCoupons'],
+  endpoints: (builder) => ({
+    getProductCoupons: builder.query<ApiPagingResponse<ProductCoupon>, { limit?: number; page?: number } | void>({
+      query: (params) => ({
+        url: '/admin/product-coupons',
+        params,
+      }),
+      transformResponse: (res) => keysToCamel(res),
+      providesTags: ['ProductCoupons'],
+    }),
+    createProductCoupon: builder.mutation<ProductCoupon, { payload: ProductCouponPayload }>({
+      query: ({ payload }) => ({
+        url: '/admin/product-coupons',
+        method: 'POST',
+        body: {
+          code: payload.code,
+          name: payload.name,
+          description: payload.description,
+          status: payload.status,
+          percent_off: payload.percentOff,
+          amount_off: payload.amountOff,
+          currency: payload.currency,
+          duration: payload.duration,
+          duration_in_months: payload.durationInMonths,
+          max_redemptions: payload.maxRedemptions,
+          redeem_by: payload.redeemBy,
+        },
+      }),
+      transformResponse: ({ coupon }: { coupon: ProductCoupon }) => keysToCamel(coupon),
+      invalidatesTags: ['ProductCoupons'],
+    }),
+    updateProductCoupon: builder.mutation<ProductCoupon, { payload: ProductCouponPayload & { id: string } }>({
+      query: ({ payload: { id, ...patch } }) => ({
+        url: `/admin/product-coupons/${id}`,
+        method: 'PATCH',
+        body: {
+          code: patch.code,
+          name: patch.name,
+          description: patch.description,
+          status: patch.status,
+          percent_off: patch.percentOff,
+          amount_off: patch.amountOff,
+          currency: patch.currency,
+          duration: patch.duration,
+          duration_in_months: patch.durationInMonths,
+          max_redemptions: patch.maxRedemptions,
+          redeem_by: patch.redeemBy,
+        },
+      }),
+      transformResponse: ({ coupon }: { coupon: ProductCoupon }) => keysToCamel(coupon),
+      invalidatesTags: ['ProductCoupons'],
+    }),
+    deleteProductCoupon: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/admin/product-coupons/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['ProductCoupons'],
+    }),
+    validateCoupon: builder.mutation<
+      { coupon: ProductCoupon; subtotal: number; discountAmount: number; total: number },
+      { code: string; planSlugs: string[] }
+    >({
+      query: ({ code, planSlugs }) => ({
+        url: '/coupons/validate',
+        method: 'POST',
+        body: {
+          code,
+          plan_slugs: planSlugs,
+        },
+      }),
+      transformResponse: (res) => keysToCamel(res),
+    }),
+  }),
+})
+
+export const {
+  useGetProductCouponsQuery,
+  useCreateProductCouponMutation,
+  useUpdateProductCouponMutation,
+  useDeleteProductCouponMutation,
+  useValidateCouponMutation,
+} = productCouponsApiSlice

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

@@ -0,0 +1,93 @@
+// src/store/api/product-features.slice.ts
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { ProductFeature, ProductFeaturePayload } from '@store/model/product-feature'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiPagingResponse } from '@helpers/types'
+
+type GetParams = {
+  q?: string
+  measureUnit?: ProductFeaturePayload['measureUnit']
+  limit?: number
+  page?: number
+}
+
+export const productFeaturesApiSlice = createApi({
+  reducerPath: 'api/product-features',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['ProductFeatures'],
+  endpoints: (builder) => ({
+    getProductFeatures: builder.query<ApiPagingResponse<ProductFeature>, GetParams>({
+      query: (params) => ({
+        url: '/product-features',
+        params,
+      }),
+      providesTags: ['ProductFeatures'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+
+    getOneProductFeature: builder.query<ProductFeature, { id: string; isAdmin?: boolean }>({
+      query: ({ id, isAdmin }) => ({
+        url: isAdmin ? `/product-features/${id}` : `/product-features/${id}`,
+      }),
+      providesTags: ['ProductFeatures'],
+      transformResponse: ({ feature }: { feature: ProductFeature }) => keysToCamel(feature),
+    }),
+
+    createProductFeature: builder.mutation<ProductFeature, { payload: ProductFeaturePayload }>({
+      query: ({ payload }) => ({
+        url: '/product-features',
+        method: 'POST',
+        body: {
+          name: payload.name,
+          description: payload.description,
+          measure_unit: payload.measureUnit,
+        },
+      }),
+      invalidatesTags: ['ProductFeatures'],
+      transformResponse: ({ feature }: { feature: ProductFeature }) => keysToCamel(feature),
+    }),
+
+    updateProductFeature: builder.mutation<ProductFeature, { payload: ProductFeaturePayload }>({
+      query: ({ payload: { id, ...patch } }) => ({
+        url: `/product-features/${id}`,
+        method: 'PATCH',
+        body: {
+          name: patch.name,
+          description: patch.description,
+          measure_unit: patch.measureUnit,
+        },
+      }),
+      invalidatesTags: ['ProductFeatures'],
+      transformResponse: ({ feature }: { feature: ProductFeature }) => keysToCamel(feature),
+    }),
+
+    deleteProductFeature: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/product-features/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['ProductFeatures'],
+    }),
+  }),
+})
+
+export const {
+  useGetProductFeaturesQuery,
+  useGetOneProductFeatureQuery,
+  useCreateProductFeatureMutation,
+  useUpdateProductFeatureMutation,
+  useDeleteProductFeatureMutation,
+  util: { getRunningQueriesThunk },
+} = productFeaturesApiSlice
+
+export const { getProductFeatures, getOneProductFeature } = productFeaturesApiSlice.endpoints