@stacksjs/commerce 0.70.88 → 0.70.90

package/dist/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/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/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/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>;

package/dist/products/items/update.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 declare function update(id: number, data: Omit<ProductUpdate, 'id'>): Promise<ProductJsonResponse>;
+/**
+ * Update multiple product items at once
+ *
+ * @param data Array of product item updates
+ * @returns Number of product items updated
+ */
+export declare function bulkUpdate(data: ProductUpdate[]): Promise<number>;
+/**
+ * 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 declare function updateAvailability(id: number, isAvailable: boolean): Promise<ProductJsonResponse | undefined>;
+/**
+ * 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 declare function adjustInventory(id: number, delta: number): Promise<ProductJsonResponse | null>;
+/**
+ * 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 declare function adjustInventoryMany(updates: ReadonlyArray<{ id: number, delta: number }>): Promise<InventoryBatchResult>;
+/**
+ * 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 declare function updateInventory(id: number, inventoryCount?: number): Promise<ProductJsonResponse | undefined>;
+declare type ProductJsonResponse = ModelRow<typeof Product>;
+declare type ProductUpdate = UpdateModelData<typeof Product>;
+/**
+ * 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' }

package/dist/products/manufacturers/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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>;
+/**
+ * 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>;

package/dist/products/manufacturers/fetch.d.ts

@@ -0,0 +1,23 @@
+import type { FetchManufacturersOptions, ManufacturerResponse } from '../../types';
+export declare function fetchAll(): Promise<ManufacturerJsonResponse[]>;
+/**
+ * Fetch a product manufacturer by ID
+ */
+export declare function fetchById(id: number): Promise<ManufacturerJsonResponse | undefined>;
+/**
+ * Fetch a product manufacturer by UUID
+ */
+export declare function fetchByUuid(uuid: string): Promise<ManufacturerJsonResponse | undefined>;
+/**
+ * Fetch featured manufacturers
+ */
+export declare function fetchFeatured(limit?: number): Promise<ManufacturerJsonResponse[]>;
+/**
+ * Fetch manufacturers by country
+ */
+export declare function fetchByCountry(country: string, options?: FetchManufacturersOptions): Promise<ManufacturerResponse>;
+/**
+ * Fetch manufacturers with their product count
+ */
+export declare function fetchWithProductCount(options?: FetchManufacturersOptions): Promise<ManufacturerJsonResponse[]>;
+declare type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>;

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

@@ -0,0 +1,21 @@
+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/dist/products/manufacturers/store.d.ts

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

package/dist/products/manufacturers/update.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 declare function update(id: number, data: ManufacturerUpdate): Promise<ManufacturerJsonResponse>;
+/**
+ * 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 declare function updateFeaturedStatus(id: number, featured?: boolean): Promise<ManufacturerJsonResponse>;
+/**
+ * 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 declare function updateByUuid(uuid: string, data: Omit<ManufacturerUpdate, 'id'>): Promise<ManufacturerJsonResponse>;
+declare type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>;
+declare type ManufacturerUpdate = UpdateModelData<typeof Manufacturer>;

package/dist/products/reviews/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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>;
+/**
+ * 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>;

package/dist/products/reviews/fetch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fetch a product review by ID
+ */
+export declare function fetchById(id: number): Promise<ReviewJsonResponse | undefined>;
+/**
+ * Fetch all product reviews
+ */
+export declare function fetchAll(): Promise<ReviewJsonResponse[]>;
+/**
+ * Fetch reviews for a specific product
+ */
+export declare function fetchByProductId(productId: number): Promise<ReviewJsonResponse[]>;
+/**
+ * Fetch reviews by user ID
+ */
+export declare function fetchByUserId(userId: number): Promise<ReviewJsonResponse[]>;
+/**
+ * Fetch approved reviews for a product
+ */
+export declare function fetchApprovedByProductId(productId: number): Promise<ReviewJsonResponse[]>;
+export declare function fetchMostHelpfulByProductId(productId: number): Promise<ReviewJsonResponse[]>;
+declare type ReviewJsonResponse = ModelRow<typeof Review>;

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

@@ -0,0 +1,22 @@
+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/dist/products/reviews/store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a new product review
+ *
+ * @param data The review data to store
+ * @returns The newly created review record
+ */
+export declare function store(data: NewReviewInput): Promise<ReviewJsonResponse>;
+declare type ReviewJsonResponse = ModelRow<typeof Review>;
+declare type NewReview = NewModelData<typeof Review>;
+declare type NewReviewInput = NewReview & Partial<{
+  is_verified_purchase: boolean
+  is_approved: boolean
+  helpful_votes: number
+  unhelpful_votes: number
+  is_featured: boolean
+}>;

package/dist/products/reviews/update.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare function update(id: number, data: ReviewUpdate): Promise<ReviewJsonResponse>;
+/**
+ * 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 declare function updateVotes(id: number, voteType: 'helpful' | 'unhelpful', increment?: boolean): Promise<ReviewJsonResponse>;
+declare type ReviewJsonResponse = ModelRow<typeof Review>;
+declare type ReviewUpdate = UpdateModelData<typeof Review>;

package/dist/products/units/destroy.d.ts

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

package/dist/products/units/fetch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fetch a product unit by ID
+ */
+export declare function fetchById(id: number): Promise<ProductUnitJsonResponse | undefined>;
+/**
+ * Fetch all product units
+ */
+export declare function fetchAll(): Promise<ProductUnitJsonResponse[]>;
+declare type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>;

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

@@ -0,0 +1,9 @@
+// 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/dist/products/units/store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Create a new product unit
+ *
+ * @param data The product unit data to store
+ * @returns The newly created product unit record
+ */
+export declare function store(data: NewProductUnit): Promise<ProductUnitJsonResponse>;
+/**
+ * Create multiple product units at once
+ *
+ * @param data Array of product unit data to store
+ * @returns Number of product units created
+ */
+export declare function bulkStore(data: NewProductUnit[]): Promise<number>;
+/**
+ * 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 declare function formatUnitOptions(type?: string): Promise<{ id: string, name: string, abbreviation: string, is_default: boolean | undefined }[] | []>;
+/**
+ * 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 declare function getDefaultUnit(type: string): Promise<ProductUnitJsonResponse | undefined>;
+// Import dependencies
+declare type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>;
+declare type NewProductUnit = NewModelData<typeof ProductUnit>;

package/dist/products/units/update.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 declare function update(id: number, data: ProductUnitUpdate): Promise<ProductUnitJsonResponse>;
+/**
+ * Update multiple product units at once
+ *
+ * @param data Array of product unit updates
+ * @returns Number of product units updated
+ */
+export declare function bulkUpdate(data: ProductUnitUpdate[]): Promise<number>;
+/**
+ * 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 declare function updateDefaultStatus(id: number, isDefault: boolean): Promise<boolean>;
+declare type ProductUnitJsonResponse = ModelRow<typeof ProductUnit>;
+declare type ProductUnitUpdate = UpdateModelData<typeof ProductUnit>;

package/dist/products/variants/destroy.d.ts

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

package/dist/products/variants/fetch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fetch a product variant by ID
+ */
+export declare function fetchById(id: number): Promise<ProductVariantJsonResponse | undefined>;
+/**
+ * Fetch all product variants
+ */
+export declare function fetchAll(): Promise<ProductVariantJsonResponse[]>;
+declare type ProductVariantJsonResponse = ModelRow<typeof ProductVariant>;

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

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

package/dist/products/variants/store.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Create a new product variant
+ *
+ * @param data The product variant data to store
+ * @returns The newly created product variant record
+ */
+export declare function store(data: NewProductVariant): Promise<ProductVariantJsonResponse>;
+/**
+ * Create multiple product variants at once
+ *
+ * @param data Array of product variant data to store
+ * @returns Number of product variants created
+ */
+export declare function bulkStore(data: NewProductVariant[]): Promise<number>;
+/**
+ * Generate product variant options from raw input
+ *
+ * @param rawOptions String array of options
+ * @returns Formatted JSON string of options
+ */
+export declare function formatVariantOptions(rawOptions: string[]): string;
+/**
+ * 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 declare function generateVariantCombinations(optionSets: Record<string, string[]>): Record<string, string>[];
+declare type ProductVariantJsonResponse = ModelRow<typeof ProductVariant>;
+declare type NewProductVariant = NewModelData<typeof ProductVariant>;

package/dist/products/variants/update.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 declare function update(id: number, data: Omit<ProductVariantUpdate, 'id'>): Promise<ProductVariantJsonResponse>;
+/**
+ * Update multiple product variants at once
+ *
+ * @param data Array of objects containing variant ID and update data
+ * @returns Number of product variants updated
+ */
+export declare function bulkUpdate(data: ProductVariantUpdate[]): Promise<number>;
+/**
+ * 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 declare function updateStatus(id: number, status: string): Promise<boolean>;
+declare type ProductVariantJsonResponse = ModelRow<typeof ProductVariant>;
+declare type ProductVariantUpdate = UpdateModelData<typeof ProductVariant>;

package/dist/receipts/destroy.d.ts

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