@stacksjs/defaults 0.70.207 → 0.70.208

package/functions/cms/posts.ts

@@ -0,0 +1,100 @@
+import type { Posts, StorePost } from '../../types/defaults'
+import { useFetch, useStorage } from '@stacksjs/browser'
+
+// Create a persistent posts array using STX useStorage
+const posts = useStorage<Posts[]>('posts', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+// Basic fetch function to get all posts
+async function fetchPosts() {
+  const { error, data } = await useFetch(`${baseURL}/cms/posts`).get().json()
+
+  const postsJson = data.value as Posts[]
+  if (error.value) {
+    console.error('Error fetching posts:', error.value)
+    return []
+  }
+
+  // Ensure data is an array before assigning
+  if (Array.isArray(data.value)) {
+    posts.value = postsJson
+    return data.value
+  }
+  else {
+    console.error('Expected array of posts but received:', typeof data.value)
+    return []
+  }
+}
+
+async function createPost(post: Partial<StorePost>): Promise<Posts | null> {
+  const { error, data } = await useFetch(`${baseURL}/cms/posts`)
+    .post(JSON.stringify(post))
+    .json()
+
+  if (error.value) {
+    console.error('Error creating post:', error.value)
+    return null
+  }
+
+  const newPost = data.value as Posts
+  if (newPost) {
+    posts.value.unshift(newPost)
+    return newPost
+  }
+  return null
+}
+
+async function updatePost(id: number, post: Partial<Posts>) {
+  const { error, data } = await useFetch(`${baseURL}/cms/posts/${id}`)
+    .patch(JSON.stringify({
+      ...post,
+      author_name: post.author_name,
+      author_email: post.author_email,
+    }))
+    .json()
+
+  if (error.value) {
+    console.error('Error updating post:', error.value)
+    return null
+  }
+
+  const updatedPost = data.value as Posts
+  if (updatedPost) {
+    const index = posts.value.findIndex(p => p.id === id)
+    if (index !== -1) {
+      posts.value[index] = updatedPost
+    }
+    return updatedPost
+  }
+  return null
+}
+
+async function deletePost(id: number) {
+  const { error } = await useFetch(`${baseURL}/cms/posts/${id}`)
+    .delete()
+    .json()
+
+  if (error.value) {
+    console.error('Error deleting post:', error.value)
+    return false
+  }
+
+  const index = posts.value.findIndex(p => p.id === id)
+  if (index !== -1) {
+    posts.value.splice(index, 1)
+  }
+
+  return true
+}
+
+// Export the composable
+export function usePosts() {
+  return {
+    posts,
+    fetchPosts,
+    createPost,
+    updatePost,
+    deletePost,
+  }
+}

package/functions/cms/taggables.ts

@@ -0,0 +1,102 @@
+import type { Taggables } from '../../types/defaults'
+import { useFetch, useStorage } from '@stacksjs/browser'
+
+// Create a persistent tags array using STX useStorage
+const taggables = useStorage<Taggables[]>('taggables', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+// Basic fetch function to get all tags
+async function fetchTaggables(): Promise<Taggables[]> {
+  const { error, data } = await useFetch(`${baseURL}/cms/tags`).get().json()
+
+  const taggablesJson = data.value as Taggables[]
+  if (error.value) {
+    console.error('Error fetching taggables:', error.value)
+    return []
+  }
+
+  // Ensure data is an array before assigning
+  if (Array.isArray(data.value)) {
+    taggables.value = taggablesJson
+
+    return taggablesJson
+  }
+  else {
+    console.error('Expected array of taggables but received:', typeof data.value)
+    return []
+  }
+}
+
+async function createTaggable(taggable: Partial<Taggables>) {
+  const taggableData = {
+    ...taggable,
+    taggable_type: 'posts',
+  }
+
+  const { error, data } = await useFetch(`${baseURL}/cms/tags`)
+    .post(JSON.stringify(taggableData))
+    .json()
+
+  if (error.value) {
+    console.error('Error creating taggable:', error.value)
+    return null
+  }
+
+  const newTaggable = data.value as Taggables
+  if (newTaggable) {
+    taggables.value.push(newTaggable)
+    return newTaggable
+  }
+  return null
+}
+
+async function updateTaggable(id: number, taggable: Partial<Taggables>) {
+  const { error, data } = await useFetch(`${baseURL}/cms/tags/${id}`)
+    .patch(JSON.stringify(taggable))
+    .json()
+
+  if (error.value) {
+    console.error('Error updating taggable:', error.value)
+    return null
+  }
+
+  const updatedTaggable = data.value as Taggables
+  if (updatedTaggable) {
+    const index = taggables.value.findIndex(t => t.id === id)
+    if (index !== -1) {
+      taggables.value[index] = updatedTaggable
+    }
+    return updatedTaggable
+  }
+  return null
+}
+
+async function deleteTaggable(id: number) {
+  const { error } = await useFetch(`${baseURL}/cms/tags/${id}`)
+    .delete()
+    .json()
+
+  if (error.value) {
+    console.error('Error deleting taggable:', error.value)
+    return false
+  }
+
+  const index = taggables.value.findIndex(t => t.id === id)
+  if (index !== -1) {
+    taggables.value.splice(index, 1)
+  }
+
+  return true
+}
+
+// Export the composable
+export function useTaggables() {
+  return {
+    taggables,
+    fetchTaggables,
+    createTaggable,
+    updateTaggable,
+    deleteTaggable,
+  }
+}

package/functions/commerce/coupons.ts

@@ -0,0 +1,128 @@
+import type { Coupons, NewCoupon } from '../../types/defaults'
+import { useStorage } from '@stacksjs/browser'
+import { pushToast } from '../toasts'
+
+// Create a persistent coupons array using STX useStorage
+const coupons = useStorage<Coupons[]>('coupons', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+// Basic fetch function to get all coupons
+async function fetchCoupons() {
+  try {
+    const response = await fetch(`${baseURL}/commerce/coupons`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: Coupons[] }
+
+    if (Array.isArray(data)) {
+      // Update both the storage and the reactive ref
+      coupons.value = data
+
+      return data
+    }
+    else {
+      pushToast('error', 'Couldn\'t load coupons', { detail: `Expected array but received ${typeof data}` })
+      return []
+    }
+  }
+  catch (error) {
+    pushToast('error', 'Couldn\'t load coupons', { detail: String(error) })
+    return coupons.value
+  }
+}
+
+async function createCoupon(coupon: Omit<Coupons, 'id'>) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/coupons`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(coupon),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as Coupons
+    if (data) {
+      coupons.value = [...coupons.value, data]
+      pushToast('success', 'Coupon created')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to create coupon', { detail: String(error) })
+    return null
+  }
+}
+
+async function updateCoupon(id: number, coupon: NewCoupon) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/coupons/${id}`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(coupon),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as Coupons
+    if (data) {
+      const index = coupons.value.findIndex(c => c.id === coupon.id)
+      if (index !== -1) {
+        coupons.value = [
+          ...coupons.value.slice(0, index),
+          data,
+          ...coupons.value.slice(index + 1),
+        ]
+      }
+      pushToast('success', 'Coupon updated')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to update coupon', { detail: String(error) })
+    return null
+  }
+}
+
+async function deleteCoupon(id: number) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/coupons/${id}`, {
+      method: 'DELETE',
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    coupons.value = coupons.value.filter(c => c.id !== id)
+    pushToast('success', 'Coupon deleted')
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Failed to delete coupon', { detail: String(error) })
+    return false
+  }
+}
+
+// Export the composable
+export function useCoupons() {
+  return {
+    coupons,
+    fetchCoupons,
+    createCoupon,
+    updateCoupon,
+    deleteCoupon,
+  }
+}

package/functions/commerce/customers.ts

@@ -0,0 +1,128 @@
+import type { Customers } from '../../types/defaults'
+import { useStorage } from '@stacksjs/browser'
+import { pushToast } from '../toasts'
+
+// Create a persistent customers array using STX useStorage
+const customers = useStorage<Customers[]>('customers', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+// Basic fetch function to get all customers
+async function fetchCustomers() {
+  try {
+    const response = await fetch(`${baseURL}/commerce/customers`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: Customers[] }
+
+    if (Array.isArray(data)) {
+      // Update both the storage and the reactive ref
+      customers.value = data
+      return data
+    }
+    else {
+      pushToast('error', 'Couldn\'t load customers', { detail: `Expected array but received ${typeof data}` })
+      return []
+    }
+  }
+  catch (error) {
+    pushToast('error', 'Couldn\'t load customers', { detail: String(error) })
+    // Fall back to whatever we already had cached
+    return customers.value
+  }
+}
+
+async function createCustomer(customer: Omit<Customers, 'id'>) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/customers`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(customer),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const { data } = await response.json() as { data: Customers }
+    if (data) {
+      customers.value = [...customers.value, data]
+      pushToast('success', 'Customer created')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to create customer', { detail: String(error) })
+    return null
+  }
+}
+
+async function updateCustomer(customer: Customers) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/customers/${customer.id}`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(customer),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const { data } = await response.json() as { data: Customers }
+    if (data) {
+      const index = customers.value.findIndex(c => c.id === customer.id)
+      if (index !== -1) {
+        customers.value = [
+          ...customers.value.slice(0, index),
+          data,
+          ...customers.value.slice(index + 1),
+        ]
+      }
+      pushToast('success', 'Customer updated')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to update customer', { detail: String(error) })
+    return null
+  }
+}
+
+async function deleteCustomer(id: number) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/customers/${id}`, {
+      method: 'DELETE',
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    customers.value = customers.value.filter(c => c.id !== id)
+    pushToast('success', 'Customer deleted')
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Failed to delete customer', { detail: String(error) })
+    return false
+  }
+}
+
+// Export the composable
+export function useCustomers() {
+  return {
+    customers,
+    fetchCustomers,
+    createCustomer,
+    updateCustomer,
+    deleteCustomer,
+  }
+}

package/functions/commerce/gift-cards.ts

@@ -0,0 +1,119 @@
+import type { GiftCards } from '../../types/defaults'
+import { useStorage } from '@stacksjs/browser'
+import { pushToast } from '../toasts'
+
+// Create a persistent gift cards array using STX useStorage
+const giftCards = useStorage<GiftCards[]>('giftCards', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+async function fetchGiftCards(): Promise<GiftCards[]> {
+  try {
+    const response = await fetch(`${baseURL}/commerce/gift-cards`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const data = await response.json() as GiftCards[]
+
+    if (Array.isArray(data)) {
+      giftCards.value = data
+      return data
+    }
+    else {
+      pushToast('error', 'Couldn\'t load gift cards', { detail: `Expected array but received ${typeof data}` })
+      return []
+    }
+  }
+  catch (error) {
+    pushToast('error', 'Couldn\'t load gift cards', { detail: String(error) })
+    return giftCards.value
+  }
+}
+
+async function createGiftCard(giftCard: GiftCards): Promise<GiftCards | null> {
+  try {
+    const response = await fetch(`${baseURL}/commerce/gift-cards`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(giftCard),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as GiftCards
+    if (data) {
+      giftCards.value.push(data)
+      pushToast('success', 'Gift card created')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to create gift card', { detail: String(error) })
+    return null
+  }
+}
+
+async function updateGiftCard(giftCard: GiftCards): Promise<GiftCards | null> {
+  try {
+    const response = await fetch(`${baseURL}/commerce/gift-cards/${giftCard.id}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(giftCard),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as GiftCards
+    if (data) {
+      const index = giftCards.value.findIndex(g => g.id === giftCard.id)
+      if (index !== -1) {
+        giftCards.value[index] = data
+      }
+      pushToast('success', 'Gift card updated')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to update gift card', { detail: String(error) })
+    return null
+  }
+}
+
+async function deleteGiftCard(id: number): Promise<boolean> {
+  try {
+    const response = await fetch(`${baseURL}/commerce/gift-cards/${id}`, {
+      method: 'DELETE',
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const index = giftCards.value.findIndex(g => g.id === id)
+    if (index !== -1) {
+      giftCards.value.splice(index, 1)
+    }
+    pushToast('success', 'Gift card deleted')
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Failed to delete gift card', { detail: String(error) })
+    return false
+  }
+}
+
+export function useGiftCards() {
+  return {
+    giftCards,
+    fetchGiftCards,
+    createGiftCard,
+    updateGiftCard,
+    deleteGiftCard,
+  }
+}

package/functions/commerce/orders.ts

@@ -0,0 +1,112 @@
+import type { Orders } from '../../types/defaults'
+import { useStorage } from '@stacksjs/browser'
+import { pushToast } from '../toasts'
+
+// Create a persistent orders array using STX useStorage
+const orders = useStorage<Orders[]>('orders', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+async function fetchOrders(): Promise<Orders[]> {
+  try {
+    const response = await fetch(`${baseURL}/commerce/orders`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: Orders[] }
+    orders.value = data
+    return data
+  }
+  catch (error) {
+    pushToast('error', 'Couldn\'t load orders', { detail: String(error) })
+    return orders.value
+  }
+}
+
+async function createOrder(order: Orders) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/orders`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(order),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as Orders
+    if (data) {
+      orders.value.push(data)
+      pushToast('success', 'Order created')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to create order', { detail: String(error) })
+    return null
+  }
+}
+
+async function updateOrder(order: Orders) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/orders/${order.id}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(order),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const data = await response.json() as Orders
+    if (data) {
+      const index = orders.value.findIndex(o => o.id === order.id)
+      if (index !== -1) {
+        orders.value[index] = data
+      }
+      pushToast('success', 'Order updated')
+      return data
+    }
+    return null
+  }
+  catch (error) {
+    pushToast('error', 'Failed to update order', { detail: String(error) })
+    return null
+  }
+}
+
+async function deleteOrder(id: number) {
+  try {
+    const response = await fetch(`${baseURL}/commerce/orders/${id}`, {
+      method: 'DELETE',
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    const index = orders.value.findIndex(o => o.id === id)
+    if (index !== -1) {
+      orders.value.splice(index, 1)
+    }
+    pushToast('success', 'Order deleted')
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Failed to delete order', { detail: String(error) })
+    return false
+  }
+}
+
+export function useOrders() {
+  return {
+    orders,
+    fetchOrders,
+    createOrder,
+    updateOrder,
+    deleteOrder,
+  }
+}