@kizlo/woocommerce 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { CurrencyFormat, IdentifierInput, KizloError, ListMetadata, Seo, createIntegration, createMiddleware, createProcedure, defineErrorMap, deserializeCurrencyFormat, deserializeListMetadata } from "kizlo";
-import { BooleanLike, Media, Metadata, NumberLike, arrayable, normalizeArrayableValue, random, seconds, timestampSec, toPublicMetadata, tryCatch } from "@kizlo/shared";
+import { CurrencyFormat, IdentifierInput, KizloError, ListMetadata, Seo, createIntegration, createMiddleware, createProcedure, customFieldsSchema, defineErrorMap, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, schemaType } from "kizlo";
+import { BooleanLike, MediaImage, Metadata, NumberLike, arrayable, normalizeArrayableValue, random, seconds, timestampFromIso, timestampFromWpGmt, timestampSec, toPublicMetadata, tryCatch } from "@kizlo/shared";
 import { SignJWT, jwtVerify } from "jose";
 import z$1, { z } from "zod/v4";
 import z$2 from "zod";
@@ -190,225 +190,6 @@ const REMOVE_COUPON_ERROR_MAP = defineErrorMap({
 	}
 });
 
-//#endregion
-//#region src/product/schema.ts
-const SWATCH_TYPES = [
-	"text",
-	"color",
-	"image"
-];
-const SwatchType = z.enum(SWATCH_TYPES);
-const PRODUCT_TYPES = [
-	"simple",
-	"grouped",
-	"external",
-	"variable",
-	"variation"
-];
-const ProductType = z.enum(PRODUCT_TYPES);
-const ProductTagRef = z.object({
-	id: z.number(),
-	name: z.string(),
-	slug: z.string()
-});
-const ProductBrandRef = z.object({
-	id: z.number(),
-	name: z.string(),
-	slug: z.string()
-});
-const ProductAttributeTermRef = z.object({
-	id: z.number(),
-	name: z.string(),
-	slug: z.string()
-});
-const ProductAttributeRef = z.object({
-	id: z.number(),
-	name: z.string(),
-	taxonomy: z.string().nullable(),
-	hasVariations: z.boolean(),
-	terms: z.array(ProductAttributeTermRef)
-});
-const ProductCategoryRef = z.object({
-	id: z.number(),
-	name: z.string(),
-	slug: z.string()
-});
-const ProductVariationAttributeRef = z.object({
-	name: z.string(),
-	value: z.string()
-});
-const ProductVariationRef = z.object({
-	id: z.number(),
-	attributes: z.array(ProductVariationAttributeRef)
-});
-const ProductPrices = z.object({
-	price: z.number(),
-	salePrice: z.number().nullable(),
-	regularPrice: z.number()
-});
-const Product = z.object({
-	id: z.number(),
-	parentId: z.number(),
-	type: ProductType,
-	name: z.string(),
-	slug: z.string(),
-	sku: z.string().nullable(),
-	shortDescription: z.string(),
-	description: z.string(),
-	onSaleFrom: z.number().nullable(),
-	onSaleTo: z.number().nullable(),
-	isOnSale: z.boolean(),
-	prices: ProductPrices,
-	averageRating: z.string(),
-	reviewCount: z.number(),
-	images: z.array(Media),
-	categories: z.array(ProductCategoryRef),
-	tags: z.array(ProductTagRef),
-	brands: z.array(ProductBrandRef),
-	attributes: z.array(ProductAttributeRef),
-	variations: z.array(ProductVariationRef),
-	groupedProducts: z.array(z.number()),
-	isSoldIndividually: z.boolean(),
-	hasOptions: z.boolean(),
-	isPurchasable: z.boolean(),
-	isInStock: z.boolean(),
-	isOnBackorder: z.boolean(),
-	stock: z.number().nullable(),
-	lowStockRemaining: z.number().nullable(),
-	seo: Seo.nullable(),
-	currencyFormat: CurrencyFormat,
-	meta: Metadata
-});
-const ProductList = z.object({
-	items: z.array(Product),
-	meta: ListMetadata
-});
-const RetrieveProductInput = z.object({
-	identifier: IdentifierInput,
-	previewToken: z.string().optional()
-});
-const PRODUCTS_ORDER_BYS = [
-	"date",
-	"id",
-	"include",
-	"title",
-	"slug",
-	"price",
-	"popularity",
-	"rating",
-	"menu_order",
-	"comment_count"
-];
-const ProductOrderBy = z.enum(PRODUCTS_ORDER_BYS);
-const PRODUCT_TAXONOMY_OPERATORS = [
-	"in",
-	"not_in",
-	"and"
-];
-const ProductTaxonomyOperator = z.enum(PRODUCT_TAXONOMY_OPERATORS);
-const PRODUCT_ATTRIBUTE_RELATIONS = ["in", "and"];
-const ProductAttributeRelation = z.enum(PRODUCT_ATTRIBUTE_RELATIONS);
-const PRODUCT_STOCK_STATUSES = [
-	"instock",
-	"outofstock",
-	"onbackorder"
-];
-const ProductStockStatus = z.enum(PRODUCT_STOCK_STATUSES);
-const PRODUCT_CATALOG_VISIBILITIES = [
-	"any",
-	"visible",
-	"catalog",
-	"search",
-	"hidden"
-];
-const ProductCatalogVisibility = z.enum(PRODUCT_CATALOG_VISIBILITIES);
-const PRODUCT_RATINGS = [
-	"1",
-	"2",
-	"3",
-	"4",
-	"5"
-];
-const ProductRating = z.enum(PRODUCT_RATINGS);
-const ProductAttributeFilter = z.object({
-	attribute: z.string().optional(),
-	slug: arrayable(z.string()).optional(),
-	termId: arrayable(NumberLike).optional(),
-	operator: ProductTaxonomyOperator.optional()
-});
-const ListProductInput = z.object({
-	page: NumberLike.optional(),
-	perPage: NumberLike.optional(),
-	search: z.string().optional(),
-	slug: z.string().optional(),
-	after: z.string().optional(),
-	before: z.string().optional(),
-	exclude: arrayable(NumberLike).optional(),
-	include: arrayable(NumberLike).optional(),
-	offset: NumberLike.optional(),
-	order: z.enum(["asc", "desc"]).optional(),
-	orderby: ProductOrderBy.optional(),
-	parent: arrayable(NumberLike).optional(),
-	parentExclude: arrayable(NumberLike).optional(),
-	type: ProductType.optional(),
-	sku: z.string().optional(),
-	featured: BooleanLike.optional(),
-	category: z.string().optional(),
-	categoryOperator: ProductTaxonomyOperator.optional(),
-	brand: z.string().optional(),
-	brandOperator: ProductTaxonomyOperator.optional(),
-	tag: z.string().optional(),
-	tagOperator: ProductTaxonomyOperator.optional(),
-	onSale: BooleanLike.optional(),
-	minPrice: z.string().optional(),
-	maxPrice: z.string().optional(),
-	stockStatus: arrayable(ProductStockStatus).optional(),
-	attributes: z.array(ProductAttributeFilter).optional(),
-	attributeRelation: ProductAttributeRelation.optional(),
-	catalogVisibility: ProductCatalogVisibility.optional(),
-	rating: arrayable(ProductRating).optional(),
-	related: NumberLike.optional()
-});
-const ProductFiltersPriceRange = z.object({
-	minPrice: z.number(),
-	maxPrice: z.number()
-});
-const ProductFiltersStockStatus = z.object({
-	count: z.number(),
-	status: ProductStockStatus
-});
-const ProductFiltersTerm = z.object({
-	id: z.number(),
-	parentId: z.number().nullable(),
-	name: z.string(),
-	slug: z.string(),
-	taxonomy: z.string(),
-	description: z.string(),
-	count: z.number()
-});
-const ProductFiltersTaxonomyTerm = ProductFiltersTerm.extend({ image: Media.nullable() });
-const ProductFiltersAttributeTerm = ProductFiltersTerm.extend({
-	type: SwatchType,
-	swatch: z.string().nullable()
-});
-const ProductFilters = z.object({
-	priceRange: ProductFiltersPriceRange,
-	stockStatuses: z.array(ProductFiltersStockStatus),
-	attributeTerms: z.array(ProductFiltersAttributeTerm),
-	taxonomyTerms: z.array(ProductFiltersTaxonomyTerm),
-	currencyFormat: CurrencyFormat
-});
-const CalculateAttributeFilter = z.object({
-	taxonomy: z.string(),
-	queryType: z.enum(["or", "and"]).optional()
-});
-const RetrieveProductFiltersInput = ListProductInput.extend({
-	ratingFilters: BooleanLike.optional(),
-	stockStatusFilters: BooleanLike.optional(),
-	taxonomyFilters: z.array(z.string()).optional(),
-	attributeFilters: z.array(CalculateAttributeFilter).optional()
-});
-
 //#endregion
 //#region src/schema.ts
 const Totals = z$1.object({
@@ -490,6 +271,11 @@ const CartItemVariation = z$1.object({
 	attribute: z$1.string(),
 	value: z$1.string()
 });
+const CartItemPrices = z$1.object({
+	price: z$1.number(),
+	salePrice: z$1.number().nullable(),
+	regularPrice: z$1.number()
+});
 const CartItem = z$1.object({
 	key: z$1.string(),
 	type: z$1.string(),
@@ -503,9 +289,9 @@ const CartItem = z$1.object({
 	slug: z$1.string(),
 	lowStockCount: z$1.number().nullable(),
 	isSoldIndividually: z$1.boolean(),
-	images: z$1.array(Media),
+	images: z$1.array(MediaImage),
 	variations: z$1.array(CartItemVariation),
-	prices: ProductPrices,
+	prices: CartItemPrices,
 	quantity: z$1.number(),
 	totals: ItemTotals
 });
@@ -596,6 +382,7 @@ function deserializeCart(data) {
 			quantity: item.quantity,
 			isSoldIndividually: item.sold_individually,
 			images: item.images.map((item$1) => ({
+				type: "image",
 				id: item$1.id,
 				name: item$1.name,
 				alt: item$1.alt,
@@ -1450,7 +1237,7 @@ function deserializeCustomer(data) {
 		lastName: data.last_name,
 		isPayingCustomer: data.is_paying_customer,
 		meta: toPublicMetadata(data.meta_data),
-		registeredAt: new Date(data.date_created).getTime(),
+		registeredAt: timestampFromWpGmt(data.date_created_gmt) ?? 0,
 		role: data.role,
 		username: data.username
 	};
@@ -1488,109 +1275,416 @@ const GET_PRODUCT_ERROR_MAP = defineErrorMap({ PRODUCT_NOT_FOUND: {
 } });
 const LIST_PRODUCT_ERROR_MAP = defineErrorMap({});
 
+//#endregion
+//#region src/product/schema.ts
+const SWATCH_TYPES = [
+	"text",
+	"color",
+	"image"
+];
+const SwatchType = z.enum(SWATCH_TYPES);
+const PRODUCT_TYPES = [
+	"simple",
+	"grouped",
+	"external",
+	"variable",
+	"variation"
+];
+const ProductType = z.enum(PRODUCT_TYPES);
+const ProductTermSummary = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	url: z.string().nullable()
+});
+const ProductTagSummary = ProductTermSummary;
+const ProductBrandSummary = ProductTermSummary;
+const ProductCategorySummary = ProductTermSummary;
+const ProductAttributeTermSummary = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	isDefault: z.boolean()
+});
+const ProductAttributeSummary = z.object({
+	id: z.number(),
+	name: z.string(),
+	taxonomy: z.string().nullable(),
+	hasVariations: z.boolean(),
+	terms: z.array(ProductAttributeTermSummary)
+});
+const ProductVariationAttributeSummary = z.object({
+	name: z.string(),
+	value: z.string().nullable()
+});
+const ProductVariationSummary = z.object({
+	id: z.number(),
+	attributes: z.array(ProductVariationAttributeSummary)
+});
+const ProductPriceRange = z.object({
+	minAmount: z.number(),
+	maxAmount: z.number()
+});
+const ProductPrices = z.object({
+	price: z.number(),
+	regularPrice: z.number(),
+	salePrice: z.number().nullable(),
+	priceRange: ProductPriceRange.nullable()
+});
+const ProductStockAvailability = z.object({
+	text: z.string(),
+	class: z.string()
+});
+const ProductDimensions = z.object({
+	length: z.string(),
+	width: z.string(),
+	height: z.string()
+});
+const ProductAddToCart = z.object({
+	text: z.string(),
+	description: z.string(),
+	singleText: z.string(),
+	minimum: z.number(),
+	maximum: z.number(),
+	multipleOf: z.number()
+});
+const ProductExtensions = z.record(z.string(), z.unknown());
+const ProductSummary = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	parentId: z.number().nullable(),
+	type: z.string(),
+	variationDescription: z.string(),
+	url: z.string().nullable(),
+	sku: z.string().nullable(),
+	shortDescription: z.string(),
+	description: z.string(),
+	isPasswordProtected: z.boolean(),
+	isOnSale: z.boolean(),
+	prices: ProductPrices,
+	currencyFormat: CurrencyFormat,
+	priceHtml: z.string(),
+	averageRating: z.number(),
+	reviewCount: z.number(),
+	images: z.array(MediaImage),
+	categories: z.array(ProductCategorySummary),
+	tags: z.array(ProductTagSummary),
+	brands: z.array(ProductBrandSummary),
+	attributes: z.array(ProductAttributeSummary),
+	variations: z.array(ProductVariationSummary),
+	groupedProductIds: z.array(z.number()),
+	hasOptions: z.boolean(),
+	isPurchasable: z.boolean(),
+	isInStock: z.boolean(),
+	isOnBackorder: z.boolean(),
+	stockAvailability: ProductStockAvailability,
+	lowStockRemaining: z.number().nullable(),
+	isSoldIndividually: z.boolean(),
+	addToCart: ProductAddToCart,
+	extensions: ProductExtensions
+});
+const ProductRecommendations = z.object({
+	upsells: z.array(ProductSummary),
+	crossSells: z.array(ProductSummary),
+	related: z.array(ProductSummary)
+});
+const ProductCustomFieldsSchema = customFieldsSchema();
+const Product = ProductSummary.extend({
+	weight: z.string(),
+	dimensions: ProductDimensions,
+	formattedWeight: z.string(),
+	formattedDimensions: z.string(),
+	stockQuantity: z.number().nullable(),
+	saleStartsAt: z.number().nullable(),
+	saleEndsAt: z.number().nullable(),
+	seo: Seo.nullable(),
+	custom: ProductCustomFieldsSchema,
+	recommendations: ProductRecommendations.nullable()
+});
+const ProductList = z.object({
+	items: z.array(Product),
+	meta: ListMetadata
+});
+const RetrieveProductInput = z.object({
+	identifier: IdentifierInput,
+	previewToken: z.string().optional(),
+	recommendations: BooleanLike.optional()
+});
+const PRODUCTS_ORDER_BYS = [
+	"date",
+	"modified",
+	"id",
+	"include",
+	"title",
+	"slug",
+	"price",
+	"popularity",
+	"rating",
+	"menu_order",
+	"comment_count"
+];
+const ProductOrderBy = z.enum(PRODUCTS_ORDER_BYS);
+const PRODUCT_DATE_COLUMNS = [
+	"date",
+	"date_gmt",
+	"modified",
+	"modified_gmt"
+];
+const ProductDateColumn = z.enum(PRODUCT_DATE_COLUMNS);
+const PRODUCT_TAXONOMY_OPERATORS = [
+	"in",
+	"not_in",
+	"and"
+];
+const ProductTaxonomyOperator = z.enum(PRODUCT_TAXONOMY_OPERATORS);
+const PRODUCT_ATTRIBUTE_RELATIONS = ["in", "and"];
+const ProductAttributeRelation = z.enum(PRODUCT_ATTRIBUTE_RELATIONS);
+const PRODUCT_STOCK_STATUSES = [
+	"instock",
+	"outofstock",
+	"onbackorder"
+];
+const ProductStockStatus = z.enum(PRODUCT_STOCK_STATUSES);
+const PRODUCT_CATALOG_VISIBILITIES = [
+	"any",
+	"visible",
+	"catalog",
+	"search",
+	"hidden"
+];
+const ProductCatalogVisibility = z.enum(PRODUCT_CATALOG_VISIBILITIES);
+const PRODUCT_RATINGS = [
+	1,
+	2,
+	3,
+	4,
+	5
+];
+const ProductRating = z.union([
+	z.literal(1),
+	z.literal(2),
+	z.literal(3),
+	z.literal(4),
+	z.literal(5)
+]);
+const ProductRatingInput = NumberLike.pipe(ProductRating);
+const ProductTermIdentifier = z.union([NumberLike, z.string()]);
+const ProductTaxonomyName = z.string().min(1).regex(/^[a-z0-9_-]+$/).refine((name) => !name.endsWith("_operator"));
+const ProductAttributeFilter = z.object({
+	taxonomy: z.string(),
+	slug: arrayable(z.string()).optional(),
+	termId: arrayable(NumberLike).optional(),
+	operator: ProductTaxonomyOperator.optional()
+});
+const ProductTaxonomyFilter = z.object({
+	taxonomy: ProductTaxonomyName,
+	termIds: arrayable(NumberLike).optional(),
+	slugs: arrayable(z.string()).optional(),
+	operator: ProductTaxonomyOperator.optional()
+}).refine((filter) => filter.termIds === void 0 !== (filter.slugs === void 0), { message: "Provide either termIds or slugs." });
+const ListProductInput = z.object({
+	page: NumberLike.optional(),
+	perPage: NumberLike.optional(),
+	search: z.string().optional(),
+	recommendations: BooleanLike.optional(),
+	slug: arrayable(z.string()).optional(),
+	after: z.string().optional(),
+	before: z.string().optional(),
+	dateColumn: ProductDateColumn.optional(),
+	exclude: arrayable(NumberLike).optional(),
+	include: arrayable(NumberLike).optional(),
+	offset: NumberLike.optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	orderBy: ProductOrderBy.optional(),
+	parent: arrayable(NumberLike).optional(),
+	parentExclude: arrayable(NumberLike).optional(),
+	type: z.string().optional(),
+	sku: arrayable(z.string()).optional(),
+	featured: BooleanLike.optional(),
+	category: arrayable(ProductTermIdentifier).optional(),
+	categoryOperator: ProductTaxonomyOperator.optional(),
+	brand: arrayable(ProductTermIdentifier).optional(),
+	brandOperator: ProductTaxonomyOperator.optional(),
+	tag: arrayable(ProductTermIdentifier).optional(),
+	tagOperator: ProductTaxonomyOperator.optional(),
+	onSale: BooleanLike.optional(),
+	minPrice: NumberLike.optional(),
+	maxPrice: NumberLike.optional(),
+	stockStatus: arrayable(ProductStockStatus).optional(),
+	attributes: z.array(ProductAttributeFilter).optional(),
+	attributeRelation: ProductAttributeRelation.optional(),
+	catalogVisibility: ProductCatalogVisibility.optional(),
+	rating: arrayable(ProductRatingInput).optional(),
+	related: NumberLike.optional(),
+	taxonomies: z.array(ProductTaxonomyFilter).optional()
+});
+const ProductFiltersPriceRange = z.object({
+	minPrice: z.number(),
+	maxPrice: z.number()
+});
+const ProductFiltersStockStatus = z.object({
+	count: z.number(),
+	status: ProductStockStatus
+});
+const ProductFiltersRatingCount = z.object({
+	count: z.number(),
+	rating: ProductRating
+});
+const ProductFiltersTerm = z.object({
+	id: z.number(),
+	parentId: z.number().nullable(),
+	name: z.string(),
+	slug: z.string(),
+	taxonomy: z.string(),
+	description: z.string(),
+	count: z.number()
+});
+const ProductFiltersTaxonomyTerm = ProductFiltersTerm.extend({ image: MediaImage.nullable() });
+const ProductFiltersAttributeTerm = ProductFiltersTerm.extend({
+	type: SwatchType,
+	swatch: z.string().nullable()
+});
+const ProductFilters = z.object({
+	priceRange: ProductFiltersPriceRange,
+	ratingCounts: z.array(ProductFiltersRatingCount),
+	stockStatuses: z.array(ProductFiltersStockStatus),
+	attributeTerms: z.array(ProductFiltersAttributeTerm),
+	taxonomyTerms: z.array(ProductFiltersTaxonomyTerm),
+	currencyFormat: CurrencyFormat
+});
+const ProductAttributeCount = z.object({
+	taxonomy: z.string(),
+	operator: z.enum(["or", "and"]).optional()
+});
+const RetrieveProductFiltersInput = ListProductInput.omit({ recommendations: true }).extend({
+	ratingCounts: BooleanLike.optional(),
+	stockStatusCounts: BooleanLike.optional(),
+	taxonomyCounts: z.array(z.string()).optional(),
+	attributeCounts: z.array(ProductAttributeCount).optional()
+});
+
 //#endregion
 //#region src/product/utils.ts
+function assertNoMissingStoreProductInputs() {}
+assertNoMissingStoreProductInputs();
 function deserializeProduct(data) {
+	return deserializeStoreProduct(data.kizlo.store_product, null);
+}
+function deserializeStoreProduct(data, recommendations) {
+	const summary = deserializeProductSummary(data);
+	const { kizlo } = deserializeExtensions(data.extensions);
 	return {
-		id: data.id,
-		type: data.type,
-		slug: data.slug,
-		name: data.name,
-		sku: data.sku,
-		description: data.description,
-		shortDescription: data.short_description,
-		prices: {
-			price: data.kizlo.prices.price,
-			salePrice: data.kizlo.prices.sale_price,
-			regularPrice: data.kizlo.prices.regular_price
-		},
-		isSoldIndividually: data.sold_individually,
-		onSaleFrom: data.date_on_sale_from ? toTimestamp(data.date_on_sale_from) : null,
-		lowStockRemaining: data.low_stock_amount,
-		onSaleTo: data.date_on_sale_to ? toTimestamp(data.date_on_sale_to) : null,
-		isInStock: data.stock_status === "instock",
-		stock: data.stock_quantity,
-		images: deserializeImages(data.images),
-		categories: deserializeTermRefs(data.categories),
-		tags: deserializeTermRefs(data.tags),
-		averageRating: data.average_rating,
-		reviewCount: data.rating_count,
-		attributes: data.kizlo.attributes.map((item) => ({
-			id: item.id,
-			hasVariations: item.has_variations,
-			name: item.name,
-			taxonomy: item.taxonomy,
-			terms: item.terms
-		})),
-		groupedProducts: data.grouped_products,
-		isOnBackorder: data.backordered,
-		isPurchasable: data.purchasable,
-		isOnSale: data.on_sale,
-		parentId: data.parent_id,
-		brands: data.brands,
-		variations: data.kizlo.variations,
-		hasOptions: !!data.kizlo.variations.length,
-		currencyFormat: deserializeCurrencyFormat(data.kizlo.currency_format),
-		meta: toPublicMetadata(data.meta_data),
-		seo: null
+		...summary,
+		weight: data.weight,
+		dimensions: data.dimensions,
+		formattedWeight: data.formatted_weight,
+		formattedDimensions: data.formatted_dimensions,
+		stockQuantity: nullableNumber(kizlo.stock),
+		saleStartsAt: timestampFromIso(typeof kizlo.on_sale_from === "string" ? kizlo.on_sale_from : null),
+		saleEndsAt: timestampFromIso(typeof kizlo.on_sale_to === "string" ? kizlo.on_sale_to : null),
+		seo: isRecord(kizlo.seo) ? deserializeSeo(kizlo.seo) : null,
+		custom: productCustomFields(kizlo.custom),
+		recommendations
 	};
 }
-function deserializeStoreProduct(data) {
-	const kizlo = data.extensions.kizlo ?? {
-		stock: null,
-		on_sale_from: null,
-		on_sale_to: null,
-		hs_code: null
-	};
+function deserializeProductSummary(data) {
+	const { extensions, kizlo } = deserializeExtensions(data.extensions);
+	const termUrls = deserializeTermUrls(kizlo.term_urls);
 	return {
 		id: data.id,
-		type: productType(data.type),
 		name: data.name,
 		slug: data.slug,
-		sku: data.sku,
-		description: data.description,
+		parentId: data.parent === 0 ? null : data.parent,
+		type: data.type,
+		variationDescription: data.variation,
+		url: typeof kizlo.url === "string" ? kizlo.url : null,
+		sku: data.sku === "" ? null : data.sku,
 		shortDescription: data.short_description,
-		isInStock: data.is_in_stock,
-		reviewCount: data.review_count,
-		averageRating: data.average_rating,
-		lowStockRemaining: data.low_stock_remaining,
-		isSoldIndividually: data.sold_individually,
+		description: data.description,
+		isPasswordProtected: data.is_password_protected,
+		isOnSale: data.on_sale,
 		prices: {
-			price: +data.prices.price,
-			salePrice: +data.prices.sale_price,
-			regularPrice: +data.prices.regular_price
+			price: Number(data.prices.price),
+			regularPrice: Number(data.prices.regular_price),
+			salePrice: data.on_sale ? Number(data.prices.sale_price) : null,
+			priceRange: data.prices.price_range ? {
+				minAmount: Number(data.prices.price_range.min_amount),
+				maxAmount: Number(data.prices.price_range.max_amount)
+			} : null
 		},
-		images: deserializeImages(data.images),
-		categories: deserializeTermRefs(data.categories),
-		tags: deserializeTermRefs(data.tags),
-		attributes: data.attributes.map((item) => ({
-			id: item.id,
-			name: item.name,
-			terms: item.terms,
-			taxonomy: item.taxonomy,
-			hasVariations: item.has_variations
-		})),
 		currencyFormat: deserializeCurrencyFormat(data.prices),
-		brands: data.brands,
-		groupedProducts: data.grouped_products,
+		priceHtml: data.price_html,
+		averageRating: Number(data.average_rating),
+		reviewCount: data.review_count,
+		images: data.images.map((image) => ({
+			type: "image",
+			id: image.id,
+			src: image.src,
+			srcset: image.srcset,
+			name: image.name,
+			alt: image.alt
+		})),
+		categories: data.categories.map((term) => deserializeTermRef(term, "product_cat", termUrls)),
+		tags: data.tags.map((term) => deserializeTermRef(term, "product_tag", termUrls)),
+		brands: data.brands.map((term) => deserializeTermRef(term, "product_brand", termUrls)),
+		attributes: data.attributes.map((attribute) => ({
+			id: attribute.id,
+			name: attribute.name,
+			taxonomy: attribute.taxonomy ?? null,
+			hasVariations: attribute.has_variations,
+			terms: attribute.terms.map((term) => ({
+				id: term.id,
+				name: term.name,
+				slug: term.slug,
+				isDefault: term.default
+			}))
+		})),
+		variations: data.variations.map((variation) => ({
+			id: variation.id,
+			attributes: variation.attributes.map((attribute) => ({
+				name: attribute.name,
+				value: attribute.value ?? null
+			}))
+		})),
+		groupedProductIds: data.grouped_products,
 		hasOptions: data.has_options,
-		isOnBackorder: data.is_on_backorder,
 		isPurchasable: data.is_purchasable,
-		isOnSale: data.on_sale,
-		parentId: data.parent,
-		variations: data.variations,
-		stock: kizlo.stock,
-		onSaleFrom: kizlo.on_sale_from ? toTimestamp(kizlo.on_sale_from) : null,
-		onSaleTo: kizlo.on_sale_to ? toTimestamp(kizlo.on_sale_to) : null,
-		seo: null,
-		meta: {}
+		isInStock: data.is_in_stock,
+		isOnBackorder: data.is_on_backorder,
+		stockAvailability: data.stock_availability,
+		lowStockRemaining: data.low_stock_remaining,
+		isSoldIndividually: data.sold_individually,
+		addToCart: {
+			text: data.add_to_cart.text,
+			description: data.add_to_cart.description,
+			singleText: data.add_to_cart.single_text,
+			minimum: data.add_to_cart.minimum,
+			maximum: data.add_to_cart.maximum,
+			multipleOf: data.add_to_cart.multiple_of
+		},
+		extensions
+	};
+}
+function deserializeProductRecommendations(data) {
+	return {
+		upsells: deserializeEmbeddedProducts(data._embedded?.upsells),
+		crossSells: deserializeEmbeddedProducts(data._embedded?.cross_sells),
+		related: deserializeEmbeddedProducts(data._embedded?.related)
 	};
 }
+function productCustomFields(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
 function deserializeProductFilters(data) {
 	if (!data.price_range) return null;
 	const maxPrice = +data.price_range.max_price;
 	const minPrice = +data.price_range.min_price;
 	return {
+		ratingCounts: (data.rating_counts ?? []).flatMap((entry) => PRODUCT_RATINGS.includes(entry.rating) ? [{
+			count: entry.count,
+			rating: entry.rating
+		}] : []),
 		stockStatuses: (data.stock_status_counts ?? []).flatMap((entry) => {
 			const status = stockStatus(entry.status);
 			return status ? [{
@@ -1606,12 +1700,7 @@ function deserializeProductFilters(data) {
 			parentId: item.parent,
 			slug: item.slug,
 			taxonomy: item.taxonomy,
-			image: item.thumbnail ? {
-				id: 0,
-				alt: item.name,
-				name: item.name,
-				src: item.thumbnail
-			} : null
+			image: item.image
 		})),
 		attributeTerms: data.kizlo.attribute_counts.map((item) => ({
 			id: item.id,
@@ -1632,32 +1721,33 @@ function deserializeProductFilters(data) {
 	};
 }
 function serializeProductListInput(data) {
-	return {
+	const searchParams = {
 		after: data?.after,
 		attribute_relation: data?.attributeRelation,
 		before: data?.before,
-		brand: data?.brand,
+		brand: commaSeparated(data?.brand),
 		brand_operator: data?.brandOperator,
 		catalog_visibility: data?.catalogVisibility,
-		category: data?.category,
+		category: commaSeparated(data?.category),
 		category_operator: data?.categoryOperator,
+		date_column: data?.dateColumn,
 		featured: data?.featured,
-		max_price: data?.maxPrice ? String(data?.maxPrice) : void 0,
-		min_price: data?.minPrice ? String(data?.minPrice) : void 0,
+		max_price: data?.maxPrice === void 0 ? void 0 : String(data.maxPrice),
+		min_price: data?.minPrice === void 0 ? void 0 : String(data.minPrice),
 		on_sale: data?.onSale,
-		orderby: data?.orderby,
+		orderby: data?.orderBy,
 		parent: normalizeArrayableValue(data?.parent),
 		parent_exclude: normalizeArrayableValue(data?.parentExclude),
-		rating: normalizeArrayableValue(data?.rating)?.map((value) => Number(value)),
-		sku: data?.sku,
-		slug: data?.slug,
+		rating: normalizeArrayableValue(data?.rating),
+		sku: commaSeparated(data?.sku),
+		slug: commaSeparated(data?.slug),
 		stock_status: normalizeArrayableValue(data?.stockStatus),
-		tag: data?.tag,
+		tag: commaSeparated(data?.tag),
 		tag_operator: data?.tagOperator,
 		type: data?.type,
 		attributes: data?.attributes?.map((item) => ({
 			operator: item.operator,
-			attribute: item.attribute,
+			attribute: item.taxonomy,
 			slug: normalizeArrayableValue(item.slug),
 			term_id: normalizeArrayableValue(item.termId)
 		})),
@@ -1670,50 +1760,69 @@ function serializeProductListInput(data) {
 		related: data?.related,
 		search: data?.search
 	};
+	for (const filter of data?.taxonomies ?? []) {
+		const key = `_unstable_tax_${filter.taxonomy}`;
+		searchParams[key] = commaSeparated(filter.termIds ?? filter.slugs);
+		if (filter.operator !== void 0) searchParams[`${key}_operator`] = filter.operator;
+	}
+	return searchParams;
 }
-/**
-* WooCommerce declares both of these fields as plain strings, so the contract cannot narrow them and
-* neither can this without saying what it does with a value it does not recognize.
-*
-* A product type Kizlo has no name for reads as `simple`, which is what every gateway to a product
-* page needs it to behave like. An unrecognized stock status is dropped from the filter list
-* instead: a count nobody can label is not a filter anyone can offer.
-*/
-function productType(type) {
-	return PRODUCT_TYPES.includes(type) ? type : "simple";
+function commaSeparated(value) {
+	if (value === void 0) return void 0;
+	return (Array.isArray(value) ? value : [value]).join(",");
 }
 function stockStatus(status) {
 	return PRODUCT_STOCK_STATUSES.includes(status) ? status : null;
 }
-function deserializeImages(images) {
-	return images.map((item) => ({
-		id: item.id,
-		src: item.src,
-		name: item.name,
-		alt: item.alt
-	}));
-}
-function deserializeTermRefs(terms) {
-	return terms.map((term) => ({
+function deserializeTermRef(term, taxonomy, urls) {
+	return {
 		id: term.id,
 		name: term.name,
-		slug: term.slug
+		slug: term.slug,
+		url: urls[`${taxonomy}:${term.id}`] ?? null
+	};
+}
+function deserializeTermUrls(value) {
+	if (!Array.isArray(value)) return {};
+	return Object.fromEntries(value.flatMap((item) => {
+		if (!isRecord(item) || typeof item.id !== "number" || typeof item.taxonomy !== "string" || typeof item.url !== "string") return [];
+		return [[`${item.taxonomy}:${item.id}`, item.url]];
 	}));
 }
-function toTimestamp(date) {
-	return new Date(date).getTime();
+function deserializeEmbeddedProducts(collections) {
+	return (collections ?? []).flat().map(deserializeProductSummary);
+}
+function deserializeExtensions(value) {
+	const { kizlo: rawKizlo,...extensions } = asRecord(value);
+	return {
+		extensions,
+		kizlo: asRecord(rawKizlo)
+	};
+}
+function asRecord(value) {
+	return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nullableNumber(value) {
+	return typeof value === "number" ? value : null;
 }
 
 //#endregion
 //#region src/product/index.ts
+const PRODUCT_EMBEDS = "upsells,cross_sells,related";
 const PRODUCT_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
 		path: "/products/{identifier}",
 		params: RetrieveProductInput.pick({ identifier: true }),
-		query: RetrieveProductInput.pick({ previewToken: true }).optional(),
-		output: Product,
+		query: RetrieveProductInput.pick({
+			previewToken: true,
+			recommendations: true
+		}).optional(),
+		output: schemaType(Product),
 		errors: GET_PRODUCT_ERROR_MAP
 	}, async ({ context, input, errors }) => {
 		if (input.query?.previewToken) {
@@ -1731,29 +1840,43 @@ const PRODUCT_PROCEDURES = {
 			}
 			return deserializeProduct(response$1.data);
 		}
-		const response = await context.wordpress.woocommerce.products.list({ slug: String(input.params.identifier) });
+		const identifier = input.params.identifier;
+		const includeRecommendations = input.query?.recommendations ?? false;
+		const embeds = includeRecommendations ? { _embed: PRODUCT_EMBEDS } : {};
+		const response = typeof identifier === "number" ? await context.wordpress.woocommerce.store.products.getById({
+			id: identifier,
+			...embeds
+		}) : await context.wordpress.woocommerce.store.products.getBySlug({
+			slug: identifier,
+			...embeds
+		});
 		if (response.error) switch (response.error.code) {
+			case "woocommerce_rest_product_invalid_id":
+			case "woocommerce_rest_product_invalid_slug": throw errors.PRODUCT_NOT_FOUND({ message: response.error.message });
 			default:
 				context.logger.error("Get product unhandled error", response.error, {
-					identifier: input.params.identifier,
+					identifier,
 					code: response.error.code
 				});
 				throw errors.INTERNAL_SERVER_ERROR();
 		}
-		const data = response.data[0];
-		if (!data) throw errors.PRODUCT_NOT_FOUND();
-		return deserializeProduct(data);
+		return deserializeStoreProduct(response.data, includeRecommendations ? deserializeProductRecommendations(response.data) : null);
 	}),
 	list: createProcedure({
 		scope: "api",
 		method: "GET",
 		path: "/products",
 		query: ListProductInput.optional(),
-		output: ProductList,
+		output: schemaType(ProductList),
 		errors: LIST_PRODUCT_ERROR_MAP
 	}, async ({ context, input, errors }) => {
 		const searchParams = serializeProductListInput(input.query);
-		const response = await context.wordpress.woocommerce.store.products.list(searchParams);
+		const includeRecommendations = input.query?.recommendations ?? false;
+		const embeds = includeRecommendations ? { _embed: PRODUCT_EMBEDS } : {};
+		const response = await context.wordpress.woocommerce.store.products.list({
+			...searchParams,
+			...embeds
+		});
 		if (response.error) switch (response.error.code) {
 			default:
 				context.logger.error("List products unhandled error", response.error, { code: response.error.code });
@@ -1765,7 +1888,7 @@ const PRODUCT_PROCEDURES = {
 			searchParams: { ...searchParams }
 		});
 		return {
-			items: list.items.map(deserializeStoreProduct),
+			items: list.items.map((item) => deserializeStoreProduct(item, includeRecommendations ? deserializeProductRecommendations(item) : null)),
 			meta: deserializeListMetadata(list.meta)
 		};
 	}),
@@ -1780,12 +1903,12 @@ const PRODUCT_PROCEDURES = {
 		const response = await context.wordpress.woocommerce.store.products.collectionData({
 			...searchParams,
 			calculate_price_range: true,
-			calculate_rating_counts: input.query?.ratingFilters,
-			calculate_taxonomy_counts: input.query?.taxonomyFilters,
-			calculate_stock_status_counts: input.query?.stockStatusFilters,
-			calculate_attribute_counts: input.query?.attributeFilters?.map((item) => ({
+			calculate_rating_counts: input.query?.ratingCounts,
+			calculate_taxonomy_counts: input.query?.taxonomyCounts,
+			calculate_stock_status_counts: input.query?.stockStatusCounts,
+			calculate_attribute_counts: input.query?.attributeCounts?.map((item) => ({
 				taxonomy: item.taxonomy,
-				query_type: item.queryType
+				query_type: item.operator
 			}))
 		});
 		if (response.error) switch (response.error.code) {
@@ -1805,7 +1928,7 @@ function woocommerce() {
 		requires: {
 			plugins: [{
 				name: "kizlo-woocommerce",
-				version: "0.2.0"
+				version: "0.3.0"
 			}],
 			endpoints: [
 				"woocommerce.customers",
@@ -1826,4 +1949,4 @@ function woocommerce() {
 }
 
 //#endregion
-export { woocommerce };
+export { ListProductInput, PRODUCT_ATTRIBUTE_RELATIONS, PRODUCT_CATALOG_VISIBILITIES, PRODUCT_DATE_COLUMNS, PRODUCT_RATINGS, PRODUCT_STOCK_STATUSES, PRODUCT_TYPES, Product, ProductAddToCart, ProductAttributeCount, ProductAttributeFilter, ProductAttributeRelation, ProductAttributeSummary, ProductAttributeTermSummary, ProductBrandSummary, ProductCatalogVisibility, ProductCategorySummary, ProductCustomFieldsSchema, ProductDateColumn, ProductDimensions, ProductExtensions, ProductFilters, ProductFiltersAttributeTerm, ProductFiltersPriceRange, ProductFiltersRatingCount, ProductFiltersStockStatus, ProductFiltersTaxonomyTerm, ProductFiltersTerm, ProductList, ProductOrderBy, ProductPriceRange, ProductPrices, ProductRating, ProductRecommendations, ProductStockAvailability, ProductStockStatus, ProductSummary, ProductTagSummary, ProductTaxonomyFilter, ProductTaxonomyOperator, ProductTermSummary, ProductType, ProductVariationAttributeSummary, ProductVariationSummary, RetrieveProductFiltersInput, RetrieveProductInput, SWATCH_TYPES, SwatchType, woocommerce };