@stacksjs/commerce 0.70.55 → 0.70.56

package/src/products/units/update.ts

@@ -1,159 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>
-type ProductUnitUpdate = UpdateModelData<typeof ProductUnit>
-
-/**
- * Update a product unit
- *
- * @param id The ID of the product unit
- * @param data The product unit data to update
- * @returns The updated product unit record
- */
-export async function update(id: number, data: ProductUnitUpdate): Promise<ProductUnitJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Product unit ID is required for update')
-
-    const result = await db
-      .updateTable('product_units')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update product unit')
-
-    // If this unit is set as default, update all other units of the same type
-    const d = data as Record<string, unknown>
-    if (d.is_default === true && data.type) {
-      await db
-        .updateTable('product_units')
-        .set({ is_default: false })
-        .where('type', '=', data.type)
-        .where('id', '!=', id)
-        .execute()
-    }
-
-    return result as ProductUnitJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update product unit: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update multiple product units at once
- *
- * @param data Array of product unit updates
- * @returns Number of product units updated
- */
-export async function bulkUpdate(data: ProductUnitUpdate[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  let updatedCount = 0
-
-  try {
-    for (const unit of data) {
-      const unitRecord = unit as Record<string, unknown>
-      if (!unitRecord.id)
-        continue
-
-      // Support both flat format and { id, data: { ... } } format
-      const updateFields = unitRecord.data && typeof unitRecord.data === 'object'
-        ? unitRecord.data as Record<string, unknown>
-        : { ...unitRecord }
-      delete (updateFields as Record<string, unknown>).id
-
-      const result = await db
-        .updateTable('product_units')
-        .set({
-          ...updateFields,
-          updated_at: formatDate(new Date()),
-        })
-        .where('id', '=', unitRecord.id)
-        .executeTakeFirst()
-
-      // If this unit is set as default, update all other units of the same type
-      const fields = updateFields as Record<string, unknown>
-      if (fields.is_default === true && fields.type) {
-        await db
-          .updateTable('product_units')
-          .set({ is_default: false })
-          .where('type', '=', fields.type as string)
-          .where('id', '!=', unitRecord.id)
-          .execute()
-      }
-
-      if (Number(result.numUpdatedRows) > 0)
-        updatedCount++
-    }
-
-    return updatedCount
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update product units in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update the default status of a product unit
- *
- * @param id The ID of the product unit
- * @param isDefault The new default status value
- * @returns True if the status was updated successfully
- */
-export async function updateDefaultStatus(id: number, isDefault: boolean): Promise<boolean> {
-  try {
-    // First get the unit type to update other units if needed
-    const unit = await db
-      .selectFrom('product_units')
-      .select('type' as any)
-      .where('id', '=', id)
-      .executeTakeFirst() as { type: string } | undefined
-
-    if (!unit)
-      return false
-
-    const result = await db
-      .updateTable('product_units')
-      .set({
-        is_default: isDefault,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    // If setting this unit as default, update all other units of the same type
-    if (isDefault && unit.type) {
-      await db
-        .updateTable('product_units')
-        .set({ is_default: false })
-        .where('type', '=', unit.type)
-        .where('id', '!=', id)
-        .execute()
-    }
-
-    return Number(result.numUpdatedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update product unit default status: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/products/variants/destroy.ts

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

package/src/products/variants/fetch.ts

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

package/src/products/variants/index.ts

@@ -1,21 +0,0 @@
-export {
-  bulkDestroy,
-  destroy,
-} from './destroy'
-
-export {
-  fetchAll,
-  fetchById,
-} from './fetch'
-
-export {
-  bulkStore,
-  formatVariantOptions,
-  generateVariantCombinations,
-  store,
-} from './store'
-
-export {
-  bulkUpdate,
-  update,
-} from './update'

package/src/products/variants/store.ts

@@ -1,136 +0,0 @@
-type ProductVariantJsonResponse = ModelRow<typeof ProductVariant>
-type NewProductVariant = NewModelData<typeof ProductVariant>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-
-/**
- * Create a new product variant
- *
- * @param data The product variant data to store
- * @returns The newly created product variant record
- */
-export async function store(data: NewProductVariant): Promise<ProductVariantJsonResponse> {
-  try {
-    const variantData = {
-      ...data,
-      uuid: randomUUIDv7(),
-    }
-
-    const result = await db
-      .insertInto('product_variants')
-      .values(variantData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create product variant')
-
-    return result as ProductVariantJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create product variant: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple product variants at once
- *
- * @param data Array of product variant data to store
- * @returns Number of product variants created
- */
-export async function bulkStore(data: NewProductVariant[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  let createdCount = 0
-
-  try {
-    for (const variant of data) {
-      const variantData = {
-        ...variant,
-        uuid: randomUUIDv7(),
-      }
-
-      await db
-        .insertInto('product_variants')
-        .values(variantData)
-        .execute()
-
-      createdCount++
-    }
-
-    return createdCount
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create product variants in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Generate product variant options from raw input
- *
- * @param rawOptions String array of options
- * @returns Formatted JSON string of options
- */
-export function formatVariantOptions(rawOptions: string[]): string {
-  if (!rawOptions || !rawOptions.length)
-    return JSON.stringify([])
-
-  // Clean and normalize the options
-  const cleanedOptions = rawOptions.map((option: any) => option.trim()).filter(Boolean)
-
-  return JSON.stringify(cleanedOptions)
-}
-
-/**
- * Create a set of common variant combinations from different option types
- *
- * @param optionSets Object containing option types and their values
- * @returns Array of variant combinations
- *
- * @example
- * // Generate combinations for a t-shirt product
- * const options = {
- *   size: ['S', 'M', 'L'],
- *   color: ['Red', 'Blue']
- * }
- * // Returns: [
- * //   { size: 'S', color: 'Red' },
- * //   { size: 'S', color: 'Blue' },
- * //   { size: 'M', color: 'Red' },
- * //   ...
- * // ]
- */
-export function generateVariantCombinations(optionSets: Record<string, string[]>): Record<string, string>[] {
-  const keys = Object.keys(optionSets)
-
-  if (!keys.length)
-    return []
-
-  // Helper function to create combinations recursively
-  function createCombinations(currentIndex: number, currentCombination: Record<string, string>): Record<string, string>[] {
-    if (currentIndex === keys.length)
-      return [currentCombination]
-
-    const currentKey = keys[currentIndex]
-    const currentOptions = optionSets[currentKey]
-    const combinations: Record<string, string>[] = []
-
-    for (const option of currentOptions) {
-      const newCombination = { ...currentCombination, [currentKey]: option }
-      combinations.push(...createCombinations(currentIndex + 1, newCombination))
-    }
-
-    return combinations
-  }
-
-  return createCombinations(0, {})
-}

package/src/products/variants/update.ts

@@ -1,104 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type ProductVariantJsonResponse = ModelRow<typeof ProductVariant>
-type ProductVariantUpdate = UpdateModelData<typeof ProductVariant>
-
-/**
- * Update a product variant
- *
- * @param id The ID of the product variant to update
- * @param data The product variant data to update
- * @returns The updated product variant record
- */
-export async function update(id: number, data: Omit<ProductVariantUpdate, 'id'>): Promise<ProductVariantJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('product_variants')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update product variant')
-
-    return result as ProductVariantJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to update product variant: ${error.message}`)
-
-    throw error
-  }
-}
-
-/**
- * Update multiple product variants at once
- *
- * @param data Array of objects containing variant ID and update data
- * @returns Number of product variants updated
- */
-export async function bulkUpdate(data: ProductVariantUpdate[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  let updatedCount = 0
-
-  try {
-    for (const variant of data) {
-      if (!(variant as Record<string, unknown>).id)
-        continue
-
-      const result = await db
-        .updateTable('product_variants')
-        .set({
-          ...variant,
-          updated_at: formatDate(new Date()),
-        })
-        .where('id', '=', (variant 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 variants in bulk: ${error.message}`)
-
-    throw error
-  }
-}
-
-/**
- * Update the status of a product variant
- *
- * @param id The ID of the product variant
- * @param status The new status value
- * @returns True if the status was updated successfully
- */
-export async function updateStatus(id: number, status: string): Promise<boolean> {
-  try {
-    const result = await db
-      .updateTable('product_variants')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    return Number(result.numUpdatedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to update product variant status: ${error.message}`)
-
-    throw error
-  }
-}

package/src/receipts/destroy.ts

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