@stacksjs/commerce 0.70.53 → 0.70.55

package/src/products/items/destroy.ts

@@ -0,0 +1,54 @@
+import { db } from '@stacksjs/database'
+
+/**
+ * Delete a product item by ID
+ *
+ * @param id The ID of the product item to delete
+ * @returns True if the product item was deleted, false otherwise
+ */
+export async function destroy(id: number): Promise<boolean> {
+  try {
+    const result = await db
+      .deleteFrom('products')
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    return Number(result.numDeletedRows) > 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete product item: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Delete multiple product items by ID
+ *
+ * @param ids Array of product item IDs to delete
+ * @returns Number of product items deleted
+ */
+export async function bulkDestroy(ids: number[]): Promise<number> {
+  if (!ids.length)
+    return 0
+
+  try {
+    // Perform the delete operation
+    const result = await db
+      .deleteFrom('products')
+      .where('id', 'in', ids)
+      .executeTakeFirst()
+
+    // Return the number of deleted rows
+    return Number(result.numDeletedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete product items: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/products/items/fetch.ts

@@ -0,0 +1,282 @@
+type ProductJsonResponse = ModelRow<typeof Product>
+import type { StacksExpressionBuilder } from '@stacksjs/database'
+import { db, sql } from '@stacksjs/database'
+
+/**
+ * Fetch a product item by ID
+ */
+export async function fetchById(id: number): Promise<ProductJsonResponse | undefined> {
+  const model = await db
+    .selectFrom('products')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst()
+
+  if (model) {
+    let manufacturer = null
+    let category = null
+
+    if (model.manufacturer_id) {
+      manufacturer = await db
+        .selectFrom('manufacturers')
+        .where('id', '=', model.manufacturer_id)
+        .selectAll()
+        .executeTakeFirst()
+    }
+
+    if (model.category_id) {
+      category = await db
+        .selectFrom('categories')
+        .where('id', '=', model.category_id)
+        .selectAll()
+        .executeTakeFirst()
+    }
+
+    return {
+      ...model,
+      manufacturer,
+      category,
+    } as unknown as ProductJsonResponse
+  }
+
+  return undefined
+}
+
+/**
+ * Fetch all product items with their manufacturers and categories
+ */
+export async function fetchAll(): Promise<ProductJsonResponse[]> {
+  // Fetch all products
+  const models = await db.selectFrom('products').selectAll().execute()
+
+  // Get the IDs of all manufacturers and categories
+  const manufacturerIds = models.map((model: any) => model.manufacturer_id).filter((id: any) => id !== null && id !== undefined)
+  const categoryIds = models.map((model: any) => model.category_id).filter((id: any) => id !== null && id !== undefined)
+
+  let manufacturersQuery = db.selectFrom('manufacturers') as any
+  let categoriesQuery = db.selectFrom('categories') as any
+
+  if (manufacturerIds.length > 0) {
+    manufacturersQuery = manufacturersQuery.where('id', 'in', manufacturerIds)
+  }
+
+  if (categoryIds.length > 0) {
+    categoriesQuery = categoriesQuery.where('id', 'in', categoryIds)
+  }
+
+  // Fetch manufacturers and categories for these specific IDs using WHERE IN
+  const allManufacturers = await manufacturersQuery.selectAll().execute()
+  const allCategories = await categoriesQuery.selectAll().execute()
+
+  // Group manufacturers and categories by ID
+  const manufacturersById = allManufacturers.reduce((acc: any, manufacturer: any) => {
+    acc[manufacturer.id] = manufacturer
+    return acc
+  }, {} as Record<number, typeof allManufacturers[0]>)
+
+  const categoriesById = allCategories.reduce((acc: any, category: any) => {
+    acc[category.id] = category
+    return acc
+  }, {} as Record<number, typeof allCategories[0]>)
+
+  // Attach manufacturers and categories to each product
+  return models.map((model: any) => ({
+    ...model,
+    manufacturer: model.manufacturer_id ? manufacturersById[model.manufacturer_id] : null,
+    category: model.category_id ? categoriesById[model.category_id] : null,
+  }))
+}
+
+/**
+ * Get products by manufacturer
+ *
+ * @param manufacturerId Manufacturer identifier
+ * @returns List of products for the specified manufacturer
+ */
+export async function getProductsByManufacturer(manufacturerId: number): Promise<ProductJsonResponse[]> {
+  try {
+    const products = await db
+      .selectFrom('products')
+      .selectAll()
+      .where('manufacturer_id', '=', manufacturerId)
+      .orderBy('name')
+      .execute()
+
+    return products as ProductJsonResponse[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get products by manufacturer: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Get products by category
+ *
+ * @param categoryId Category identifier
+ * @returns List of products for the specified category
+ */
+export async function getProductsByCategory(categoryId: number): Promise<ProductJsonResponse[]> {
+  try {
+    const products = await db
+      .selectFrom('products')
+      .selectAll()
+      .where('category_id', '=', categoryId)
+      .orderBy('name')
+      .execute()
+
+    return products as ProductJsonResponse[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get products by category: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Get product by UUID
+ *
+ * @param uuid Product UUID
+ * @returns Matching product or undefined
+ */
+export async function getProductByUuid(uuid: string): Promise<ProductJsonResponse | undefined> {
+  try {
+    const product = await db
+      .selectFrom('products')
+      .selectAll()
+      .where('uuid', '=', uuid)
+      .executeTakeFirst()
+
+    return product as ProductJsonResponse | undefined
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get product by UUID: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Format product options for dropdown menus or selectors
+ *
+ * @returns Array of formatted product options with id, name, uuid, and price
+ */
+export async function formatProductOptions(): Promise<{ id: number, name: string, uuid: string, price: number }[]> {
+  try {
+    const results = await db
+      .selectFrom('products')
+      .select(['id', 'name', 'uuid', 'price'])
+      .orderBy('name')
+      .execute()
+
+    // Filter out any results with undefined/null values to match the return type
+    return results.filter((result: any) =>
+      result.name !== null
+      && result.name !== undefined
+      && result.uuid !== null
+      && result.uuid !== undefined
+      && result.price !== null
+      && result.price !== undefined,
+    ) as { id: number, name: string, uuid: string, price: number }[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to format product options: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Get products by price range
+ *
+ * @param minPrice Minimum price
+ * @param maxPrice Maximum price
+ * @returns List of products within the specified price range
+ */
+export async function getProductsByPriceRange(minPrice: number, maxPrice: number): Promise<ProductJsonResponse[]> {
+  try {
+    const products = await db
+      .selectFrom('products')
+      .selectAll()
+      .where('price', '>=', minPrice)
+      .where('price', '<=', maxPrice)
+      .orderBy('price')
+      .execute()
+
+    return products as ProductJsonResponse[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get products by price range: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Top-selling products by units sold.
+ *
+ * Aggregates `order_items` (the line-item table — each row is one
+ * product on one order) grouping by product, summing quantity for the
+ * "units sold" rank and the line-item revenue (price × quantity) for
+ * the revenue side. Joins back to `products` so we can return the
+ * product name + current inventory inline; if a product was deleted
+ * after sales were recorded, that row is skipped (INNER JOIN).
+ *
+ * Revenue uses the price stored on `order_items` (price-at-sale)
+ * rather than the current `products.price`, so historical numbers
+ * stay correct even when prices change.
+ */
+export interface TopProductRow {
+  id: number
+  name: string
+  units_sold: number
+  revenue: number
+  inventory_count: number
+}
+
+export async function fetchTopProducts(limit: number = 5): Promise<TopProductRow[]> {
+  try {
+    const rows = await db
+      .selectFrom('order_items')
+      .innerJoin('products', 'products.id', 'order_items.product_id')
+      .select([
+        'products.id as id',
+        'products.name as name',
+        'products.inventory_count as inventory_count',
+        ((eb: StacksExpressionBuilder) => eb.fn.sum('order_items.quantity').as('units_sold')) as any,
+        // Multiply line-item price × quantity inline. Falls back to the
+        // current product price if order_items.price is null (older data).
+        sql<number>`SUM(COALESCE(order_items.price, products.price) * order_items.quantity)`.as('revenue') as any,
+      ])
+      .groupBy(['products.id', 'products.name', 'products.inventory_count'])
+      .orderBy('units_sold', 'desc')
+      .limit(limit)
+      .execute()
+
+    return rows.map((r: any) => ({
+      id: Number(r.id),
+      name: String(r.name ?? 'Unnamed product'),
+      units_sold: Number(r.units_sold ?? 0),
+      revenue: Number(r.revenue ?? 0),
+      inventory_count: Number(r.inventory_count ?? 0),
+    }))
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to fetch top products: ${error.message}`)
+    }
+    throw error
+  }
+}

package/src/products/items/index.ts

@@ -0,0 +1,26 @@
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+// Functions from fetch.ts
+export type { TopProductRow } from './fetch'
+export {
+  fetchAll,
+  fetchById,
+  fetchTopProducts,
+} from './fetch'
+
+// Functions from store.ts
+export {
+  bulkStore,
+  store,
+} from './store'
+
+// Functions from update.ts
+export {
+  update,
+  updateAvailability,
+  updateInventory,
+} from './update'

package/src/products/items/store.ts

@@ -0,0 +1,84 @@
+type ProductJsonResponse = ModelRow<typeof Product>
+type NewProduct = NewModelData<typeof Product>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { fetchById } from './fetch'
+
+/**
+ * Create a new product item
+ *
+ * @param data The product item data to store
+ * @returns The newly created product item record
+ */
+export async function store(data: NewProduct): Promise<ProductJsonResponse> {
+  try {
+    const itemData = {
+      ...data,
+      uuid: randomUUIDv7(),
+    }
+
+    const result = await db
+      .insertInto('products')
+      .values(itemData)
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create product item')
+
+    const insertId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
+
+    const model = await fetchById(insertId)
+
+    if (!model)
+      throw new Error('Failed to create product item')
+
+    return model
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create product item: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Create multiple product items at once
+ *
+ * @param data Array of product item data to store
+ * @returns Number of product items created
+ */
+export async function bulkStore(data: NewProduct[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  let createdCount = 0
+
+  try {
+    await (db as any).transaction().execute(async (trx: any) => {
+      for (const item of data) {
+        const itemData = {
+          ...item,
+          uuid: randomUUIDv7(),
+        }
+
+        await trx
+          .insertInto('products')
+          .values(itemData)
+          .execute()
+
+        createdCount++
+      }
+    })
+
+    return createdCount
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create product items in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}