@kizlo/woocommerce 0.1.9 → 0.2.1

package/dist/index.d.ts

@@ -1329,7 +1329,7 @@ declare function woocommerce(): kizlo0.Extension<"woocommerce", {
       attributes: {
         id: number;
         name: string;
-        taxonomy: string;
+        taxonomy: string | null;
         hasVariations: boolean;
         terms: {
           id: number;
@@ -1537,7 +1537,7 @@ declare function woocommerce(): kizlo0.Extension<"woocommerce", {
         attributes: {
           id: number;
           name: string;
-          taxonomy: string;
+          taxonomy: string | null;
           hasVariations: boolean;
           terms: {
             id: number;
@@ -1719,7 +1719,7 @@ declare function woocommerce(): kizlo0.Extension<"woocommerce", {
         taxonomy: string;
         description: string;
         count: number;
-        type: "text" | "color" | "image";
+        type: "image" | "text" | "color";
         swatch: string | null;
       }[];
       taxonomyTerms: {
@@ -2424,8 +2424,7 @@ declare function woocommerce(): kizlo0.Extension<"woocommerce", {
     retry: kizlo0.Procedure<"api", {
       body: {
         key: string;
-        paymentMethod: string;
-        billingAddress?: {
+        billingAddress: {
           firstName: string;
           lastName: string;
           phone: string;
@@ -2437,7 +2436,8 @@ declare function woocommerce(): kizlo0.Extension<"woocommerce", {
           email: string;
           company?: string | undefined;
           address2?: string | undefined;
-        } | undefined;
+        };
+        paymentMethod: string;
         shippingAddress?: {
           firstName: string;
           lastName: string;

package/dist/index.js

@@ -1,10 +1,15 @@
-import { CurrencyFormat, IdentifierInput, KizloError, ListMetadata, Seo, WC_CORE_BASE, WC_STORE_BASE, WP_KIZLO_BASE, createExtension, createMiddleware, createProcedure, defineErrorMap, deserializeCurrencyFormat, deserializeListMetadata } from "kizlo";
+import { CurrencyFormat, IdentifierInput, KizloError, ListMetadata, Seo, createExtension, createMiddleware, createProcedure, defineErrorMap, deserializeCurrencyFormat, deserializeListMetadata } from "kizlo";
 import { BooleanLike, Media, Metadata, NumberLike, arrayable, normalizeArrayableValue, random, seconds, timestampSec, toPublicMetadata, tryCatch } from "@kizlo/shared";
 import { SignJWT, jwtVerify } from "jose";
 import z$1, { z } from "zod/v4";
 import z$2 from "zod";
 
 //#region src/session.ts
+const GUEST_COOKIE_OPTIONS = {
+	httpOnly: true,
+	path: "/",
+	sameSite: "lax"
+};
 async function mintGuestToken(secret, ttlSeconds) {
 	const sub = random({
 		length: 32,
@@ -49,10 +54,7 @@ function sessionMiddleware(options) {
 				await context.cookies.set({
 					name: cookieName,
 					value: jwt,
-					options: {
-						httpOnly: true,
-						sameSite: "lax"
-					}
+					options: GUEST_COOKIE_OPTIONS
 				});
 				return next({ context: { sessionHeaders: getCartHeaders({
 					token: sub,
@@ -65,10 +67,7 @@ function sessionMiddleware(options) {
 				await context.cookies.set({
 					name: cookieName,
 					value: jwt,
-					options: {
-						httpOnly: true,
-						sameSite: "lax"
-					}
+					options: GUEST_COOKIE_OPTIONS
 				});
 				throw new KizloError("CART_SESSION_EXPIRED");
 			}
@@ -80,17 +79,14 @@ function sessionMiddleware(options) {
 		if (foundToken) {
 			const [err, data] = await tryCatch(verifyToken(foundToken, context.config.siteSecret));
 			if (!err) {
-				const response = await context.wordpress.post("/cart/merge", {
-					base: WP_KIZLO_BASE,
-					headers: getCartHeaders({
-						userId: auth.id,
-						token: data.sub,
-						connInfo
-					})
-				});
+				const response = await context.wordpress.woocommerce.kizlo.cart.merge({}, { headers: getCartHeaders({
+					userId: auth.id,
+					token: data.sub,
+					connInfo
+				}) });
 				if (response.error) context.logger.error("CART_MERGE_FAILED", response.error);
 			}
-			await context.cookies.delete(cookieName);
+			await context.cookies.delete(cookieName, GUEST_COOKIE_OPTIONS);
 		}
 		return next({ context: { sessionHeaders: getCartHeaders({
 			userId: auth.id,
@@ -228,7 +224,7 @@ const ProductAttributeTermRef = z.object({
 const ProductAttributeRef = z.object({
 	id: z.number(),
 	name: z.string(),
-	taxonomy: z.string(),
+	taxonomy: z.string().nullable(),
 	hasVariations: z.boolean(),
 	terms: z.array(ProductAttributeTermRef)
 });
@@ -753,10 +749,7 @@ const CART_ROUTER = {
 		errors: GET_CART_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, errors }) => {
-		const response = await context.wordpress.get("/cart", {
-			base: WC_STORE_BASE,
-			headers: context.sessionHeaders
-		});
+		const response = await context.wordpress.woocommerce.store.cart.get({}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			default:
 				context.logger.error("Get cart unhandled error", response.error, { code: response.error.code });
@@ -774,45 +767,41 @@ const CART_ROUTER = {
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, input: { body: input }, errors }) => {
 		const connInfo = await context.getConnInfo();
-		const defaultBilling = input.billing ?? {
+		const billing = input.billing ?? {
 			...input.shipping,
 			email: void 0
 		};
-		const updateData = {
-			billing_address: defaultBilling !== void 0 ? {
-				first_name: defaultBilling?.firstName ?? "",
-				last_name: defaultBilling?.lastName ?? "",
-				address_1: defaultBilling?.address1 ?? "",
-				address_2: defaultBilling?.address2 ?? "",
-				company: defaultBilling?.company ?? "",
-				email: defaultBilling?.email ?? "",
-				phone: defaultBilling?.phone ?? "",
-				city: defaultBilling?.city ?? "",
-				state: defaultBilling?.state ?? connInfo?.state ?? void 0,
-				country: defaultBilling?.country ?? connInfo?.country ?? void 0,
-				postcode: defaultBilling?.postcode ?? connInfo?.postcode ?? ""
-			} : {},
-			shipping_address: input.shipping !== void 0 ? {
-				first_name: input.shipping?.firstName ?? "",
-				last_name: input.shipping?.lastName ?? "",
-				address_1: input.shipping?.address1 ?? "",
-				address_2: input.shipping?.address2 ?? "",
-				company: input.shipping?.company ?? "",
-				phone: input.shipping?.phone ?? "",
-				city: input.shipping?.city ?? "",
-				state: input.shipping?.state ?? connInfo?.state ?? void 0,
-				country: input.shipping?.country ?? connInfo?.country ?? void 0,
-				postcode: input.shipping?.postcode ?? connInfo?.postcode ?? ""
-			} : {}
+		const address = {
+			first_name: billing.firstName ?? "",
+			last_name: billing.lastName ?? "",
+			address_1: billing.address1 ?? "",
+			address_2: billing.address2 ?? "",
+			company: billing.company ?? "",
+			phone: billing.phone ?? "",
+			city: billing.city ?? "",
+			state: billing.state ?? connInfo?.state ?? "",
+			country: billing.country ?? connInfo?.country ?? "",
+			postcode: billing.postcode ?? connInfo?.postcode ?? ""
 		};
-		const response = await context.wordpress.post("/cart/update-customer", {
-			base: WC_STORE_BASE,
-			body: {
-				billing_address: updateData.billing_address,
-				shipping_address: updateData.shipping_address
+		const response = await context.wordpress.woocommerce.store.cart.updateCustomer({
+			billing_address: {
+				...address,
+				email: billing.email ?? ""
 			},
-			headers: context.sessionHeaders
-		});
+			...input.shipping && { shipping_address: {
+				...address,
+				first_name: input.shipping.firstName ?? "",
+				last_name: input.shipping.lastName ?? "",
+				address_1: input.shipping.address1 ?? "",
+				address_2: input.shipping.address2 ?? "",
+				company: input.shipping.company ?? "",
+				phone: input.shipping.phone ?? "",
+				city: input.shipping.city ?? "",
+				state: input.shipping.state ?? connInfo?.state ?? "",
+				country: input.shipping.country ?? connInfo?.country ?? "",
+				postcode: input.shipping.postcode ?? connInfo?.postcode ?? ""
+			} }
+		}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			default:
 				context.logger.error("Update cart customer unhandled error", response.error, { code: response.error.code });
@@ -829,14 +818,10 @@ const CART_ROUTER = {
 		errors: SELECT_SHIPPING_RATE_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, input: { body }, errors }) => {
-		const response = await context.wordpress.post("/cart/select-shipping-rate", {
-			base: WC_STORE_BASE,
-			headers: context.sessionHeaders,
-			body: {
-				rate_id: body.rateId,
-				package_id: body.packageId
-			}
-		});
+		const response = await context.wordpress.woocommerce.store.cart.selectShippingRate({
+			rate_id: body.rateId,
+			package_id: body.packageId
+		}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			case "woocommerce_rest_cart_shipping_rate_not_found": throw errors.CART_SHIPPING_RATE_NOT_FOUND({ message: response.error.message });
 			case "woocommerce_rest_shipping_disabled": throw errors.CART_SHIPPING_DISABLED({ message: response.error.message });
@@ -856,15 +841,11 @@ const CART_ROUTER = {
 			errors: ADD_CART_ITEM_ERROR_MAP,
 			middlewares: [sessionMiddleware()]
 		}, async ({ context, input: { body: input }, errors }) => {
-			const response = await context.wordpress.post("/cart/add-item", {
-				body: {
-					id: input.productId,
-					quantity: input.quantity,
-					variation: input.variations ?? []
-				},
-				base: WC_STORE_BASE,
-				headers: context.sessionHeaders
-			});
+			const response = await context.wordpress.woocommerce.store.cart.addItem({
+				id: input.productId,
+				quantity: input.quantity,
+				variation: input.variations ?? []
+			}, { headers: context.sessionHeaders });
 			if (response.error) switch (response.error.code) {
 				case "woocommerce_rest_product_out_of_stock": throw errors.CART_ITEM_OUT_OF_STOCK({ message: response.error.message });
 				case "woocommerce_rest_product_partially_out_of_stock": throw errors.CART_ITEM_INSUFFICIENT_STOCK({ message: response.error.message });
@@ -893,14 +874,10 @@ const CART_ROUTER = {
 			errors: UPDATE_CART_ITEM_ERROR_MAP,
 			middlewares: [sessionMiddleware()]
 		}, async ({ context, input: { params, body }, errors }) => {
-			const response = await context.wordpress.post("/cart/update-item", {
-				body: {
-					key: params.key,
-					quantity: body.quantity
-				},
-				base: WC_STORE_BASE,
-				headers: context.sessionHeaders
-			});
+			const response = await context.wordpress.woocommerce.store.cart.updateItem({
+				key: params.key,
+				quantity: body.quantity
+			}, { headers: context.sessionHeaders });
 			if (response.error) switch (response.error.code) {
 				case "woocommerce_rest_cart_invalid_key": throw errors.CART_ITEM_NOT_FOUND({ message: response.error.message });
 				case "woocommerce_rest_cart_invalid_product": throw errors.CART_PRODUCT_INVALID({ message: response.error.message });
@@ -922,11 +899,7 @@ const CART_ROUTER = {
 			errors: REMOVE_CART_ITEM_ERROR_MAP,
 			middlewares: [sessionMiddleware()]
 		}, async ({ context, input: { params }, errors }) => {
-			const response = await context.wordpress.post("/cart/remove-item", {
-				body: { key: params.key },
-				base: WC_STORE_BASE,
-				headers: context.sessionHeaders
-			});
+			const response = await context.wordpress.woocommerce.store.cart.removeItem({ key: params.key }, { headers: context.sessionHeaders });
 			if (response.error) switch (response.error.code) {
 				case "woocommerce_rest_cart_invalid_key": throw errors.CART_ITEM_NOT_FOUND({ message: response.error.message });
 				default:
@@ -946,11 +919,7 @@ const CART_ROUTER = {
 			errors: APPLY_COUPON_ERROR_MAP,
 			middlewares: [sessionMiddleware()]
 		}, async ({ context, input: { body }, errors }) => {
-			const response = await context.wordpress.post("/cart/apply-coupon", {
-				body: { code: body.code },
-				base: WC_STORE_BASE,
-				headers: context.sessionHeaders
-			});
+			const response = await context.wordpress.woocommerce.store.cart.applyCoupon({ code: body.code }, { headers: context.sessionHeaders });
 			if (response.error) switch (response.error.code) {
 				case "woocommerce_rest_cart_coupon_error": throw errors.CART_COUPON_INVALID({ message: response.error.message });
 				case "woocommerce_rest_cart_coupon_disabled": throw errors.CART_COUPON_DISABLED({ message: response.error.message });
@@ -969,11 +938,7 @@ const CART_ROUTER = {
 			errors: REMOVE_COUPON_ERROR_MAP,
 			middlewares: [sessionMiddleware()]
 		}, async ({ context, input, errors }) => {
-			const response = await context.wordpress.post("/cart/remove-coupon", {
-				body: { code: input.params.code },
-				base: WC_STORE_BASE,
-				headers: context.sessionHeaders
-			});
+			const response = await context.wordpress.woocommerce.store.cart.removeCoupon({ code: input.params.code }, { headers: context.sessionHeaders });
 			if (response.error) switch (response.error.code) {
 				case "woocommerce_rest_cart_coupon_error": throw errors.CART_COUPON_INVALID({ message: response.error.message });
 				case "woocommerce_rest_cart_coupon_disabled": throw errors.CART_COUPON_DISABLED({ message: response.error.message });
@@ -1175,13 +1140,61 @@ const RetryCheckoutInput = z$2.object({
 	orderId: NumberLike,
 	paymentMethod: z$2.string(),
 	billingEmail: z$2.email().optional(),
-	billingAddress: BillingAddress.optional(),
+	billingAddress: BillingAddress,
 	paymentData: CheckoutPaymentData.optional(),
 	shippingAddress: ShippingAddress.optional()
 });
 
 //#endregion
 //#region src/checkout/utils.ts
+/**
+* A payment method the caller named, passed to WooCommerce as one.
+*
+* WooCommerce builds this argument's enum from `get_payment_gateway_ids()`, so the contract
+* enumerates the gateways enabled on the WordPress the client was generated against. That is true of
+* that install and says nothing about the one a build actually talks to, and WooCommerce agrees: its
+* own comment on the enum is that further validation happens during the request.
+*
+* So the enum is documentation here rather than a constraint, and the gateway a shopper chose is
+* sent whatever it is. WooCommerce rejects an unknown one with
+* `woocommerce_rest_checkout_payment_method_disabled`, which both callers already map.
+*/
+function gateway(method) {
+	return method;
+}
+/**
+* A Kizlo address in the shape WooCommerce registered its argument in.
+*
+* Kizlo's addresses are camelCase and WooCommerce's are snake_case, and until the contract described
+* the route nothing said so: the retry call passed a Kizlo address straight through as
+* `billing_address`, where every key missed and WooCommerce kept the address already on the order.
+*
+* Every field is required there, so an address given in part is sent filled out. An address that was
+* not given at all is a different thing and never reaches here: WooCommerce reads an absent
+* `shipping_address` as "use the billing address", and a blank one as an address, so a caller who
+* omitted it must leave the argument off the call rather than send this filled with empty strings.
+*/
+function serializeAddress(address) {
+	return {
+		first_name: address.firstName,
+		last_name: address.lastName,
+		address_1: address.address1,
+		address_2: address.address2 ?? "",
+		company: address.company ?? "",
+		city: address.city,
+		state: address.state,
+		country: address.country,
+		postcode: address.postcode,
+		phone: address.phone
+	};
+}
+/** The same, plus the email WooCommerce carries on the billing address alone. */
+function serializeBillingAddress(address) {
+	return {
+		...serializeAddress(address),
+		email: address.email
+	};
+}
 function deserializeCheckout(data) {
 	return {
 		cart: data.__experimentalCart ? deserializeCart(data.__experimentalCart) : null,
@@ -1210,16 +1223,40 @@ function deserializeCheckout(data) {
 			postcode: data.billing_address.postcode,
 			state: data.billing_address.state
 		},
-		additionalFields: data.additional_fields,
+		additionalFields: additionalFields(data.additional_fields),
 		customerNote: data.customer_note,
 		paymentMethod: data.payment_method,
 		paymentResult: data.payment_result?.payment_status ? {
-			status: data.payment_result.payment_status,
+			status: paymentStatus(data.payment_result.payment_status),
 			redirectUrl: data.payment_result.redirect_url,
 			data: data.payment_result.payment_details
 		} : null
 	};
 }
+/**
+* WooCommerce registers `additional_fields` as a bare object, so the contract describes it as one
+* with undescribed contents: what a site's checkout fields are is a per-site question that no schema
+* can answer ahead of time. The values are scalars in practice, and anything else is dropped rather
+* than passed on to fail the procedure's own output validation with a less useful message.
+*/
+function additionalFields(fields) {
+	const kept = {};
+	for (const [key, value] of Object.entries(fields ?? {})) if (typeof value === "string" || typeof value === "boolean") kept[key] = value;
+	return kept;
+}
+/**
+* WooCommerce names the four statuses in the field's description and declares the field a plain
+* string, so the contract cannot narrow it. `error` is the safe reading of anything unrecognized: a
+* gateway that answered with something new has not taken payment as far as this checkout knows.
+*/
+function paymentStatus(status) {
+	switch (status) {
+		case "success":
+		case "pending":
+		case "failure": return status;
+		default: return "error";
+	}
+}
 
 //#endregion
 //#region src/checkout/index.ts
@@ -1232,10 +1269,7 @@ const CHECKOUT_ROUTER = {
 		errors: GET_CHECKOUT_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, errors }) => {
-		const response = await context.wordpress.get("/checkout", {
-			base: WC_STORE_BASE,
-			headers: context.sessionHeaders
-		});
+		const response = await context.wordpress.woocommerce.store.checkout.get({}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: response.error.message });
 			default:
@@ -1253,16 +1287,12 @@ const CHECKOUT_ROUTER = {
 		errors: UPDATE_CHECKOUT_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, input, errors }) => {
-		const response = await context.wordpress.put("/checkout", {
-			base: WC_STORE_BASE,
-			body: {
-				order_notes: input.body.customerNote,
-				payment_method: input.body.paymentMethod,
-				additional_fields: input.body.additionalFields,
-				__experimental_calc_totals: input.body.recalculateTotals
-			},
-			headers: context.sessionHeaders
-		});
+		const response = await context.wordpress.woocommerce.store.checkout.update({
+			order_notes: input.body.customerNote,
+			payment_method: gateway(input.body.paymentMethod),
+			additional_fields: input.body.additionalFields,
+			__experimental_calc_totals: input.body.recalculateTotals
+		}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			case "woocommerce_rest_cart_coupon_error": throw errors.CHECKOUT_COUPON_INVALID({ message: response.error.message });
 			case "woocommerce_rest_checkout_payment_method_disabled": throw errors.CHECKOUT_PAYMENT_METHOD_DISABLED({ message: response.error.message });
@@ -1287,30 +1317,23 @@ const CHECKOUT_ROUTER = {
 		errors: CONFIRM_CHECKOUT_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, input, errors }) => {
-		const checkoutResponse = await context.wordpress.get("/checkout", {
-			base: WC_STORE_BASE,
-			headers: context.sessionHeaders
-		});
+		const checkoutResponse = await context.wordpress.woocommerce.store.checkout.get({}, { headers: context.sessionHeaders });
 		if (checkoutResponse.error) switch (checkoutResponse.error.code) {
 			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: checkoutResponse.error.message });
 			default:
 				context.logger.error("Get checkout for confirm unhandled error", checkoutResponse.error, { code: checkoutResponse.error.code });
 				throw errors.INTERNAL_SERVER_ERROR();
 		}
-		const confirmResponse = await context.wordpress.post("/checkout", {
-			base: WC_STORE_BASE,
-			body: {
-				payment_data: input.body.paymentData,
-				customer_password: input.body.customerPassword,
-				customer_note: checkoutResponse.data.customer_note,
-				payment_method: checkoutResponse.data.payment_method,
-				create_account: !!input.body.customerPassword?.length,
-				billing_address: checkoutResponse.data.billing_address,
-				shipping_address: checkoutResponse.data.shipping_address,
-				additional_fields: checkoutResponse.data.additional_fields
-			},
-			headers: context.sessionHeaders
-		});
+		const confirmResponse = await context.wordpress.woocommerce.store.checkout.process({
+			payment_data: input.body.paymentData,
+			customer_password: input.body.customerPassword,
+			customer_note: checkoutResponse.data.customer_note,
+			payment_method: checkoutResponse.data.payment_method,
+			create_account: !!input.body.customerPassword?.length,
+			billing_address: checkoutResponse.data.billing_address,
+			shipping_address: checkoutResponse.data.shipping_address,
+			additional_fields: checkoutResponse.data.additional_fields
+		}, { headers: context.sessionHeaders });
 		if (confirmResponse.error) switch (confirmResponse.error.code) {
 			case "woocommerce_rest_invalid_address": throw errors.CHECKOUT_ADDRESS_INVALID({ message: confirmResponse.error.message });
 			case "woocommerce_rest_invalid_address_country": throw errors.CHECKOUT_ADDRESS_COUNTRY_INVALID({ message: confirmResponse.error.message });
@@ -1346,19 +1369,15 @@ const CHECKOUT_ROUTER = {
 		errors: RETRY_CHECKOUT_ERROR_MAP,
 		middlewares: [sessionMiddleware()]
 	}, async ({ context, input, errors }) => {
-		const response = await context.wordpress.post(`/checkout/${input.params.orderId}`, {
-			base: WC_STORE_BASE,
-			body: {
-				key: input.body.key,
-				id: input.params.orderId,
-				payment_data: input.body.paymentData,
-				billing_email: input.body.billingEmail,
-				payment_method: input.body.paymentMethod,
-				billing_address: input.body.billingAddress ?? {},
-				shipping_address: input.body.shippingAddress ?? {}
-			},
-			headers: context.sessionHeaders
-		});
+		const response = await context.wordpress.woocommerce.store.checkout.processOrder({
+			key: input.body.key,
+			id: input.params.orderId,
+			payment_data: input.body.paymentData,
+			billing_email: input.body.billingEmail,
+			payment_method: gateway(input.body.paymentMethod),
+			billing_address: serializeBillingAddress(input.body.billingAddress),
+			shipping_address: input.body.shippingAddress ? serializeAddress(input.body.shippingAddress) : void 0
+		}, { headers: context.sessionHeaders });
 		if (response.error) switch (response.error.code) {
 			case "woocommerce_rest_invalid_billing_email": throw errors.CHECKOUT_EMAIL_INVALID({ message: response.error.message });
 			case "woocommerce_rest_checkout_process_payment_error": throw errors.CHECKOUT_PAYMENT_FAILED({ message: response.error.message });
@@ -1447,8 +1466,17 @@ const CUSTOMER_ROUTER = { get: createProcedure({
 }, async ({ context, errors }) => {
 	const auth = await context.getAuthUser();
 	if (!auth) throw errors.FORBIDDEN();
-	const response = await context.wordpress.get(`/customers/${auth.id}`, { base: WC_CORE_BASE });
-	if (response.error) throw response.error;
+	const response = await context.wordpress.woocommerce.customers.retrieve({ id: auth.id });
+	if (response.error) switch (response.error.code) {
+		case "wc_user_invalid_id": throw errors.NOT_FOUND();
+		case "woocommerce_rest_cannot_view": throw errors.FORBIDDEN();
+		default:
+			context.logger.error("Get customer unhandled error", response.error, {
+				userId: auth.id,
+				code: response.error.code
+			});
+			throw errors.INTERNAL_SERVER_ERROR();
+	}
 	return deserializeCustomer(response.data);
 }) };
 
@@ -1472,13 +1500,13 @@ function deserializeProduct(data) {
 		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
+			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",
+		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,
@@ -1508,9 +1536,15 @@ function deserializeProduct(data) {
 	};
 }
 function deserializeStoreProduct(data) {
+	const kizlo = data.extensions.kizlo ?? {
+		stock: null,
+		on_sale_from: null,
+		on_sale_to: null,
+		hs_code: null
+	};
 	return {
 		id: data.id,
-		type: data.type,
+		type: productType(data.type),
 		name: data.name,
 		slug: data.slug,
 		sku: data.sku,
@@ -1545,9 +1579,9 @@ function deserializeStoreProduct(data) {
 		isOnSale: data.on_sale,
 		parentId: data.parent,
 		variations: data.variations,
-		stock: data.extensions.kizlo.stock,
-		onSaleFrom: data.extensions.kizlo.on_sale_from ? toTimestamp(data.extensions.kizlo.on_sale_from) : null,
-		onSaleTo: data.extensions.kizlo.on_sale_to ? toTimestamp(data.extensions.kizlo.on_sale_to) : null,
+		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: {}
 	};
@@ -1557,7 +1591,13 @@ function deserializeProductFilters(data) {
 	const maxPrice = +data.price_range.max_price;
 	const minPrice = +data.price_range.min_price;
 	return {
-		stockStatuses: data.stock_status_counts ?? [],
+		stockStatuses: (data.stock_status_counts ?? []).flatMap((entry) => {
+			const status = stockStatus(entry.status);
+			return status ? [{
+				count: entry.count,
+				status
+			}] : [];
+		}),
 		taxonomyTerms: data.kizlo.taxonomy_counts.map((item) => ({
 			id: item.id,
 			name: item.name,
@@ -1608,7 +1648,7 @@ function serializeProductListInput(data) {
 		orderby: data?.orderby,
 		parent: normalizeArrayableValue(data?.parent),
 		parent_exclude: normalizeArrayableValue(data?.parentExclude),
-		rating: normalizeArrayableValue(data?.rating)?.map(Number),
+		rating: normalizeArrayableValue(data?.rating)?.map((value) => Number(value)),
 		sku: data?.sku,
 		slug: data?.slug,
 		stock_status: normalizeArrayableValue(data?.stockStatus),
@@ -1631,6 +1671,20 @@ function serializeProductListInput(data) {
 		search: data?.search
 	};
 }
+/**
+* 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 stockStatus(status) {
+	return PRODUCT_STOCK_STATUSES.includes(status) ? status : null;
+}
 function deserializeImages(images) {
 	return images.map((item) => ({
 		id: item.id,
@@ -1665,7 +1719,7 @@ const PRODUCT_ROUTER = {
 		if (input.query?.previewToken) {
 			const result = await context.verifyPreviewToken(input.query.previewToken);
 			if (!result) throw errors.PRODUCT_NOT_FOUND();
-			const response$1 = await context.wordpress.get(`/products/${result.id}`, { base: WC_CORE_BASE });
+			const response$1 = await context.wordpress.woocommerce.products.retrieve({ id: Number(result.id) });
 			if (response$1.error) switch (response$1.error.code) {
 				case "woocommerce_rest_product_invalid_id": throw errors.PRODUCT_NOT_FOUND({ message: response$1.error.message });
 				default:
@@ -1677,10 +1731,7 @@ const PRODUCT_ROUTER = {
 			}
 			return deserializeProduct(response$1.data);
 		}
-		const response = await context.wordpress.get("/products", {
-			searchParams: { slug: input.params.identifier },
-			base: WC_CORE_BASE
-		});
+		const response = await context.wordpress.woocommerce.products.list({ slug: String(input.params.identifier) });
 		if (response.error) switch (response.error.code) {
 			default:
 				context.logger.error("Get product unhandled error", response.error, {
@@ -1702,10 +1753,7 @@ const PRODUCT_ROUTER = {
 		errors: LIST_PRODUCT_ERROR_MAP
 	}, async ({ context, input, errors }) => {
 		const searchParams = serializeProductListInput(input.query);
-		const response = await context.wordpress.get("/products", {
-			base: WC_STORE_BASE,
-			searchParams: { ...searchParams }
-		});
+		const response = await context.wordpress.woocommerce.store.products.list(searchParams);
 		if (response.error) switch (response.error.code) {
 			default:
 				context.logger.error("List products unhandled error", response.error, { code: response.error.code });
@@ -1729,19 +1777,16 @@ const PRODUCT_ROUTER = {
 		output: ProductFilters.nullable()
 	}, async ({ context, errors, input }) => {
 		const searchParams = serializeProductListInput(input.query);
-		const response = await context.wordpress.get("/products/collection-data", {
-			base: WC_STORE_BASE,
-			searchParams: {
-				...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) => ({
-					taxonomy: item.taxonomy,
-					query_type: item.queryType
-				}))
-			}
+		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) => ({
+				taxonomy: item.taxonomy,
+				query_type: item.queryType
+			}))
 		});
 		if (response.error) switch (response.error.code) {
 			default:
@@ -1757,6 +1802,21 @@ const PRODUCT_ROUTER = {
 function woocommerce() {
 	return createExtension({
 		id: "woocommerce",
+		requires: {
+			plugin: {
+				slug: "kizlo-woocommerce",
+				name: "Kizlo WooCommerce",
+				version: "0.2.0"
+			},
+			endpoints: [
+				"woocommerce.customers",
+				"woocommerce.products",
+				"woocommerce.kizlo.cart",
+				"woocommerce.store.cart",
+				"woocommerce.store.checkout",
+				"woocommerce.store.products"
+			]
+		},
 		init: () => {
 			return { router: {
 				cart: CART_ROUTER,

package/dist/test.js

@@ -1,6 +1,15 @@
-import { WC_CORE_BASE, WC_STORE_BASE } from "kizlo";
 import { defineFixture, kizloRelease } from "kizlo/test";
 
+//#region src/constants.ts
+/**
+* Base paths for the two WooCommerce APIs, used only where this package seeds or inspects a store
+* directly. Everything a router or service reaches goes through a generated endpoint, which derives
+* its own prefix from the namespace the plugin declares.
+*/
+const WC_CORE_BASE = "/wp-json/wc/v3";
+const WC_STORE_BASE = "/wp-json/wc/store/v1";
+
+//#endregion
 //#region src/test/index.ts
 const PRODUCTS = [
 	{
@@ -51,6 +60,30 @@ async function upsertCoupon(service, coupon) {
 	if (created.error) throw created.error;
 }
 /**
+* WooCommerce ships every gateway disabled, and paying an order needs an available one, so the
+* checkout tests have nothing to reach without this. Bank transfer is the gateway with no shipping
+* method or country conditions attached to it, so enabling it says the least about the rest.
+*/
+async function enableBankTransfer(service) {
+	const updated = await service.put(`${WC_CORE_BASE}/payment_gateways/bacs`, { body: { enabled: true } });
+	if (updated.error) throw updated.error;
+}
+/**
+* WooCommerce bundles Action Scheduler, which keeps its actions in the posts table until it
+* migrates to its own tables, and registers two global post statuses (`in-progress`, `failed`)
+* for as long as that legacy store is live. The migration is scheduled a minute after activation
+* and left to cron, so a WordPress reports those two statuses for roughly its first minute and
+* never again. Every post type's status enum is built from the global list, so a client generated
+* inside that window carries two statuses that one generated outside it does not.
+*
+* Firing Action Scheduler's own migration callback settles it: the runner finds nothing to move
+* on a fresh install and marks the migration complete itself, so this is its cron path run now
+* rather than its bookkeeping written by hand.
+*/
+async function settleActionScheduler(wpEval) {
+	await wpEval("if (class_exists(\"ActionScheduler_DataController\") && !ActionScheduler_DataController::is_migration_complete()) { do_action(\"action_scheduler/migration_hook\"); }");
+}
+/**
 * WooCommerce test fixture: installs WooCommerce + the kizlo-woocommerce plugin, seeds
 * products/coupons. Pass `plugins` to override the defaults — e.g. bind-mount your local
 * source with `{ path: "plugins/kizlo-woocommerce" }` to develop/test against live files.
@@ -62,6 +95,9 @@ function woocommerce(opts = {}) {
 			name: "kizlo-woocommerce",
 			source: kizloRelease("kizlo-woocommerce")
 		}],
+		async settle({ wpEval }) {
+			await settleActionScheduler(wpEval);
+		},
 		async seed({ service }) {
 			let productId = 0;
 			for (const product of PRODUCTS) {
@@ -69,6 +105,7 @@ function woocommerce(opts = {}) {
 				if (!productId) productId = id;
 			}
 			for (const coupon of COUPONS) await upsertCoupon(service, coupon);
+			await enableBankTransfer(service);
 			return { productId };
 		},
 		async cleanup({ service, userId }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kizlo/woocommerce",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "type": "module",
   "sideEffects": false,
   "description": "WooCommerce extension for Kizlo.",
@@ -49,11 +49,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@kizlo/shared": "0.6.0",
+    "@kizlo/shared": "0.7.0",
     "jose": "6.1.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "kizlo": ">=0.1.0"
+    "kizlo": ">=0.15.0"
   }
 }