@spacemade/ui 0.0.1

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

@@ -0,0 +1,142 @@
+// src/store/api/product-plans.slice.ts
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { EntityStatus, ProductPlan, ProductPlanPayload } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiPagingResponse } from '@helpers/types'
+
+type GetParams = {
+  nameLike?: string
+  productId?: string
+  skipPlanSlugs?: string[]
+  status?: EntityStatus
+  includeTiers?: boolean
+  limit?: number
+  page?: number
+}
+
+export const productPlansApiSlice = createApi({
+  reducerPath: 'api/product-plans',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['ProductPlans'],
+  endpoints: (builder) => ({
+    getProductPlans: builder.query<ApiPagingResponse<ProductPlan>, GetParams>({
+      query: (params) => ({
+        url: '/admin/product-plans',
+        params,
+      }),
+      providesTags: ['ProductPlans'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+
+    getOneProductPlan: builder.query<ProductPlan, { id: string; isAdmin?: boolean }>({
+      query: ({ id, isAdmin }) => ({
+        url: isAdmin ? `/admin/product-plans/${id}` : `/product-plans/${id}`,
+      }),
+      providesTags: ['ProductPlans'],
+      transformResponse: ({ plan }: { plan: ProductPlan }) => keysToCamel(plan),
+    }),
+
+    createProductPlan: builder.mutation<ProductPlan, { payload: ProductPlanPayload }>({
+      query: ({ payload }) => ({
+        url: '/admin/product-plans',
+        method: 'POST',
+        body: {
+          slug: payload.slug,
+          name: payload.name,
+          status: payload.status,
+          description: payload.description,
+          rank: payload.rank,
+          amount: payload.amount,
+          type: payload.type,
+          billing_period: payload.billingPeriod,
+          pricing_model: payload.pricingModel,
+          billing_unit_type: payload.billingUnitType,
+          stripe_meter_id: payload.stripeMeterId,
+          is_default_plan_for_users: payload.isDefaultPlanForUsers,
+          product_id: payload.productId,
+          usage_tiers: payload.usageTiers?.map((tier) => ({
+            rank: tier.rank,
+            first_unit: tier.firstUnit,
+            last_unit: tier.lastUnit,
+            unit_amount: tier.unitAmount,
+            flat_fee: tier.flatFee,
+          })),
+        },
+      }),
+      invalidatesTags: ['ProductPlans'],
+      transformResponse: ({ plan }: { plan: ProductPlan }) => keysToCamel(plan),
+    }),
+
+    updateProductPlan: builder.mutation<ProductPlan, { payload: ProductPlanPayload & { id: string } }>({
+      query: ({ payload: { id, ...patch } }) => ({
+        url: `/admin/product-plans/${id}`,
+        method: 'PATCH',
+        body: {
+          slug: patch.slug,
+          name: patch.name,
+          status: patch.status,
+          description: patch.description,
+          rank: patch.rank,
+          amount: patch.amount,
+          type: patch.type,
+          billing_period: patch.billingPeriod,
+          pricing_model: patch.pricingModel,
+          billing_unit_type: patch.billingUnitType,
+          stripe_meter_id: patch.stripeMeterId,
+          is_default_plan_for_users: patch.isDefaultPlanForUsers,
+          product_id: patch.productId,
+          usage_tiers: patch.usageTiers?.map((tier) => ({
+            rank: tier.rank,
+            first_unit: tier.firstUnit,
+            last_unit: tier.lastUnit,
+            unit_amount: tier.unitAmount,
+            flat_fee: tier.flatFee,
+          })),
+        },
+      }),
+      invalidatesTags: ['ProductPlans'],
+      transformResponse: ({ plan }: { plan: ProductPlan }) => keysToCamel(plan),
+    }),
+
+    deleteProductPlan: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/admin/product-plans/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['ProductPlans'],
+    }),
+
+    checkProductPlanSlugAvailability: builder.query<
+      { value: string; isAvailable: boolean },
+      { value: string }
+    >({
+      query: (params) => ({
+        url: '/search/availability/product-plan',
+        params,
+      }),
+      transformResponse: (res) => keysToCamel(res),
+    }),
+  }),
+})
+
+export const {
+  useGetProductPlansQuery,
+  useGetOneProductPlanQuery,
+  useCreateProductPlanMutation,
+  useUpdateProductPlanMutation,
+  useDeleteProductPlanMutation,
+  useLazyCheckProductPlanSlugAvailabilityQuery,
+  util: { getRunningQueriesThunk },
+} = productPlansApiSlice
+
+export const { getProductPlans, getOneProductPlan } = productPlansApiSlice.endpoints

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

@@ -0,0 +1,156 @@
+// @store/slice/api/subscriptionApiSlice.ts
+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'
+
+// ---- Shared model types (align with your front-end model) ----
+export enum StripeSubscriptionStatus {
+  Incomplete = 'incomplete',
+  IncompleteExpired = 'incomplete_expired',
+  Trialing = 'trialing',
+  Active = 'active',
+  PastDue = 'past_due',
+  Canceled = 'canceled',
+  Unpaid = 'unpaid',
+}
+
+export type ProductPlanLite = {
+  id: string | null | undefined
+  slug: string | null | undefined
+  name: string | null | undefined
+  rank: number | null | undefined
+}
+
+export type Subscription = {
+  id: string
+  status:
+    | 'live'
+    | 'draft'
+    | 'trialing'
+    | 'active'
+    | 'past_due'
+    | 'canceled'
+    | 'incomplete'
+    | 'unpaid'
+  userId: string
+  stripeSubscriptionId: string | null
+  subscriptionItemId?: string | null
+  emailInvoice: boolean
+  currentPeriodEnd: number | null
+  amount: number | null
+  billingCycle: string | null
+  cancelAtPeriodEnd: boolean | null
+  createdAt: string
+  updatedAt: string
+  isDefaultSubscription?: boolean
+  productPlans?: ProductPlanLite[]
+}
+
+// ---- API response payloads from controller ----
+type GetUserSubResponse = { subscription: Subscription }
+type MessageResponse = { message: string }
+type UpdatePrefsResponse = { subscription: Subscription }
+type PreviewResponse = {
+  credit: number
+  amountDue: number
+  ccLast4: string | null
+}
+
+// ---- Slice ----
+export const productSubscriptionsApi = createApi({
+  reducerPath: 'api/subscription',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['UserSubscription'],
+  endpoints: (builder) => ({
+    // Current user subscription (or synthesized free plan)
+    getUserSubscription: builder.query<GetUserSubResponse, void>({
+      query: () => ({ url: '/subscription/user' }),
+      transformResponse: (res: any) => keysToCamel(res),
+      providesTags: ['UserSubscription'],
+    }),
+
+    // Begin a subscription on a plan by slug
+    planSubscribe: builder.mutation<MessageResponse, { plan: string }>({
+      query: ({ plan }) => ({
+        url: '/subscription/subscribe',
+        method: 'POST',
+        body: { plan },
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+      invalidatesTags: ['UserSubscription'],
+    }),
+
+    // Preview switching to a new plan (proration, amount due, last4)
+    updateSubscriptionPlanPreview: builder.query<PreviewResponse, { plan: string }>({
+      query: ({ plan }) => ({
+        url: `/subscription/subscribe/update/preview`,
+        params: { plan },
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+    }),
+
+    // Switch plans
+    updateSubscriptionPlan: builder.mutation<MessageResponse, { plan: string }>({
+      query: ({ plan }) => ({
+        url: `/subscription/subscribe/update`,
+        method: 'POST',
+        params: { plan },
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+      invalidatesTags: ['UserSubscription'],
+    }),
+
+    // Cancel (unsubscribe) a specific subscription
+    unsubscribe: builder.mutation<MessageResponse, { subscriptionId: string }>({
+      query: ({ subscriptionId }) => ({
+        url: `/subscription/${encodeURIComponent(subscriptionId)}/unsubscribe`,
+        method: 'POST',
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+      invalidatesTags: ['UserSubscription'],
+    }),
+
+    // Resume a specific subscription
+    resume: builder.mutation<MessageResponse, { subscriptionId: string }>({
+      query: ({ subscriptionId }) => ({
+        url: `/subscription/${encodeURIComponent(subscriptionId)}/resume`,
+        method: 'POST',
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+      invalidatesTags: ['UserSubscription'],
+    }),
+
+    // Update subscription preferences
+    updateSubscriptionPreferences: builder.mutation<
+      UpdatePrefsResponse,
+      { subscriptionId: string; emailInvoice: boolean }
+    >({
+      query: ({ subscriptionId, emailInvoice }) => ({
+        url: `/subscription/${encodeURIComponent(subscriptionId)}/update`,
+        method: 'POST',
+        body: { email_invoice: emailInvoice },
+      }),
+      transformResponse: (res: any) => keysToCamel(res),
+      invalidatesTags: ['UserSubscription'],
+    }),
+  }),
+})
+
+export const {
+  useGetUserSubscriptionQuery,
+  usePlanSubscribeMutation,
+  useUpdateSubscriptionPlanPreviewQuery,
+  useUpdateSubscriptionPlanMutation,
+  useUnsubscribeMutation,
+  useResumeMutation,
+  useUpdateSubscriptionPreferencesMutation,
+} = productSubscriptionsApi

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

@@ -0,0 +1,116 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { ProductVersion, ProductVersionPayload, ProductVersionStatus } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiPagingResponse } from '@helpers/types'
+
+type GetParams = {
+  nameLike?: string
+  productId?: string
+  status?: ProductVersionStatus
+  limit?: number
+  page?: number
+}
+
+export const productVersionsApiSlice = createApi({
+  reducerPath: 'api/product-versions',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['ProductVersions'],
+  endpoints: (builder) => ({
+    getProductVersions: builder.query<ApiPagingResponse<ProductVersion>, GetParams>({
+      query: (params) => ({
+        url: '/admin/product-versions',
+        params,
+      }),
+      providesTags: ['ProductVersions'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+
+    getOneProductVersion: builder.query<ProductVersion, { id: string; isAdmin?: boolean; productId?: string }>({
+      query: ({ id, isAdmin, productId }) => ({
+        url: isAdmin ? `/admin/product-versions/${id}` : `/product-versions/${id}`,
+        params: productId ? { productId } : undefined,
+      }),
+      providesTags: ['ProductVersions'],
+      transformResponse: ({ version }: { version: ProductVersion }) => keysToCamel(version),
+    }),
+
+    createProductVersion: builder.mutation<ProductVersion, { payload: ProductVersionPayload }>({
+      query: ({ payload }) => ({
+        url: '/admin/product-versions',
+        method: 'POST',
+        body: {
+          product_id: payload.productId,
+          name: payload.name,
+          description: payload.description,
+          resource_url: payload.resourceUrl,
+          resource_spec: payload.resourceSpec,
+          resource_params: payload.resourceParams,
+          version_status: payload.versionStatus,
+          rank: payload.rank,
+        },
+      }),
+      invalidatesTags: ['ProductVersions'],
+      transformResponse: ({ version }: { version: ProductVersion }) => keysToCamel(version),
+    }),
+
+    updateProductVersion: builder.mutation<ProductVersion, { payload: ProductVersionPayload & { id: string } }>({
+      query: ({ payload: { id, ...patch } }) => ({
+        url: `/admin/product-versions/${id}`,
+        method: 'PATCH',
+        body: {
+          product_id: patch.productId,
+          name: patch.name,
+          description: patch.description,
+          resource_url: patch.resourceUrl,
+          resource_spec: patch.resourceSpec,
+          resource_params: patch.resourceParams,
+          version_status: patch.versionStatus,
+          rank: patch.rank,
+        },
+      }),
+      invalidatesTags: ['ProductVersions'],
+      transformResponse: ({ version }: { version: ProductVersion }) => keysToCamel(version),
+    }),
+
+    deleteProductVersion: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/admin/product-versions/${id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['ProductVersions'],
+    }),
+
+    checkProductVersionNameAvailability: builder.query<
+      { value: string; isAvailable: boolean },
+      { value: string; productId: string }
+    >({
+      query: (params) => ({
+        url: '/search/availability/product-version',
+        params,
+      }),
+      transformResponse: (res) => keysToCamel(res),
+    }),
+  }),
+})
+
+export const {
+  useGetProductVersionsQuery,
+  useGetOneProductVersionQuery,
+  useCreateProductVersionMutation,
+  useUpdateProductVersionMutation,
+  useDeleteProductVersionMutation,
+  useLazyCheckProductVersionNameAvailabilityQuery,
+  util: { getRunningQueriesThunk },
+} = productVersionsApiSlice
+
+export const { getProductVersions, getOneProductVersion } = productVersionsApiSlice.endpoints

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

@@ -0,0 +1,169 @@
+// src/store/api/products.slice.ts
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { EntityStatus, Product, ProductPayload, ProductType } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiPagingResponse } from '@helpers/types'
+
+type GetParams = {
+  nameLike?: string
+  type?: ProductType
+  excludeType?: ProductType | ProductType[]
+  skipProductSlugs?: string[]
+  status?: EntityStatus
+  limit?: number
+  page?: number
+  isAdmin?: boolean
+  isSubscribed?: boolean
+  isPublic?: boolean
+  include?: string[] // e.g., ['plans', 'featureEntitlements']
+  picker?: boolean
+  orderBy?: string
+  sort?: 'asc' | 'desc'
+}
+
+export const productsApiSlice = createApi({
+  reducerPath: 'api/products',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL,
+    credentials: 'include',
+  }),
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any).payload[reducerPath]
+    }
+  },
+  tagTypes: ['Products'],
+  endpoints: (builder) => ({
+    getProducts: builder.query<ApiPagingResponse<Product>, GetParams & { showAll?: boolean; isAdmin?: boolean }>({
+      query: ({ showAll, isAdmin, ...params }) => ({
+        url: isAdmin ? '/admin/products' : '/products',
+        params: { ...params, ...(showAll ? { showAll: true } : {}) },
+      }),
+      providesTags: (result) =>
+        result?.results?.length
+          ? [
+            { type: 'Products' as const, id: 'LIST' },
+            ...result.results.map((p) => ({ type: 'Products' as const, id: String(p.id) })),
+          ]
+          : [{ type: 'Products' as const, id: 'LIST' }],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+
+    getOneProduct: builder.query<Product, { id: string; isAdmin?: boolean; include?: string[]; includePlanFeatures?: boolean }>({
+      query: ({ id, isAdmin, include, includePlanFeatures }) => ({
+        url: isAdmin ? `/admin/products/${id}` : `/products/${id}`,
+        params: {
+          ...(include?.length ? { include: include.join(',') } : {}),
+          ...(includePlanFeatures ? { includePlanFeatures: true } : {}),
+        },
+      }),
+      providesTags: (_result, _err, arg) => [{ type: 'Products' as const, id: String(arg.id) }],
+      transformResponse: ({ product }: { product: Product }) => keysToCamel(product),
+    }),
+
+    getProductPrices: builder.query<any, { productId: string }>({
+      query: ({ productId }) => ({
+        url: `/products/${productId}/prices`,
+      }),
+      transformResponse: (res) => keysToCamel(res),
+    }),
+
+    createProduct: builder.mutation<Product, { payload: ProductPayload }>({
+      query: ({ payload }) => ({
+        url: '/admin/products',
+        method: 'POST',
+        body: {
+          slug: payload.slug,
+          name: payload.name,
+          status: payload.status,
+          description: payload.description,
+          rank: payload.rank,
+          product_icon_media_id: payload.productIconMediaId,
+          screenshot_media_ids: payload.screenshotMediaIds,
+          type: payload.type,
+          intro: payload.intro,
+          form_specs: payload.formSpecs,
+          feature_entitlements: payload.featureEntitlements?.map((entitlement) => ({
+            id: entitlement.id,
+            feature_id: entitlement.featureId,
+            slug: entitlement.slug,
+            is_enabled: entitlement.isEnabled,
+            included_units: entitlement.includedUnits,
+            overage_unit_amount: entitlement.overageUnitAmount,
+            hard_cap: entitlement.hardCap,
+            stripe_meter_id: entitlement.stripeMeterId,
+            stripe_price_id: entitlement.stripePriceId,
+          })),
+        },
+      }),
+      invalidatesTags: ['Products'],
+      transformResponse: ({ product }: { product: Product }) => keysToCamel(product),
+    }),
+
+    updateProduct: builder.mutation<Product, { payload: ProductPayload & { id: string } }>({
+      query: ({ payload: { id, ...patch } }) => ({
+        url: `/admin/products/${id}`,
+        method: 'PATCH',
+        body: {
+          slug: patch.slug,
+          name: patch.name,
+          status: patch.status,
+          description: patch.description,
+          rank: patch.rank,
+          product_icon_media_id: patch.productIconMediaId,
+          screenshot_media_ids: patch.screenshotMediaIds,
+          type: patch.type,
+          intro: patch.intro,
+          form_specs: patch.formSpecs,
+          feature_entitlements: patch.featureEntitlements?.map((entitlement) => ({
+            id: entitlement.id,
+            feature_id: entitlement.featureId,
+            slug: entitlement.slug,
+            is_enabled: entitlement.isEnabled,
+            included_units: entitlement.includedUnits,
+            overage_unit_amount: entitlement.overageUnitAmount,
+            hard_cap: entitlement.hardCap,
+            stripe_meter_id: entitlement.stripeMeterId,
+            stripe_price_id: entitlement.stripePriceId,
+          })),
+        },
+      }),
+      invalidatesTags: ['Products'],
+      transformResponse: ({ product }: { product: Product }) => keysToCamel(product),
+    }),
+
+    deleteProduct: builder.mutation<void, { product: Product }>({
+      query: ({ product }) => ({
+        url: `/admin/products/${product.id}`,
+        method: 'DELETE',
+      }),
+      invalidatesTags: ['Products'],
+    }),
+
+    checkProductSlugAvailability: builder.query<
+      { value: string; isAvailable: boolean },
+      { value: string }
+    >({
+      query: (params) => ({
+        url: '/search/availability/product',
+        params,
+      }),
+      transformResponse: (res) => keysToCamel(res),
+    }),
+  }),
+})
+
+export const {
+  useGetProductsQuery,
+  useGetOneProductQuery,
+  useGetProductPricesQuery,
+  useCreateProductMutation,
+  useUpdateProductMutation,
+  useDeleteProductMutation,
+  useLazyCheckProductSlugAvailabilityQuery,
+  util: { getRunningQueriesThunk },
+} = productsApiSlice
+
+export const { getProducts, getOneProduct, getProductPrices } = productsApiSlice.endpoints