@stacksjs/commerce 0.70.36 → 0.70.42

package/dist/src/orders/destroy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Delete an order by ID
+ *
+ * @param id The ID of the order to delete
+ * @returns True if the order was deleted, false otherwise
+ */
+export declare function destroy(id: number): Promise<boolean>;
+/**
+ * Soft delete an order by ID (updates status to CANCELED)
+ *
+ * @param id The ID of the order to soft delete
+ * @returns True if the order was soft deleted, false otherwise
+ */
+export declare function softDelete(id: number): Promise<boolean>;
+/**
+ * Delete multiple orders by ID
+ *
+ * @param ids Array of order IDs to delete
+ * @returns Number of orders deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;
+/**
+ * Soft delete multiple orders by ID (updates status to CANCELED)
+ *
+ * @param ids Array of order IDs to soft delete
+ * @returns Number of orders soft deleted
+ */
+export declare function bulkSoftDelete(ids: number[]): Promise<number>;

package/dist/src/orders/export.d.ts

@@ -0,0 +1,32 @@
+import type { SpreadsheetWrapper } from 'ts-spreadsheets';
+/**
+ * Export orders to a spreadsheet
+ * @param format The format of the spreadsheet (default is CSV)
+ * @returns Spreadsheet object ready for download or storage
+ */
+export declare function exportOrders(format?: 'csv' | 'excel'): Promise<SpreadsheetWrapper>;
+/**
+ * Export orders and automatically download
+ * @param format The format of the spreadsheet (default is CSV)
+ * @param filename Optional filename for the download
+ * @returns Download response
+ */
+export declare function downloadOrders(format?: 'csv' | 'excel', filename?: string): Promise<Response>;
+/**
+ * Store orders export to disk
+ * @param format The format of the spreadsheet (default is CSV)
+ * @param path Optional path to store the file
+ * @returns Path where the file is stored
+ */
+export declare function storeOrdersExport(format?: 'csv' | 'excel', path?: string): Promise<void>;
+/**
+ * Represents the structure of an exported order
+ */
+export declare interface ExportedOrder {
+  'Order ID': number
+  'Customer': string
+  'Date': string
+  'Total': number
+  'Status': string
+  'Items': string
+}

package/dist/src/orders/fetch.d.ts

@@ -0,0 +1,76 @@
+import type { OrderStats } from '../types';
+/**
+ * Fetch all orders from the database with their items
+ * @param limit Optional limit on number of orders to fetch
+ */
+export declare function fetchAll(limit?: number): Promise<OrderJsonResponse[]>;
+/**
+ * Fetch the most recent orders
+ * @param limit Number of recent orders to fetch (default: 10)
+ */
+export declare function fetchRecent(limit?: number): Promise<OrderJsonResponse[]>;
+/**
+ * Fetch an order by ID
+ */
+export declare function fetchById(id: number): Promise<OrderJsonResponse | undefined>;
+/**
+ * Get order statistics
+ */
+export declare function fetchStats(): Promise<OrderStats>;
+/**
+ * Compare orders between different time periods
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export declare function compareOrdersByPeriod(_daysRange?: number): Promise<{
+  current_period: number
+  previous_period: number
+  difference: number
+  percentage_change: number
+  days_range: number
+}>;
+/**
+ * Calculate order values and metrics for different time periods
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export declare function calculateOrderMetrics(_daysRange?: number): Promise<{
+  current_period: {
+    total_orders: number
+    total_revenue: number
+    average_order_value: number
+    orders_by_status: { status: string, count: number }[]
+    orders_by_type: { order_type: string, count: number }[]
+  }
+  previous_period: {
+    total_orders: number
+    total_revenue: number
+    average_order_value: number
+  }
+  comparison: {
+    orders: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    revenue: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    average_order_value: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+  }
+  days_range: number
+}>;
+/**
+ * Get daily order counts for a time period
+ * @param daysRange Number of days to look back
+ */
+export declare function fetchDailyOrderTrends(_daysRange?: number): Promise<{
+  date: string
+  order_count: number
+  revenue: number
+}[]>;
+declare type OrderJsonResponse = ModelRow<typeof Order>;

package/dist/src/orders/index.d.ts

@@ -0,0 +1,27 @@
+export {
+  bulkDestroy,
+  bulkSoftDelete,
+  destroy,
+  softDelete,
+} from './destroy';
+export {
+  downloadOrders,
+  exportOrders,
+  storeOrdersExport,
+} from './export';
+export {
+  calculateOrderMetrics,
+  compareOrdersByPeriod,
+  fetchAll,
+  fetchById,
+  fetchDailyOrderTrends,
+  fetchStats,
+} from './fetch';
+export {
+  store,
+} from './store';
+export {
+  update,
+  updateDeliveryInfo,
+  updateStatus,
+} from './update';

package/dist/src/orders/store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a new order
+ *
+ * @param data The order data to store
+ * @returns The newly created order record
+ */
+export declare function store(data: NewOrder): Promise<OrderJsonResponse | undefined>;
+declare type OrderJsonResponse = ModelRow<typeof Order>;
+declare type NewOrder = NewModelData<typeof Order>;

package/dist/src/orders/update.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Update an order by ID
+ *
+ * @param id The ID of the order to update
+ * @param data The updated order data
+ * @returns The updated order record
+ */
+export declare function update(id: number, data: Omit<OrderUpdate, 'id'>): Promise<OrderJsonResponse | undefined>;
+/**
+ * Update an order's status
+ *
+ * @param id The ID of the order
+ * @param status The new order status
+ * @returns The updated order with the new status
+ */
+export declare function updateStatus(id: number, status: 'PENDING' | 'PROCESSING' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED' | 'REFUNDED'): Promise<OrderJsonResponse | undefined>;
+/**
+ * Update delivery information for an order
+ *
+ * @param id The ID of the order
+ * @param delivery_address The updated delivery address
+ * @param estimated_delivery_time The updated estimated delivery time
+ * @returns The updated order
+ */
+export declare function updateDeliveryInfo(id: number, delivery_address?: string, estimated_delivery_time?: string): Promise<OrderJsonResponse | undefined>;
+declare type OrderJsonResponse = ModelRow<typeof Order>;
+declare type OrderUpdate = UpdateModelData<typeof Order>;

package/dist/src/payments/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Delete a payment by ID
+ *
+ * @param id The ID of the payment to delete
+ * @returns True if the payment was deleted, false otherwise
+ */
+export declare function destroy(id: number): Promise<boolean>;
+/**
+ * Delete multiple payments by ID
+ *
+ * @param ids Array of order IDs to delete
+ * @returns Number of payments deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;

package/dist/src/payments/fetch.d.ts

@@ -0,0 +1,55 @@
+export declare function fetchAll(): Promise<PaymentJsonResponse[]>;
+export declare function fetchById(id: number): Promise<PaymentJsonResponse | undefined>;
+/**
+ * Fetch payment statistics for a specific time period
+ *
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export declare function fetchPaymentStats(daysRange?: number): Promise<PaymentStats>;
+/**
+ * Fetch payment statistics by payment method
+ *
+ * @param daysRange Number of days to look back
+ */
+export declare function fetchPaymentStatsByMethod(_daysRange?: number): Promise<Record<string, {
+  count: number
+  revenue: number
+  percentage_of_total: number
+}>>;
+/**
+ * Fetch monthly payment trends for the last 12 months
+ */
+export declare function fetchMonthlyPaymentTrends(): Promise<Array<{
+  month: string
+  year: number
+  transactions: number
+  revenue: number
+  average: number
+}>>;
+/**
+ * Payment statistics response interface
+ */
+export declare interface PaymentStats {
+  total_transactions: number
+  total_revenue: number
+  average_transaction: number
+  successful_rate: number
+  comparison: {
+    transactions: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    revenue: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    average: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+  }
+}
+declare type PaymentJsonResponse = ModelRow<typeof Payment>;

package/dist/src/payments/index.d.ts

@@ -0,0 +1,13 @@
+export { bulkDestroy, destroy } from './destroy';
+// Fetch operations - from fetch.ts
+export {
+  fetchAll,
+  fetchById,
+  fetchMonthlyPaymentTrends,
+  fetchPaymentStats,
+  fetchPaymentStatsByMethod,
+} from './fetch';
+// Store operations - from store.ts
+export { store } from './store';
+// Update operations - from update.ts
+export { update } from './update';

package/dist/src/payments/store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a new payment
+ *
+ * @param data The payment data to store
+ * @returns The newly created payment record
+ */
+export declare function store(data: NewPayment): Promise<PaymentJsonResponse | undefined>;
+declare type PaymentJsonResponse = ModelRow<typeof Payment>;
+declare type NewPayment = NewModelData<typeof Payment>;

package/dist/src/payments/update.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Update a payment by ID.
+ *
+ * Supports the lifecycle a payment row goes through after creation —
+ * status transitions (pending → completed/failed/refunded), refund
+ * amount tracking, processor metadata (transaction ID, card brand),
+ * and operator notes. The original `amount` is intentionally fillable
+ * via this path because partial captures and adjustments can rewrite
+ * it before settlement; if your processor never adjusts captured
+ * amounts, just don't pass `amount` in `data`.
+ *
+ * @param id The ID of the payment to update
+ * @param data The updated payment data (omit `id`)
+ * @returns The updated payment record
+ */
+export declare function update(id: number, data: Omit<PaymentUpdate, 'id'>): Promise<PaymentJsonResponse | undefined>;
+declare type PaymentJsonResponse = ModelRow<typeof Payment>;
+declare type PaymentUpdate = UpdateModelData<typeof Payment>;

package/dist/src/products/categories/destroy.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Delete a category by ID
+ * @param id The ID of the category to delete
+ * @returns A boolean indicating whether the deletion was successful
+ */
+export declare function remove(id: number): Promise<boolean>;
+/**
+ * Bulk delete multiple categories
+ * @param ids Array of category IDs to delete
+ * @returns Number of categories successfully deleted
+ */
+export declare function bulkRemove(ids: number[]): Promise<number>;
+/**
+ * Delete child categories of a parent category
+ * @param parentId The ID of the parent category
+ * @returns Number of categories deleted
+ */
+export declare function removeChildCategories(parentId: string): Promise<number>;
+/**
+ * Deactivate a category (set is_active to false)
+ * @param id The ID of the category to deactivate
+ * @returns A boolean indicating whether the deactivation was successful
+ */
+export declare function deactivate(id: number): Promise<boolean>;
+/**
+ * Deactivate all child categories of a parent category
+ * @param parentId The ID of the parent category
+ * @returns Number of categories deactivated
+ */
+export declare function deactivateChildCategories(parentId: string): Promise<number>;

package/dist/src/products/categories/fetch.d.ts

@@ -0,0 +1,49 @@
+import type { CategoryStats } from '../../types';
+/**
+ * Fetch all categories from the database
+ */
+export declare function fetchAll(): Promise<CategoryJsonResponse[]>;
+/**
+ * Fetch a category by ID
+ */
+export declare function fetchById(id: number): Promise<CategoryJsonResponse | undefined>;
+/**
+ * Fetch a category by name
+ */
+export declare function fetchByName(name: string): Promise<CategoryJsonResponse | undefined>;
+/**
+ * Fetch active categories (is_active = true)
+ */
+export declare function fetchActive(): Promise<CategoryJsonResponse[]>;
+/**
+ * Fetch root categories (parent_category_id is null)
+ */
+export declare function fetchRootCategories(): Promise<CategoryJsonResponse[]>;
+/**
+ * Fetch child categories for a given parent category ID
+ */
+export declare function fetchChildCategories(parentId: string): Promise<CategoryJsonResponse[]>;
+/**
+ * Fetch categories sorted by display order
+ */
+export declare function fetchByDisplayOrder(ascending?: boolean): Promise<CategoryJsonResponse[]>;
+/**
+ * Get category statistics
+ */
+export declare function fetchStats(): Promise<CategoryStats>;
+/**
+ * Compare category growth between different time periods
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export declare function compareCategoryGrowth(_daysRange?: number): Promise<{
+  current_period: number
+  previous_period: number
+  difference: number
+  percentage_change: number
+  days_range: number
+}>;
+/**
+ * Build category tree structure
+ */
+export declare function fetchCategoryTree(): Promise<any[]>;
+declare type CategoryJsonResponse = ModelRow<typeof Category>;

package/dist/src/products/categories/index.d.ts

@@ -0,0 +1,33 @@
+// Export all functions from destroy.ts
+export {
+  bulkRemove,
+  deactivate,
+  deactivateChildCategories,
+  remove,
+  removeChildCategories,
+} from './destroy';
+// Export all functions from fetch.ts
+export {
+  compareCategoryGrowth,
+  fetchActive,
+  fetchAll,
+  fetchByDisplayOrder,
+  fetchById,
+  fetchByName,
+  fetchCategoryTree,
+  fetchChildCategories,
+  fetchRootCategories,
+  fetchStats,
+} from './fetch';
+// Export all functions from store.ts
+export {
+  findOrCreateByName,
+  store,
+} from './store';
+// Export all functions from update.ts
+export {
+  update,
+  updateActiveStatus,
+  updateDisplayOrder,
+  updateParent,
+} from './update';

package/dist/src/products/categories/store.d.ts

@@ -0,0 +1,21 @@
+import { slug } from '@stacksjs/strings';
+/**
+ * Create a new category
+ *
+ * @param data The category data to store
+ * @returns The newly created category record
+ */
+export declare function store(data: NewCategory): Promise<CategoryJsonResponse>;
+export declare function findOrCreateByName(data: Partial<CategorizableTable>): Promise<CategoryJsonResponse>;
+export declare interface CategorizableTable {
+  id: number
+  name: string
+  slug: string
+  description?: string
+  is_active: boolean
+  categorizable_type: string
+  created_at?: string
+  updated_at?: string
+}
+declare type CategoryJsonResponse = ModelRow<typeof Category>;
+declare type NewCategory = NewModelData<typeof Category>;

package/dist/src/products/categories/update.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Update a category by ID
+ *
+ * @param id The ID of the category to update
+ * @param request The updated category data
+ * @returns The updated category record
+ */
+export declare function update(id: number, request: RequestInstance<typeof Category>): Promise<CategoryRow | undefined>;
+/**
+ * Update category display order
+ *
+ * @param id The ID of the category
+ * @param newOrder The new display order value
+ * @returns The updated category
+ */
+export declare function updateDisplayOrder(id: number, newOrder: number): Promise<CategoryRow | undefined>;
+/**
+ * Update category active status
+ *
+ * @param id The ID of the category
+ * @param isActive Whether the category should be active
+ * @returns The updated category
+ */
+export declare function updateActiveStatus(id: number, isActive: boolean): Promise<CategoryRow | undefined>;
+/**
+ * Move category to a different parent
+ *
+ * @param id The ID of the category to move
+ * @param newParentId The ID of the new parent category, or null to make it a root category
+ * @returns The updated category
+ */
+export declare function updateParent(id: number, newParentId: string | null): Promise<CategoryRow | undefined>;
+declare type CategoryRow = ModelRow<typeof Category>;

package/dist/src/products/index.d.ts

@@ -0,0 +1,24 @@
+import * as categories from './categories/index';
+import * as items from './items/index';
+import * as manufacturers from './manufacturers/index';
+import * as reviews from './reviews/index';
+import * as units from './units/index';
+import * as variants from './variants/index';
+declare const products: ProductsNamespace;
+declare interface ProductsNamespace {
+  categories: typeof categories
+  items: typeof items
+  manufacturers: typeof manufacturers
+  reviews: typeof reviews
+  units: typeof units
+  variants: typeof variants
+}
+export {
+  categories,
+  items,
+  manufacturers,
+  reviews,
+  units,
+  variants,
+};
+export default products;

package/dist/src/products/items/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function destroy(id: number): Promise<boolean>;
+/**
+ * Delete multiple product items by ID
+ *
+ * @param ids Array of product item IDs to delete
+ * @returns Number of product items deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;

package/dist/src/products/items/fetch.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Fetch a product item by ID
+ */
+export declare function fetchById(id: number): Promise<ProductJsonResponse | undefined>;
+/**
+ * Fetch all product items with their manufacturers and categories
+ */
+export declare function fetchAll(): Promise<ProductJsonResponse[]>;
+/**
+ * Get products by manufacturer
+ *
+ * @param manufacturerId Manufacturer identifier
+ * @returns List of products for the specified manufacturer
+ */
+export declare function getProductsByManufacturer(manufacturerId: number): Promise<ProductJsonResponse[]>;
+/**
+ * Get products by category
+ *
+ * @param categoryId Category identifier
+ * @returns List of products for the specified category
+ */
+export declare function getProductsByCategory(categoryId: number): Promise<ProductJsonResponse[]>;
+/**
+ * Get product by UUID
+ *
+ * @param uuid Product UUID
+ * @returns Matching product or undefined
+ */
+export declare function getProductByUuid(uuid: string): Promise<ProductJsonResponse | undefined>;
+/**
+ * Format product options for dropdown menus or selectors
+ *
+ * @returns Array of formatted product options with id, name, uuid, and price
+ */
+export declare function formatProductOptions(): Promise<{ id: number, name: string, uuid: string, price: number }[]>;
+/**
+ * Get products by price range
+ *
+ * @param minPrice Minimum price
+ * @param maxPrice Maximum price
+ * @returns List of products within the specified price range
+ */
+export declare function getProductsByPriceRange(minPrice: number, maxPrice: number): Promise<ProductJsonResponse[]>;
+export declare function fetchTopProducts(limit?: number): Promise<TopProductRow[]>;
+/**
+ * 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 declare interface TopProductRow {
+  id: number
+  name: string
+  units_sold: number
+  revenue: number
+  inventory_count: number
+}
+declare type ProductJsonResponse = ModelRow<typeof Product>;

package/dist/src/products/items/index.d.ts

@@ -0,0 +1,23 @@
+// Functions from fetch.ts
+export type { TopProductRow } from './fetch';
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy';
+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/dist/src/products/items/store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a new product item
+ *
+ * @param data The product item data to store
+ * @returns The newly created product item record
+ */
+export declare function store(data: NewProduct): Promise<ProductJsonResponse>;
+/**
+ * Create multiple product items at once
+ *
+ * @param data Array of product item data to store
+ * @returns Number of product items created
+ */
+export declare function bulkStore(data: NewProduct[]): Promise<number>;
+declare type ProductJsonResponse = ModelRow<typeof Product>;
+declare type NewProduct = NewModelData<typeof Product>;