chore: wip

Author: glennmichael123

storage/framework/core/commerce/src/customers/fetch.ts

@@ -22,77 +22,61 @@ export interface PaginatedCustomers {
   }
 }
 
-export interface CustomerStats {
-  total: number
-  active: number
-  inactive: number
-  topSpenders: Partial<CustomersTable>[]
-  recentCustomers: Partial<CustomersTable>[]
-}
-
 /**
- * Fetch all customers from the database
+ * Fetch a customer by ID
  */
-export async function fetchAll(): Promise<CustomersTable[]> {
+export async function fetchById(id: number): Promise<CustomersTable | undefined> {
   return await db
     .selectFrom('customers')
+    .where('id', '=', id)
     .selectAll()
-    .execute()
+    .executeTakeFirst()
 }
 
 /**
- * Fetch customers with pagination, sorting, and filtering options
+ * Fetch customers with simple pagination, sorting, and basic search
+ * A minimal implementation that works well while planning for Algolia/Meilisearch
  */
 export async function fetchPaginated(options: FetchCustomersOptions = {}): Promise<PaginatedCustomers> {
   // Set default values
   const page = options.page || 1
   const limit = options.limit || 10
-  const offset = (page - 1) * limit
   const sortBy = options.sortBy || 'created_at'
   const sortOrder = options.sortOrder || 'desc'
 
   // Start building the query
   let query = db.selectFrom('customers')
   let countQuery = db.selectFrom('customers')
 
-  // Apply search filter if provided
-  if (options.search) {
-    const searchTerm = `%${options.search}%`
-    const searchFilter = eb => eb.or([
-      eb('name', 'like', searchTerm),
-      eb('email', 'like', searchTerm),
-      eb('phone', 'like', searchTerm),
-    ])
-
-    query = query.where(searchFilter)
-    countQuery = countQuery.where(searchFilter)
+  // Simple name search if provided
+  if (options.search && options.search.trim()) {
+    const searchTerm = `%${options.search.trim()}%`
+    query = query.where('name', 'like', searchTerm)
+    countQuery = countQuery.where('name', 'like', searchTerm)
   }
 
-  // Apply status filter if provided and not 'all'
+  // Basic status filter
   if (options.status && options.status !== 'all') {
     query = query.where('status', '=', options.status)
     countQuery = countQuery.where('status', '=', options.status)
   }
 
-  // Get total count for pagination
+  // Get total count
   const countResult = await countQuery
     .select(eb => eb.fn.count('id').as('total'))
     .executeTakeFirst()
 
   const total = Number(countResult?.total || 0)
 
-  // Apply sorting
-  // Note: Ensure the column is valid to prevent SQL injection
-  const validColumns = ['name', 'email', 'orders', 'totalSpent', 'lastOrder', 'status', 'created_at', 'updated_at']
-  const validSortBy = validColumns.includes(sortBy) ? sortBy : 'created_at'
-
-  query = query.orderBy(validSortBy, sortOrder)
+  // Basic sorting
+  query = query.orderBy(sortBy, sortOrder)
 
-  // Apply pagination
-  query = query.limit(limit).offset(offset)
-
-  // Execute the query
-  const customers = await query.selectAll().execute()
+  // Basic pagination
+  const customers = await query
+    .selectAll()
+    .limit(limit)
+    .offset((page - 1) * limit)
+    .execute()
 
   // Calculate pagination info
   const totalPages = Math.ceil(total / limit)
@@ -109,58 +93,3 @@ export async function fetchPaginated(options: FetchCustomersOptions = {}): Promi
     },
   }
 }
-
-/**
- * Fetch a customer by ID
- */
-export async function fetchById(id: number): Promise<CustomersTable | undefined> {
-  return await db
-    .selectFrom('customers')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst()
-}
-
-/**
- * Get customer statistics
- */
-export async function fetchStats(): Promise<CustomerStats> {
-  const totalCustomers = await db
-    .selectFrom('customers')
-    .select(eb => eb.fn.count('id').as('count'))
-    .executeTakeFirst()
-
-  const activeCustomers = await db
-    .selectFrom('customers')
-    .where('status', '=', 'Active')
-    .select(eb => eb.fn.count('id').as('count'))
-    .executeTakeFirst()
-
-  const inactiveCustomers = await db
-    .selectFrom('customers')
-    .where('status', '=', 'Inactive')
-    .select(eb => eb.fn.count('id').as('count'))
-    .executeTakeFirst()
-
-  const topSpenders = await db
-    .selectFrom('customers')
-    .select(['id', 'name', 'email', 'total_spent'])
-    .orderBy('total_spent', 'desc')
-    .limit(5)
-    .execute()
-
-  const recentCustomers = await db
-    .selectFrom('customers')
-    .select(['id', 'name', 'email', 'created_at'])
-    .orderBy('created_at', 'desc')
-    .limit(5)
-    .execute()
-
-  return {
-    total: Number(totalCustomers?.count || 0),
-    active: Number(activeCustomers?.count || 0),
-    inactive: Number(inactiveCustomers?.count || 0),
-    topSpenders,
-    recentCustomers,
-  }
-}

storage/framework/core/commerce/src/customers/index.ts

@@ -1,16 +1,6 @@
-// Export types
-// Export fetch functionality
 export {
-  type CustomerStats,
-  fetchAll,
   fetchById,
   type FetchCustomersOptions,
   fetchPaginated,
-  fetchStats,
   type PaginatedCustomers,
 } from './fetch'
-
-// Future exports will go here
-// export * from './store'
-// export * from './update'
-// export * from './delete'

storage/framework/core/commerce/src/customers/update.ts

@@ -14,13 +14,25 @@ import { db } from '@stacksjs/database'
  */
 export async function update(id: number, request: CustomerRequestType): Promise<CustomerType | undefined> {
   try {
-    // Create the update data object by picking only defined properties from the request
-    const updateData: CustomerUpdate = Object.entries(request)
-      .filter(([_, value]) => value !== undefined)
-      .reduce((obj, [key, value]) => {
-        obj[key] = value
-        return obj
-      }, {} as CustomerUpdate)
+    // Create a single update data object directly from the request
+    const updateData: CustomerUpdate = {
+      name: request.get('name'),
+      email: request.get('email'),
+      phone: request.get('phone'),
+      orders: request.get<number>('orders'),
+      total_spent: request.get<number>('totalSpent'),
+      last_order: request.get('lastOrder'),
+      status: request.get('status'),
+      avatar: request.get('avatar'),
+      user_id: request.get<number>('user_id'),
+    }
+
+    // Remove undefined values
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key as keyof CustomerUpdate] === undefined) {
+        delete updateData[key as keyof CustomerUpdate]
+      }
+    })
 
     // Skip update if no fields are provided
     if (Object.keys(updateData).length === 0) {

storage/framework/core/orm/src/utils.ts

@@ -707,7 +707,7 @@ export async function writeModelRequest(): Promise<void> {
       }
     }
 
-    fieldStringType += ` get<T>(key: T): string | undefined`
+    fieldStringType += ` get<T>(key: string): T | undefined`
 
     const otherModelRelations = await fetchOtherModelRelations(modelName)
 

storage/framework/server-auto-imports.json

@@ -244,4 +244,4 @@
     "transactionRequest": true,
     "userRequest": true
   }
-}
+}