@stacksjs/commerce 0.70.53 → 0.70.55

package/src/products/items/update.ts

@@ -0,0 +1,324 @@
+import { db, sql } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type ProductJsonResponse = ModelRow<typeof Product>
+type ProductUpdate = UpdateModelData<typeof Product>
+import { fetchById } from './fetch'
+
+/**
+ * Update a product item
+ *
+ * @param id The ID of the product item to update
+ * @param data The product item data to update
+ * @returns The updated product item record
+ */
+export async function update(id: number, data: Omit<ProductUpdate, 'id'>): Promise<ProductJsonResponse> {
+  try {
+    if (!id)
+      throw new Error('Product item ID is required for update')
+
+    const result = await db
+      .updateTable('products')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update product item')
+
+    return result as ProductJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update product item: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update multiple product items at once
+ *
+ * @param data Array of product item updates
+ * @returns Number of product items updated
+ */
+export async function bulkUpdate(data: ProductUpdate[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  let updatedCount = 0
+
+  try {
+    await (db as any).transaction().execute(async (trx: any) => {
+      for (const item of data) {
+        if (!(item as Record<string, unknown>).id)
+          continue
+
+        const result = await trx
+          .updateTable('products')
+          .set({
+            ...item,
+            updated_at: formatDate(new Date()),
+          })
+          .where('id', '=', (item as Record<string, unknown>).id)
+          .executeTakeFirst()
+
+        if (Number(result.numUpdatedRows) > 0)
+          updatedCount++
+      }
+    })
+
+    return updatedCount
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update product items in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update a product item's availability status
+ *
+ * @param id The ID of the product item
+ * @param isAvailable The new availability status
+ * @returns The updated product item with the new availability status
+ */
+export async function updateAvailability(
+  id: number,
+  isAvailable: boolean,
+): Promise<ProductJsonResponse | undefined> {
+  // Check if product item exists
+  const productItem = await fetchById(id)
+
+  if (!productItem) {
+    throw new Error(`Product item with ID ${id} not found`)
+  }
+
+  try {
+    // Update the product item availability
+    await db
+      .updateTable('products')
+      .set({
+        is_available: isAvailable,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch the updated product item
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update product item availability: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Atomically decrement (or increment) a product's inventory count by `delta`.
+ *
+ * Returns the updated row, or `null` if the requested decrement would push
+ * inventory below zero — that's how callers detect "we sold the last one"
+ * during checkout. The conditional UPDATE means two parallel checkout
+ * requests can't both observe stock=1 and both succeed; the second one
+ * matches zero rows and the function returns null. Existing
+ * `updateInventory(id, count)` keeps the previous "set absolute count"
+ * semantics for admin tooling.
+ */
+export async function adjustInventory(
+  id: number,
+  delta: number,
+): Promise<ProductJsonResponse | null> {
+  if (!Number.isFinite(delta) || delta === 0) {
+    throw new Error('[commerce/inventory] adjustInventory delta must be a non-zero finite number')
+  }
+
+  const result: any = await db
+    .updateTable('products')
+    .set({
+      inventory_count: sql`inventory_count + ${delta}`,
+      updated_at: formatDate(new Date()),
+    })
+    .where('id', '=', id)
+    // Guard against negative stock when decrementing.
+    .where(sql`inventory_count + ${delta}`, '>=', 0)
+    .execute()
+
+  // Drivers report affected rows differently — handle the common shapes.
+  const affected = Number(
+    result?.numUpdatedRows
+    ?? result?.[0]?.numUpdatedRows
+    ?? result?.numAffectedRows
+    ?? 0,
+  )
+
+  if (!affected) return null
+  return (await fetchById(id)) ?? null
+}
+
+/**
+ * Discriminated result for `adjustInventoryMany` — `ok: true` when
+ * every per-item adjustment succeeded; `ok: false` with `failedAt`
+ * (the index in the input array that triggered the rollback) when
+ * any single item couldn't be adjusted (out of stock, missing,
+ * etc.). All adjustments roll back as a unit on failure.
+ */
+export type InventoryBatchResult =
+  | { ok: true, products: ProductJsonResponse[] }
+  | { ok: false, failedAt: number, productId: number, reason: 'out-of-stock' | 'not-found' }
+
+/**
+ * Atomic batch inventory adjustment (stacksjs/stacks#1879 Co-2).
+ *
+ * Pre-fix: a multi-item cart called `adjustInventory(id, delta)` N
+ * times sequentially. If item 2 failed (out of stock), item 1's
+ * decrement was already committed with no rollback — the order
+ * persisted with partial stock reservation and the customer saw
+ * a refund-on-next-page-load surprise.
+ *
+ * Post-fix: wraps the per-item loop in `db.transaction`. Any item
+ * that can't be adjusted (the existing `adjustInventory` returns
+ * null on insufficient stock) throws inside the transaction; the
+ * driver rolls every prior decrement back. Returns a discriminated
+ * result so the cart handler can surface "item X was out of stock"
+ * specifically instead of a generic transaction-failed error.
+ *
+ * @example
+ * ```ts
+ * const result = await adjustInventoryMany([
+ *   { id: cart.itemA, delta: -2 },
+ *   { id: cart.itemB, delta: -1 },
+ * ])
+ * if (!result.ok) {
+ *   throw new HttpError(409, `Item ${result.productId} is out of stock`)
+ * }
+ * ```
+ */
+export async function adjustInventoryMany(
+  updates: ReadonlyArray<{ id: number, delta: number }>,
+): Promise<InventoryBatchResult> {
+  if (updates.length === 0) return { ok: true, products: [] }
+
+  try {
+    const products = await db.transaction().execute(async (trx: any) => {
+      const out: ProductJsonResponse[] = []
+      for (let i = 0; i < updates.length; i++) {
+        const { id, delta } = updates[i]!
+        if (!Number.isFinite(delta) || delta === 0)
+          throw new Error('[commerce/inventory] adjustInventoryMany delta must be a non-zero finite number')
+
+        // Same atomic UPDATE as adjustInventory, but routed through
+        // the transaction handle so all decrements share a single
+        // commit boundary.
+        const result: any = await trx
+          .updateTable('products')
+          .set({
+            inventory_count: sql`inventory_count + ${delta}`,
+            updated_at: formatDate(new Date()),
+          })
+          .where('id', '=', id)
+          .where(sql`inventory_count + ${delta}`, '>=', 0)
+          .execute()
+
+        const affected = Number(
+          result?.numUpdatedRows
+          ?? result?.[0]?.numUpdatedRows
+          ?? result?.numAffectedRows
+          ?? 0,
+        )
+
+        if (!affected) {
+          // Throw a structured error the outer try/catch can convert
+          // into a discriminated result. Driver rolls back automatically.
+          const exists = await trx.selectFrom('products').where('id', '=', id).select('id').executeTakeFirst()
+          const reason = exists ? 'out-of-stock' : 'not-found'
+          throw Object.assign(new Error(`adjustInventoryMany failed at index ${i}: ${reason}`), {
+            __batchFail: true,
+            failedAt: i,
+            productId: id,
+            reason,
+          })
+        }
+
+        const refreshed = await trx.selectFrom('products').where('id', '=', id).selectAll().executeTakeFirst()
+        if (refreshed) out.push(refreshed as ProductJsonResponse)
+      }
+      return out
+    })
+    return { ok: true, products }
+  }
+  catch (err: any) {
+    if (err?.__batchFail) {
+      return {
+        ok: false,
+        failedAt: err.failedAt as number,
+        productId: err.productId as number,
+        reason: err.reason as 'out-of-stock' | 'not-found',
+      }
+    }
+    // Real error (network, schema, etc.) — surface to caller.
+    throw err
+  }
+}
+
+/**
+ * Update inventory information for a product item
+ *
+ * @param id The ID of the product item
+ * @param inventoryCount The updated inventory count
+ * @returns The updated product item
+ */
+export async function updateInventory(
+  id: number,
+  inventoryCount?: number,
+): Promise<ProductJsonResponse | undefined> {
+  // Check if product item exists
+  const productItem = await fetchById(id)
+
+  if (!productItem) {
+    throw new Error(`Product item with ID ${id} not found`)
+  }
+
+  // Create update data with only provided fields
+  const updateData: Record<string, any> = {
+    updated_at: formatDate(new Date()),
+  }
+
+  if (inventoryCount !== undefined) {
+    updateData.inventory_count = inventoryCount
+  }
+
+  // If no inventory fields to update, just return the existing product item
+  if (Object.keys(updateData).length === 1) { // Only updated_at was set
+    return productItem
+  }
+
+  try {
+    // Update the product item
+    await db
+      .updateTable('products')
+      .set(updateData)
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch the updated product item
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update inventory information: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/products/manufacturers/destroy.ts

@@ -0,0 +1,56 @@
+import { db } from '@stacksjs/database'
+
+/**
+ * Delete an order by ID
+ *
+ * @param id The ID of the order to delete
+ * @returns True if the order was deleted, false otherwise
+ */
+export async function destroy(id: number): Promise<boolean> {
+  try {
+    // Perform the delete operation
+    const result = await db
+      .deleteFrom('manufacturers')
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    // Return true if any row was affected (deleted)
+    return Number(result.numDeletedRows) > 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete order: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Delete multiple orders by ID
+ *
+ * @param ids Array of order IDs to delete
+ * @returns Number of orders deleted
+ */
+export async function bulkDestroy(ids: number[]): Promise<number> {
+  if (!ids.length)
+    return 0
+
+  try {
+    // Perform the delete operation
+    const result = await db
+      .deleteFrom('manufacturers')
+      .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 orders: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/products/manufacturers/fetch.ts

@@ -0,0 +1,117 @@
+type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>
+import type { FetchManufacturersOptions, ManufacturerResponse } from '../../types'
+import type { StacksExpressionBuilder } from '@stacksjs/database'
+import { db } from '@stacksjs/database'
+
+export function fetchAll(): Promise<ManufacturerJsonResponse[]> {
+  return db.selectFrom('manufacturers').selectAll().execute() as Promise<ManufacturerJsonResponse[]>
+}
+
+/**
+ * Fetch a product manufacturer by ID
+ */
+export async function fetchById(id: number): Promise<ManufacturerJsonResponse | undefined> {
+  return await db
+    .selectFrom('manufacturers')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as ManufacturerJsonResponse | undefined
+}
+
+/**
+ * Fetch a product manufacturer by UUID
+ */
+export async function fetchByUuid(uuid: string): Promise<ManufacturerJsonResponse | undefined> {
+  return await db
+    .selectFrom('manufacturers')
+    .where('uuid', '=', uuid)
+    .selectAll()
+    .executeTakeFirst() as ManufacturerJsonResponse | undefined
+}
+
+/**
+ * Fetch featured manufacturers
+ */
+export async function fetchFeatured(limit: number = 10): Promise<ManufacturerJsonResponse[]> {
+  return await db
+    .selectFrom('manufacturers')
+    .where('featured', '=', true)
+    .selectAll()
+    .orderBy('manufacturer', 'asc')
+    .limit(limit)
+    .execute() as ManufacturerJsonResponse[]
+}
+
+/**
+ * Fetch manufacturers by country
+ */
+export async function fetchByCountry(country: string, options: FetchManufacturersOptions = {}): Promise<ManufacturerResponse> {
+  // Set default values
+  const page = (options as any).page || 1
+  const limit = (options as any).limit || 2
+
+  // Get total count for pagination
+  const countResult = await db
+    .selectFrom('manufacturers')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('total')) as any)
+    .where('country', '=', country)
+    .executeTakeFirst() as { total: number } | undefined
+
+  const total = Number(countResult?.total || 0)
+
+  // Apply pagination
+  const manufacturers = await db
+    .selectFrom('manufacturers')
+    .selectAll()
+    .where('country', '=', country)
+    .limit(limit)
+    .offset((page - 1) * limit)
+    .execute()
+
+  // Calculate pagination info
+  const totalPages = Math.ceil(total / limit)
+
+  return {
+    data: manufacturers as ManufacturerJsonResponse[],
+    paging: {
+      total_records: total,
+      page,
+      total_pages: totalPages,
+    },
+    next_cursor: page < totalPages ? page + 1 : null,
+  }
+}
+
+/**
+ * Fetch manufacturers with their product count
+ */
+export async function fetchWithProductCount(options: FetchManufacturersOptions = {}): Promise<ManufacturerJsonResponse[]> {
+  // Start building the query with joins and filters before groupBy
+  let query = db.selectFrom('manufacturers as m')
+    .leftJoin('products as p', 'p.manufacturer_id', '=', 'm.id') as any
+
+  // Apply filters before groupBy (WHERE must come before GROUP BY in SQL)
+  if (options.country)
+    query = query.where('m.country', '=', options.country)
+
+  if (options.featured !== undefined)
+    query = query.where('m.featured', '=', options.featured)
+
+  // Apply select and groupBy after where clauses
+  query = query
+    .select([
+      'm.id',
+      'm.uuid',
+      'm.manufacturer',
+      'm.description',
+      'm.country',
+      'm.featured',
+      'm.created_at',
+      'm.updated_at',
+      (eb: StacksExpressionBuilder) => eb.fn.count('p.id').as('product_count'),
+    ] as any)
+    .groupBy('m.id')
+
+  // Return all manufacturers
+  return query.execute() as Promise<ManufacturerJsonResponse[]>
+}

package/src/products/manufacturers/index.ts

@@ -0,0 +1,24 @@
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+export {
+  fetchAll,
+  fetchByCountry,
+  fetchById,
+  fetchByUuid,
+  fetchFeatured,
+  fetchWithProductCount,
+} from './fetch'
+
+export {
+  bulkStore,
+  store,
+} from './store'
+
+export {
+  update,
+  updateByUuid,
+  updateFeaturedStatus,
+} from './update'

package/src/products/manufacturers/store.ts

@@ -0,0 +1,82 @@
+type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>
+type NewManufacturer = NewModelData<typeof Manufacturer>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { HttpError } from '@stacksjs/error-handling'
+import { isUniqueViolation } from '@stacksjs/orm'
+
+/**
+ * Create a new product manufacturer
+ *
+ * @param data The manufacturer data to store
+ * @returns The newly created manufacturer record
+ */
+export async function store(data: NewManufacturer): Promise<ManufacturerJsonResponse> {
+  try {
+    const manufacturerData = {
+      ...data,
+      uuid: randomUUIDv7(),
+      featured: data.featured ?? false,
+    }
+
+    const result = await db
+      .insertInto('manufacturers')
+      .values(manufacturerData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create manufacturer')
+
+    return result as ManufacturerJsonResponse
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    // Cross-dialect duplicate detection (#1957).
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'A manufacturer with this name already exists')
+    if (error instanceof Error)
+      throw new Error(`Failed to create manufacturer: ${error.message}`)
+    throw error
+  }
+}
+
+/**
+ * Create multiple manufacturers at once
+ *
+ * @param data Array of manufacturer data to store
+ * @returns Number of manufacturers created
+ */
+export async function bulkStore(data: NewManufacturer[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  let createdCount = 0
+
+  try {
+    for (const manufacturer of data) {
+      const manufacturerData = {
+        ...manufacturer,
+        uuid: randomUUIDv7(),
+        featured: manufacturer.featured ?? false,
+      }
+
+      await db
+        .insertInto('manufacturers')
+        .values(manufacturerData)
+        .execute()
+
+      createdCount++
+    }
+
+    return createdCount
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create manufacturers in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}