@stacksjs/commerce 0.70.54 → 0.70.55

package/src/products/units/update.ts

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,54 @@
+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
+  }
+}