@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/weixin_store/executors.js

@@ -1,4 +1,4 @@
-import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalString } from "../../core/cast.js";
+import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, positiveInteger, } from "../../core/cast.js";
 import { createProviderFetch, defineProviderExecutors, providerInputError, providerUserAgent, readTransitFileInput, requireCustomCredential, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 import { getWechatAccessToken, isWechatTokenError, normalizeWechatApiError, parseWechatJson, readWechatErrcode, readWeixinStoreCredential, } from "./access-token.js";
 const service = "weixin_store";
@@ -35,6 +35,20 @@ const deliveryProductFieldMap = {
     productCnt: "product_cnt",
 };
 const weixinStoreActionHandlers = {
+    async upload_qualification_image(input, context) {
+        const file = await readTransitFileInput(input.file, context);
+        if (file.sizeBytes > 2 * 1024 * 1024) {
+            throw providerInputError("file must be at most 2 MB");
+        }
+        const formData = new FormData();
+        formData.set("media", file.file, file.name);
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/basics/qualification/upload",
+            body: formData,
+            timeoutMs: wechatImageUploadTimeoutMs,
+        });
+    },
     upload_image(input, context) {
         const imageUrl = optionalString(input.imageUrl);
         if ((imageUrl === undefined) === (input.file === undefined)) {
@@ -61,7 +75,53 @@ const weixinStoreActionHandlers = {
         return callWechatApi(context, {
             method: "POST",
             path: "/shop/ec/category/detail",
-            body: { cat_id: readPositiveInteger(input.catId, "catId") },
+            body: { cat_id: positiveInteger(input.catId, "catId", providerInputError) },
+        });
+    },
+    apply_category(input, context) {
+        const categoryInfo = optionalRecord(input.categoryInfo);
+        if (!categoryInfo) {
+            throw providerInputError("categoryInfo must be an object");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/category/add",
+            body: { category_info: mapCategoryApplication(categoryInfo) },
+        });
+    },
+    get_category_application(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/getbizcatflowdetail",
+            body: { audit_id: positiveInteger(input.auditId, "auditId", providerInputError) },
+        });
+    },
+    list_category_permissions(input, context) {
+        const status = optionalInteger(input.status);
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/get_category_relation_list",
+            body: compactObject({ is_filter_status: status !== undefined, status }),
+        });
+    },
+    precheck_product_category(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/product/categoryprecheck",
+            body: compactObject({
+                cat_id: input.catId === undefined ? undefined : positiveInteger(input.catId, "catId", providerInputError),
+            }),
+        });
+    },
+    get_category_product_rule(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/getcategoryproductrule",
+            body: compactObject({
+                cat_id: positiveInteger(input.catId, "catId", providerInputError),
+                release_mode: optionalInteger(input.releaseMode),
+                brand_id: input.brandId === undefined ? undefined : positiveInteger(input.brandId, "brandId", providerInputError),
+            }),
         });
     },
     list_valid_brands(input, context) {
@@ -260,7 +320,7 @@ const weixinStoreActionHandlers = {
             path: "/channels/ec/aftersale/rejectapply",
             body: compactObject({
                 after_sale_order_id: requiredInputString(input.afterSaleOrderId, "afterSaleOrderId"),
-                reject_reason_type: readPositiveInteger(input.rejectReasonType, "rejectReasonType"),
+                reject_reason_type: positiveInteger(input.rejectReasonType, "rejectReasonType", providerInputError),
                 reject_reason: optionalString(input.rejectReason),
             }),
         });
@@ -299,8 +359,8 @@ export const credentialValidators = {
 };
 /** Upload a local transit file as a store image, which WeChat sizes from the required pixel dimensions. */
 async function uploadImageFile(context, input) {
-    const width = readPositiveInteger(input.width, "width");
-    const height = readPositiveInteger(input.height, "height");
+    const width = positiveInteger(input.width, "width", providerInputError);
+    const height = positiveInteger(input.height, "height", providerInputError);
     const file = await readTransitFileInput(input.file, context);
     const formData = new FormData();
     formData.set("media", file.file, file.name);
@@ -362,6 +422,38 @@ async function executeWechatJsonRequest(context, request, accessToken) {
         return { status: response.status, record: parseWechatJson(rawText), rawText };
     });
 }
+/**
+ * Build the category_info of a category application: force the certificate-group
+ * protocol and send every id as the number WeChat documents, since callers often
+ * copy them from responses that carry numeric ids as strings.
+ */
+function mapCategoryApplication(categoryInfo) {
+    return {
+        ...categoryInfo,
+        cats_v2: objectArray(categoryInfo.cats_v2, "categoryInfo.cats_v2", providerInputError).map((cat) => ({
+            ...cat,
+            cat_id: positiveInteger(cat.cat_id, "categoryInfo.cats_v2[].cat_id", providerInputError),
+        })),
+        license_group_list: objectArray(categoryInfo.license_group_list, "categoryInfo.license_group_list", providerInputError).map((group) => {
+            const license = optionalRecord(group.license) ?? {};
+            return {
+                ...group,
+                license_group_id: positiveInteger(group.license_group_id, "categoryInfo.license_group_list[].license_group_id", providerInputError),
+                license: {
+                    ...license,
+                    license_id: positiveInteger(license.license_id, "categoryInfo.license_group_list[].license.license_id", providerInputError),
+                },
+            };
+        }),
+        brand_list: categoryInfo.brand_list === undefined
+            ? undefined
+            : objectArray(categoryInfo.brand_list, "categoryInfo.brand_list", providerInputError).map((brand) => ({
+                ...brand,
+                brand_id: positiveInteger(brand.brand_id, "categoryInfo.brand_list[].brand_id", providerInputError),
+            })),
+        is_new_apply_cat: true,
+    };
+}
 /** WeChat only reads deliver_acct_type when deliver_method is 3, and then it is required. */
 function checkProductPayload(input) {
     if (optionalInteger(input.deliverMethod) === 3 && input.deliverAcctType === undefined) {
@@ -447,13 +539,6 @@ function readOffsetLimit(input) {
 function readPageSize(input, max, defaultValue) {
     return readBoundedInteger(input.pageSize, "pageSize", 1, max) ?? defaultValue;
 }
-function readPositiveInteger(value, fieldName) {
-    const parsed = optionalInteger(value);
-    if (parsed === undefined || parsed < 1) {
-        throw providerInputError(`${fieldName} must be a positive integer`);
-    }
-    return parsed;
-}
 /** Read a WeChat id that the docs type inconsistently as string or number; numbers are sent in string form. */
 function readIdString(value, fieldName) {
     const stringId = optionalString(value);

package/src/providers/whatsapp/runtime.js

@@ -1,9 +1,10 @@
-import { compactObject, looseArray, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { compactObject, looseArray, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
 import { jsonObject } from "../../core/request.js";
-import { ProviderRequestError, providerUserAgent, readTransitFileInput } from "../provider-runtime.js";
+import { ProviderRequestError, providerInputError, providerUserAgent, readTransitFileInput, } from "../provider-runtime.js";
 export const whatsappGraphApiBaseUrl = "https://graph.facebook.com";
 export const whatsappGraphApiVersion = "v23.0";
 const whatsappMeFields = "id,name";
+const analyticsDefaultWindowSeconds = 30 * 24 * 60 * 60;
 export const whatsappActionHandlers = {
     get_phone_numbers(input, context) {
         return whatsappGetPhoneNumbers(input, context);
@@ -20,6 +21,15 @@ export const whatsappActionHandlers = {
     get_template_status(input, context) {
         return whatsappGetTemplateStatus(input, context);
     },
+    get_message_analytics(input, context) {
+        return whatsappGetMessageAnalytics(input, context);
+    },
+    get_pricing_analytics(input, context) {
+        return whatsappGetPricingAnalytics(input, context);
+    },
+    get_template_analytics(input, context) {
+        return whatsappGetTemplateAnalytics(input, context);
+    },
     create_message_template(input, context) {
         return whatsappCreateMessageTemplate(input, context);
     },
@@ -90,7 +100,7 @@ async function whatsappGetPhoneNumbers(input, context) {
     const payload = await whatsappRequest({
         accessToken: context.accessToken,
         path: `/${wabaId}/phone_numbers`,
-        query: { limit: input.limit },
+        query: { after: input.after, limit: input.limit },
         fetcher: context.fetcher,
         signal: context.signal,
         operation: "get_phone_numbers",
@@ -160,6 +170,97 @@ async function whatsappGetTemplateStatus(input, context) {
     });
     return normalizeTemplate(payload);
 }
+async function whatsappGetMessageAnalytics(input, context) {
+    const wabaId = requireWabaId(input, context, "get_message_analytics");
+    const window = resolveAnalyticsWindow(input, "get_message_analytics");
+    const granularity = readString(input.granularity) ?? "DAY";
+    const payload = await whatsappRequest({
+        accessToken: context.accessToken,
+        path: `/${wabaId}`,
+        query: {
+            fields: graphAnalyticsField("analytics", {
+                start: window.start,
+                end: window.end,
+                granularity,
+                phone_numbers: input.phone_numbers,
+                product_types: input.product_types,
+                country_codes: input.country_codes,
+            }),
+        },
+        fetcher: context.fetcher,
+        signal: context.signal,
+        operation: "get_message_analytics",
+        phase: "execute",
+    });
+    const analytics = asRecord(payload.analytics, "analytics");
+    return compactObject({
+        granularity: readString(analytics.granularity) ?? granularity,
+        phone_numbers: readStringArray(analytics.phone_numbers),
+        country_codes: readStringArray(analytics.country_codes),
+        data_points: looseArray(analytics.data_points).map((item) => normalizeMessageAnalyticsDataPoint(item)),
+    });
+}
+async function whatsappGetPricingAnalytics(input, context) {
+    const wabaId = requireWabaId(input, context, "get_pricing_analytics");
+    const window = resolveAnalyticsWindow(input, "get_pricing_analytics");
+    const payload = await whatsappRequest({
+        accessToken: context.accessToken,
+        path: `/${wabaId}`,
+        query: {
+            fields: graphAnalyticsField("pricing_analytics", {
+                start: window.start,
+                end: window.end,
+                granularity: readString(input.granularity) ?? "DAILY",
+                phone_numbers: input.phone_numbers,
+                country_codes: input.country_codes,
+                metric_types: input.metric_types,
+                pricing_types: input.pricing_types,
+                pricing_categories: input.pricing_categories,
+                dimensions: input.dimensions,
+            }),
+        },
+        fetcher: context.fetcher,
+        signal: context.signal,
+        operation: "get_pricing_analytics",
+        phase: "execute",
+    });
+    const analytics = asRecord(payload.pricing_analytics, "pricing_analytics");
+    return {
+        data_points: flattenAnalyticsData(analytics.data).map((item) => normalizePricingAnalyticsDataPoint(item)),
+    };
+}
+async function whatsappGetTemplateAnalytics(input, context) {
+    const wabaId = requireWabaId(input, context, "get_template_analytics");
+    const useWabaTimezone = optionalBoolean(input.use_waba_timezone) ?? false;
+    const window = resolveTemplateAnalyticsWindow(input, useWabaTimezone);
+    const templateIds = looseArray(input.template_ids);
+    const payload = await whatsappRequest({
+        accessToken: context.accessToken,
+        path: `/${wabaId}/template_analytics`,
+        query: {
+            start: window.start,
+            end: window.end,
+            // The template_analytics edge accepts DAILY only.
+            granularity: "DAILY",
+            // Meta's documented syntax: template_ids=[id,id] and metric_types=a,b, both unquoted.
+            template_ids: `[${templateIds.map((id) => String(id)).join(",")}]`,
+            metric_types: graphList(input.metric_types),
+            product_type: input.product_type,
+            use_waba_timezone: useWabaTimezone ? "true" : undefined,
+            after: input.after,
+        },
+        fetcher: context.fetcher,
+        signal: context.signal,
+        operation: "get_template_analytics",
+        phase: "execute",
+    });
+    const buckets = looseArray(payload.data).map((entry) => optionalRecord(entry));
+    return compactObject({
+        waba_timezone: buckets.map((bucket) => readString(bucket?.waba_timezone)).find((zone) => zone !== undefined),
+        data_points: flattenAnalyticsData(payload.data).map((item) => normalizeTemplateAnalyticsDataPoint(item)),
+        paging: normalizePaging(payload.paging),
+    });
+}
 async function whatsappCreateMessageTemplate(input, context) {
     const wabaId = requireWabaId(input, context, "create_message_template");
     const payload = await whatsappRequest({
@@ -531,6 +632,125 @@ function normalizeWebhookConfiguration(value) {
         return undefined;
     return compactObject({ application: readString(record.application) });
 }
+function resolveAnalyticsWindow(input, actionName) {
+    const end = optionalInteger(input.end) ?? Math.floor(Date.now() / 1000);
+    const start = optionalInteger(input.start) ?? end - analyticsDefaultWindowSeconds;
+    if (start >= end)
+        throw providerInputError(`whatsapp ${actionName} requires start to be earlier than end`);
+    return { start, end };
+}
+/**
+ * Render a WABA analytics field with Meta's dot-chained modifier syntax, e.g.
+ * `pricing_analytics.start(1).end(2).granularity(DAILY).dimensions(PRICING_CATEGORY,COUNTRY)`.
+ * Every value is written bare, exactly as Meta's reference examples do: no
+ * quotes around enums or phone numbers, lists as comma-separated items. Empty
+ * lists are omitted, which Meta reads as "no filter", the same as an absent
+ * modifier.
+ */
+function graphAnalyticsField(field, modifiers) {
+    let rendered = field;
+    for (const [key, value] of Object.entries(modifiers)) {
+        const item = Array.isArray(value) ? graphList(value) : value;
+        if (item == null)
+            continue;
+        rendered += `.${key}(${String(item)})`;
+    }
+    return rendered;
+}
+/** Comma-separated bare items, the list form Meta's analytics reference uses; `undefined` when empty. */
+function graphList(value) {
+    const items = looseArray(value);
+    if (items.length === 0)
+        return undefined;
+    return items.map((item) => String(item)).join(",");
+}
+/**
+ * The template_analytics edge takes a UNIX timestamp or a YYYY-MM-DD date, and
+ * insists on the date form when use_waba_timezone is set. A timestamp given in
+ * that mode is converted to its UTC calendar date so the caller can use one
+ * input shape for both modes.
+ */
+function resolveTemplateAnalyticsWindow(input, useWabaTimezone) {
+    const startDate = readString(input.start);
+    const endDate = readString(input.end);
+    for (const date of [startDate, endDate]) {
+        if (date !== undefined &&
+            (!Number.isFinite(Date.parse(date)) || new Date(date).toISOString().slice(0, 10) !== date))
+            throw providerInputError("whatsapp template analytics requires valid calendar dates");
+    }
+    const window = resolveAnalyticsWindow({
+        start: startDate === undefined ? optionalInteger(input.start) : Date.parse(startDate) / 1000,
+        end: endDate === undefined ? optionalInteger(input.end) : Date.parse(endDate) / 1000,
+    }, "get_template_analytics");
+    const start = startDate ?? window.start;
+    const end = endDate ?? window.end;
+    if (!useWabaTimezone)
+        return { start, end };
+    const calendarStart = toCalendarDate(start);
+    const calendarEnd = toCalendarDate(end);
+    if (calendarStart >= calendarEnd) {
+        throw providerInputError("whatsapp get_template_analytics requires start to be earlier than end");
+    }
+    return { start: calendarStart, end: calendarEnd };
+}
+function toCalendarDate(value) {
+    if (typeof value === "string")
+        return value;
+    return new Date(value * 1000).toISOString().slice(0, 10);
+}
+/** Meta nests `data_points` under one `data[]` entry per granularity/product bucket; callers want one flat list. */
+function flattenAnalyticsData(value) {
+    return looseArray(value).flatMap((entry) => looseArray(optionalRecord(entry)?.data_points));
+}
+function normalizeMessageAnalyticsDataPoint(value) {
+    const record = asRecord(value, "analytics.data_points[]");
+    return compactObject({
+        start: optionalNumber(record.start),
+        end: optionalNumber(record.end),
+        sent: optionalNumber(record.sent),
+        delivered: optionalNumber(record.delivered),
+    });
+}
+function normalizePricingAnalyticsDataPoint(value) {
+    const record = asRecord(value, "pricing_analytics.data_points[]");
+    return compactObject({
+        start: optionalNumber(record.start),
+        end: optionalNumber(record.end),
+        volume: optionalNumber(record.volume),
+        cost: optionalNumber(record.cost),
+        phone_number: readString(record.phone_number),
+        country: readString(record.country),
+        pricing_category: readString(record.pricing_category),
+        pricing_type: readString(record.pricing_type),
+        tier: readString(record.tier),
+    });
+}
+function normalizeTemplateAnalyticsDataPoint(value) {
+    const record = asRecord(value, "template_analytics.data_points[]");
+    return compactObject({
+        template_id: readString(record.template_id) ?? "",
+        start: optionalNumber(record.start),
+        end: optionalNumber(record.end),
+        sent: optionalNumber(record.sent),
+        delivered: optionalNumber(record.delivered),
+        read: optionalNumber(record.read),
+        clicked: looseArray(record.clicked).map((item) => {
+            const click = asRecord(item, "template_analytics.clicked[]");
+            return compactObject({
+                type: readString(click.type) ?? "",
+                button_content: readString(click.button_content) ?? "",
+                count: optionalNumber(click.count) ?? 0,
+            });
+        }),
+        cost: looseArray(record.cost).map((item) => {
+            const cost = asRecord(item, "template_analytics.cost[]");
+            return compactObject({
+                type: readString(cost.type) ?? "",
+                value: optionalNumber(cost.value),
+            });
+        }),
+    });
+}
 function normalizePaging(value) {
     const record = optionalRecord(value);
     if (!record)

package/src/providers/woocommerce/executors.d.ts

@@ -1,4 +1,7 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/woocommerce/executors.js

@@ -1,6 +1,7 @@
 import { isPrivateNetworkAccessAllowed } from "../../core/request.js";
 import { basicAuthorizationHeader, createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { resolveWooCommerceCredentialContext, validateWooCommerceCredential, woocommerceActionHandlers, } from "./runtime.js";
+import { wooCommerceStoreEvent } from "./trigger-on-store-event.js";
 const service = "woocommerce";
 const proxyFetch = createProviderFetch({ allowPrivateNetwork: isPrivateNetworkAccessAllowed });
 export const executors = defineProviderExecutors({
@@ -49,3 +50,4 @@ export const credentialValidators = {
         return validateWooCommerceCredential(input.values, guardedFetcher, signal);
     },
 };
+export const triggers = [wooCommerceStoreEvent];

package/src/providers/woocommerce/trigger-on-store-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const wooCommerceStoreEvent: IntegrationDefinition;

package/src/providers/woocommerce/trigger-on-store-event.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/woocommerce/trigger-on-store-event.definition.js

@@ -0,0 +1,55 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const topics = [
+    "coupon.created",
+    "coupon.updated",
+    "coupon.deleted",
+    "coupon.restored",
+    "customer.created",
+    "customer.updated",
+    "customer.deleted",
+    "order.created",
+    "order.updated",
+    "order.deleted",
+    "order.restored",
+    "product.created",
+    "product.updated",
+    "product.deleted",
+    "product.restored",
+    "product.published",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(topics), { maxItems: 16, minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+        {
+            handle: "webhookName",
+            jsonSchema: s.string({ maxLength: 120, minLength: 1 }),
+            nullable: false,
+            value: "OOMOL Trigger",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected WooCommerce store events occur.",
+    displayName: "Store Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "woocommerce.on_store_event",
+    name: "on_store_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "resource", jsonSchema: s.string(), nullable: false },
+        { handle: "source", jsonSchema: s.string(), nullable: false },
+        { handle: "topic", jsonSchema: s.string(), nullable: false },
+        { handle: "webhookId", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "woocommerce",
+    type: "integration",
+};

package/src/providers/woocommerce/trigger-on-store-event.js

@@ -0,0 +1,179 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-store-event.definition.js";
+export const wooCommerceStoreEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        if (!(await verifyBase64Hmac(context.callbackSecret, [context.rawBody], context.header("x-wc-webhook-signature")))) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const topic = context.header("x-wc-webhook-topic")?.trim();
+        if (!topic)
+            return { outcome: "ignored", reason: "WooCommerce topic header is missing." };
+        if (!resolveConfig(context.config).events.includes(topic))
+            return { outcome: "ignored", reason: "WooCommerce topic is not subscribed." };
+        const deliveryId = context.header("x-wc-webhook-delivery-id") ?? "";
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: {
+                body: context.payload,
+                deliveryId,
+                event: context.header("x-wc-webhook-event") ?? "",
+                resource: context.header("x-wc-webhook-resource") ?? "",
+                source: context.header("x-wc-webhook-source") ?? "",
+                topic,
+                webhookId: context.header("x-wc-webhook-id") ?? "",
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        const listed = await list(context);
+        if (!context.active) {
+            for (const value of listed)
+                await remove(context, value.id);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const adopted = new Map();
+        for (const value of listed)
+            if (config.events.includes(value.topic) && !adopted.has(value.topic))
+                adopted.set(value.topic, value.id);
+        const kept = new Set(adopted.values());
+        for (const value of listed)
+            if (!kept.has(value.id))
+                await remove(context, value.id);
+        const ids = [];
+        for (const topic of config.events) {
+            const existing = adopted.get(topic);
+            ids.push(existing == null ? await create(context, config, topic) : await align(context, existing, topic));
+        }
+        await state.saveSubscription({ webhookIds: ids }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: [...new Set(value.events)],
+        webhookName: value.webhookName,
+    };
+}
+async function create(context, config, topic) {
+    const result = await request(context, `webhook create (${topic})`, {
+        body: {
+            delivery_url: context.endpointUrl,
+            name: `${config.webhookName} - ${topic}`,
+            secret: context.callbackSecret,
+            topic,
+        },
+        endpoint: "/webhooks",
+        method: "POST",
+    });
+    success(result, `webhook create (${topic})`);
+    return readId(result.data);
+}
+async function align(context, webhookId, topic) {
+    const result = await request(context, `webhook update (${topic})`, {
+        body: {
+            delivery_url: context.endpointUrl,
+            secret: context.callbackSecret,
+            status: "active",
+            topic,
+        },
+        endpoint: `/webhooks/${webhookId}`,
+        method: "PUT",
+    });
+    if (invalidId(result))
+        return create(context, resolveConfig(context.config), topic);
+    success(result, `webhook update (${topic})`);
+    return webhookId;
+}
+async function list(context) {
+    const matches = [];
+    for (let page = 1; page <= 10; page += 1) {
+        const result = await request(context, "webhook list", {
+            endpoint: "/webhooks",
+            method: "GET",
+            query: { context: "view", page, per_page: 100, status: "all" },
+        });
+        success(result, "webhook list");
+        const hooks = Array.isArray(result.data) ? result.data : [];
+        for (const hook of hooks) {
+            const value = record(hook);
+            if (value?.delivery_url !== context.endpointUrl || typeof value.topic != "string")
+                continue;
+            const webhookId = normalizeId(value.id);
+            if (webhookId != null)
+                matches.push({ id: webhookId, topic: value.topic });
+        }
+        if (hooks.length < 100)
+            return matches;
+    }
+    throw new TransientIntegrationError("WooCommerce webhook list did not finish within ten pages.");
+}
+async function remove(context, webhookId) {
+    const result = await request(context, "webhook delete", {
+        endpoint: `/webhooks/${webhookId}`,
+        method: "DELETE",
+        query: { force: "true" },
+    });
+    if (result.status != 404)
+        success(result, "webhook delete");
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`WooCommerce ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const code = errorCode(result.data);
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`WooCommerce ${operation} rejected the Connection.`);
+    if (result.status == 404 ||
+        (result.status == 400 && (code.endsWith("_invalid_topic") || code.endsWith("_invalid_delivery_url"))) ||
+        (result.status == 501 && code == "woocommerce_rest_trash_not_supported")) {
+        throw new PermanentIntegrationError(`WooCommerce ${operation} rejected the subscription.`);
+    }
+    throw new TransientIntegrationError(`WooCommerce ${operation} failed with status ${result.status}.`);
+}
+function invalidId(result) {
+    return result.status == 400 && errorCode(result.data) == "woocommerce_rest_webhook_invalid_id";
+}
+function errorCode(data) {
+    const value = record(data)?.code;
+    return typeof value == "string" ? value : "";
+}
+function readId(data) {
+    const value = normalizeId(record(data)?.id);
+    if (value == null)
+        throw new TransientIntegrationError("WooCommerce webhook response is missing its ID.");
+    return value;
+}
+function normalizeId(value) {
+    if (typeof value == "string" && value.length > 0)
+        return value;
+    return typeof value == "number" && Number.isFinite(value) ? String(value) : null;
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("WooCommerce Integration state is missing.");
+    return value;
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}