@stacksjs/commerce 0.70.55 → 0.70.56

package/src/products/manufacturers/update.ts

@@ -1,113 +0,0 @@
-import { db } from '@stacksjs/database'
-import { HttpError } from '@stacksjs/error-handling'
-import { formatDate, isUniqueViolation } from '@stacksjs/orm'
-type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>
-type ManufacturerUpdate = UpdateModelData<typeof Manufacturer>
-
-/**
- * Update a manufacturer
- *
- * @param id The ID of the manufacturer to update
- * @param data The manufacturer data to update
- * @returns The updated manufacturer record
- */
-export async function update(id: number, data: ManufacturerUpdate): Promise<ManufacturerJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Manufacturer ID is required for update')
-
-    const result = await db
-      .updateTable('manufacturers')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error(`Manufacturer with ID ${id} not found`)
-
-    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 update manufacturer: ${error.message}`)
-    throw error
-  }
-}
-
-/**
- * Toggle the featured status of a manufacturer
- *
- * @param id The ID of the manufacturer
- * @param featured The new featured status (or toggle if not provided)
- * @returns The updated manufacturer with the new featured status
- */
-export async function updateFeaturedStatus(
-  id: number,
-  featured?: boolean,
-): Promise<ManufacturerJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('manufacturers')
-      .set({
-        featured,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update manufacturer featured status')
-
-    return result as ManufacturerJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update manufacturer featured status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a manufacturer by UUID
- *
- * @param uuid The UUID of the manufacturer to update
- * @param data The updated manufacturer data
- * @returns The updated manufacturer record
- */
-export async function updateByUuid(uuid: string, data: Omit<ManufacturerUpdate, 'id'>): Promise<ManufacturerJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('manufacturers')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('uuid', '=', uuid)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update manufacturer')
-
-    return result as ManufacturerJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update manufacturer: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/products/reviews/destroy.ts

@@ -1,56 +0,0 @@
-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('reviews')
-      .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('reviews')
-      .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/reviews/fetch.ts

@@ -1,63 +0,0 @@
-type ReviewJsonResponse = ModelRow<typeof Review>
-import { db } from '@stacksjs/database'
-
-/**
- * Fetch a product review by ID
- */
-export async function fetchById(id: number): Promise<ReviewJsonResponse | undefined> {
-  return await db
-    .selectFrom('reviews')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst()
-}
-
-/**
- * Fetch all product reviews
- */
-export async function fetchAll(): Promise<ReviewJsonResponse[]> {
-  return await db.selectFrom('reviews').selectAll().execute()
-}
-
-/**
- * Fetch reviews for a specific product
- */
-export async function fetchByProductId(productId: number): Promise<ReviewJsonResponse[]> {
-  return await db
-    .selectFrom('reviews')
-    .where('product_id', '=', productId)
-    .selectAll()
-    .execute()
-}
-
-/**
- * Fetch reviews by user ID
- */
-export async function fetchByUserId(userId: number): Promise<ReviewJsonResponse[]> {
-  return await db
-    .selectFrom('reviews')
-    .where('customer_id', '=', userId)
-    .selectAll()
-    .execute()
-}
-
-/**
- * Fetch approved reviews for a product
- */
-export async function fetchApprovedByProductId(productId: number): Promise<ReviewJsonResponse[]> {
-  return await db
-    .selectFrom('reviews')
-    .where('product_id', '=', productId)
-    .where('is_approved', '=', true)
-    .selectAll()
-    .execute()
-}
-
-export async function fetchMostHelpfulByProductId(productId: number): Promise<ReviewJsonResponse[]> {
-  return await db
-    .selectFrom('reviews')
-    .where('product_id', '=', productId)
-    .orderBy('helpful_votes', 'desc')
-    .selectAll()
-    .execute()
-}

package/src/products/reviews/index.ts

@@ -1,25 +0,0 @@
-export {
-  bulkDestroy,
-  destroy,
-} from './destroy'
-
-// Functions from fetch.ts
-export {
-  fetchAll,
-  fetchApprovedByProductId,
-  fetchById,
-  fetchByProductId,
-  fetchByUserId,
-  fetchMostHelpfulByProductId,
-} from './fetch'
-
-// Functions from store.ts
-export {
-  store,
-} from './store'
-
-// Functions from update.ts
-export {
-  update,
-  updateVotes,
-} from './update'

package/src/products/reviews/store.ts

@@ -1,46 +0,0 @@
-type ReviewJsonResponse = ModelRow<typeof Review>
-type NewReview = NewModelData<typeof Review>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-
-/**
- * Create a new product review
- *
- * @param data The review data to store
- * @returns The newly created review record
- */
-export async function store(data: NewReview): Promise<ReviewJsonResponse> {
-  try {
-    const reviewData = {
-      ...data,
-      uuid: randomUUIDv7(),
-      is_verified_purchase: data.is_verified_purchase ?? false,
-      is_approved: data.is_approved ?? false,
-      helpful_votes: data.helpful_votes ?? 0,
-      unhelpful_votes: data.unhelpful_votes ?? 0,
-      is_featured: data.is_featured ?? false,
-    }
-
-    const result = await db
-      .insertInto('reviews')
-      .values(reviewData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create review')
-
-    return result
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes('Duplicate entry')) {
-        throw new Error('A review with this code already exists')
-      }
-
-      throw new Error(`Failed to create review: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/products/reviews/update.ts

@@ -1,82 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type ReviewJsonResponse = ModelRow<typeof Review>
-type ReviewUpdate = UpdateModelData<typeof Review>
-
-/**
- * Update a review
- *
- * @param id The id of the review to update
- * @param data The review data to update
- * @returns The updated review record
- */
-export async function update(id: number, data: ReviewUpdate): Promise<ReviewJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Review ID is required for update')
-
-    const result = await db
-      .updateTable('reviews')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update review')
-
-    return result
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update review: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a review's vote counts
- *
- * @param id The ID of the review
- * @param voteType The type of vote ('helpful' or 'unhelpful')
- * @param increment Whether to increment (true) or decrement (false) the vote count
- * @returns The updated review with new vote counts
- */
-export async function updateVotes(
-  id: number,
-  voteType: 'helpful' | 'unhelpful',
-  increment: boolean = true,
-): Promise<ReviewJsonResponse> {
-  try {
-    const column = voteType === 'helpful' ? 'helpful_votes' : 'unhelpful_votes'
-    const expr = increment
-      ? `COALESCE("${column}", 0) + 1`
-      : `MAX(COALESCE("${column}", 0) - 1, 0)`
-
-    const result = await db
-      .unsafe(
-        `UPDATE "reviews" SET "${column}" = ${expr}, "updated_at" = ? WHERE "id" = ? RETURNING *`,
-        [formatDate(new Date()), id],
-      )
-      .execute()
-
-    const row = Array.isArray(result) ? result[0] : result
-
-    if (!row)
-      throw new Error('Failed to update review votes')
-
-    return row
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update review votes: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/products/units/destroy.ts

@@ -1,56 +0,0 @@
-import { db } from '@stacksjs/database'
-
-/**
- * Delete a product unit by ID
- *
- * @param id The ID of the product unit to delete
- * @returns True if the product unit was deleted, false otherwise
- */
-export async function destroy(id: number): Promise<boolean> {
-  try {
-    // Perform the delete operation
-    const result = await db
-      .deleteFrom('product_units')
-      .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 product unit: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Delete multiple product units by ID
- *
- * @param ids Array of product unit IDs to delete
- * @returns Number of product units deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  try {
-    // Perform the delete operation
-    const result = await db
-      .deleteFrom('product_units')
-      .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 units: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/products/units/fetch.ts

@@ -1,20 +0,0 @@
-type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>
-import { db } from '@stacksjs/database'
-
-/**
- * Fetch a product unit by ID
- */
-export async function fetchById(id: number): Promise<ProductUnitJsonResponse | undefined> {
-  return await db
-    .selectFrom('product_units')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as ProductUnitJsonResponse | undefined
-}
-
-/**
- * Fetch all product units
- */
-export async function fetchAll(): Promise<ProductUnitJsonResponse[]> {
-  return await db.selectFrom('product_units').selectAll().execute() as ProductUnitJsonResponse[]
-}

package/src/products/units/index.ts

@@ -1,13 +0,0 @@
-// Export all functions from the unit modules
-
-// Destroy functions
-export { bulkDestroy, destroy } from './destroy'
-
-// Fetch functions
-export { fetchAll, fetchById } from './fetch'
-
-// Store functions
-export { bulkStore, formatUnitOptions, getDefaultUnit, store } from './store'
-
-// Update functions
-export { bulkUpdate, update, updateDefaultStatus } from './update'

package/src/products/units/store.ts

@@ -1,162 +0,0 @@
-// Import dependencies
-type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>
-type NewProductUnit = NewModelData<typeof ProductUnit>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-
-/**
- * Create a new product unit
- *
- * @param data The product unit data to store
- * @returns The newly created product unit record
- */
-export async function store(data: NewProductUnit): Promise<ProductUnitJsonResponse> {
-  try {
-    const unitData = {
-      ...data,
-      uuid: randomUUIDv7(),
-    }
-
-    const result = await db
-      .insertInto('product_units')
-      .values(unitData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create product unit')
-
-    // If this unit is set as default, update all other units of the same type
-    if ((unitData as Record<string, unknown>).is_default) {
-      await db
-        .updateTable('product_units')
-        .set({ is_default: false })
-        .where('type', '=', unitData.type)
-        .where('id', '!=', result.id)
-        .execute()
-    }
-
-    return result as ProductUnitJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create product unit: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple product units at once
- *
- * @param data Array of product unit data to store
- * @returns Number of product units created
- */
-export async function bulkStore(data: NewProductUnit[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  let createdCount = 0
-
-  try {
-    for (const unit of data) {
-      const unitData = {
-        ...unit,
-        uuid: randomUUIDv7(),
-      }
-
-      const result = await db
-        .insertInto('product_units')
-        .values(unitData)
-        .returningAll()
-        .executeTakeFirst()
-
-      // If this unit is set as default, update all other units of the same type
-      if ((unitData as Record<string, unknown>).is_default && result) {
-        await db
-          .updateTable('product_units')
-          .set({ is_default: false })
-          .where('type', '=', unitData.type)
-          .where('id', '!=', result.id)
-          .execute()
-      }
-
-      createdCount++
-    }
-
-    return createdCount
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create product units in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Format product unit options for dropdown menus or selectors
- *
- * @param type Optional filter by unit type
- * @returns Array of formatted unit options with id, name, and abbreviation
- */
-export function formatUnitOptions(
-  type?: string,
-): Promise<{ id: string, name: string, abbreviation: string, is_default: boolean | undefined }[] | []> {
-  try {
-    let query = db
-      .selectFrom('product_units')
-      .select(['id', 'name', 'abbreviation', 'is_default'] as any) as any
-
-    // Filter by type if provided
-    if (type)
-      query = query.where('type', '=', type)
-
-    query = query.orderBy('name')
-
-    // Convert db results to ensure id is string and handle potentially undefined is_default
-    return query.execute().then((results: any) =>
-      results.map((result: any) => ({
-        id: String(result.id), // Convert id to string
-        name: result.name,
-        abbreviation: result.abbreviation,
-        is_default: result.is_default,
-      })),
-    )
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to format unit options: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Get the default unit for a specific type
- *
- * @param type The unit type to get the default for
- * @returns The default unit or undefined if none found
- */
-export async function getDefaultUnit(type: string): Promise<ProductUnitJsonResponse | undefined> {
-  try {
-    const defaultUnit = await db
-      .selectFrom('product_units')
-      .selectAll()
-      .where('type', '=', type)
-      .where('is_default', '=', true)
-      .executeTakeFirst()
-
-    return defaultUnit as ProductUnitJsonResponse | undefined
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to get default unit: ${error.message}`)
-    }
-
-    throw error
-  }
-}