@oomol-lab/open-connector 1.7.0 → 1.8.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/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;
+}

package/src/providers/zendesk/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/zendesk/executors.js

@@ -1,5 +1,6 @@
 import { basicAuthorizationHeader, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requireOAuthCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { validateZendeskCredential, zendeskActionHandlers } from "./runtime.js";
+import { zendeskEvent } from "./trigger-on-event.js";
 const service = "zendesk";
 export const executors = defineProviderExecutors({
     service,
@@ -128,3 +129,4 @@ function normalizeZendeskSubdomain(raw) {
     }
     return subdomain;
 }
+export const triggers = [zendeskEvent];

package/src/providers/zendesk/trigger-on-event.d.ts

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

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

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

package/src/providers/zendesk/trigger-on-event.definition.js

@@ -0,0 +1,101 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = [
+    "zen:event-type:ticket.agent_assignment_changed",
+    "zen:event-type:ticket.attachment_linked_to_comment",
+    "zen:event-type:ticket.attachment_redacted_from_comment",
+    "zen:event-type:ticket.brand_changed",
+    "zen:event-type:ticket.comment_added",
+    "zen:event-type:ticket.comment_made_private",
+    "zen:event-type:ticket.comment_redacted",
+    "zen:event-type:ticket.created",
+    "zen:event-type:ticket.csat_received",
+    "zen:event-type:ticket.csat_requested",
+    "zen:event-type:ticket.custom_field_changed",
+    "zen:event-type:ticket.custom_status_changed",
+    "zen:event-type:ticket.description_changed",
+    "zen:event-type:ticket.email_ccs_changed",
+    "zen:event-type:ticket.external_id_changed",
+    "zen:event-type:ticket.followers_changed",
+    "zen:event-type:ticket.form_changed",
+    "zen:event-type:ticket.group_assignment_changed",
+    "zen:event-type:ticket.marked_as_spam",
+    "zen:event-type:ticket.merged",
+    "zen:event-type:ticket.next_sla_breach_changed",
+    "zen:event-type:ticket.ola_policy_changed",
+    "zen:event-type:ticket.organization_changed",
+    "zen:event-type:ticket.permanently_deleted",
+    "zen:event-type:ticket.priority_changed",
+    "zen:event-type:ticket.problem_link_changed",
+    "zen:event-type:ticket.requester_changed",
+    "zen:event-type:ticket.schedule_changed",
+    "zen:event-type:ticket.sla_policy_changed",
+    "zen:event-type:ticket.soft_deleted",
+    "zen:event-type:ticket.status_changed",
+    "zen:event-type:ticket.subject_changed",
+    "zen:event-type:ticket.submitter_changed",
+    "zen:event-type:ticket.tags_changed",
+    "zen:event-type:ticket.task_due_at_changed",
+    "zen:event-type:ticket.type_changed",
+    "zen:event-type:ticket.undeleted",
+    "zen:event-type:organization.created",
+    "zen:event-type:organization.custom_field_changed",
+    "zen:event-type:organization.deleted",
+    "zen:event-type:organization.external_id_changed",
+    "zen:event-type:organization.name_changed",
+    "zen:event-type:organization.tags_changed",
+    "zen:event-type:user.active_changed",
+    "zen:event-type:user.alias_changed",
+    "zen:event-type:user.created",
+    "zen:event-type:user.custom_field_changed",
+    "zen:event-type:user.custom_role_changed",
+    "zen:event-type:user.default_group_changed",
+    "zen:event-type:user.deleted",
+    "zen:event-type:user.details_changed",
+    "zen:event-type:user.external_id_changed",
+    "zen:event-type:user.group_membership_created",
+    "zen:event-type:user.group_membership_deleted",
+    "zen:event-type:user.identity_changed",
+    "zen:event-type:user.identity_created",
+    "zen:event-type:user.identity_deleted",
+    "zen:event-type:user.last_login_changed",
+    "zen:event-type:user.merged",
+    "zen:event-type:user.name_changed",
+    "zen:event-type:user.notes_changed",
+    "zen:event-type:user.only_private_comments_changed",
+    "zen:event-type:user.organization_membership_created",
+    "zen:event-type:user.organization_membership_deleted",
+    "zen:event-type:user.password_changed",
+    "zen:event-type:user.photo_changed",
+    "zen:event-type:user.role_changed",
+    "zen:event-type:user.suspended_changed",
+    "zen:event-type:user.tags_changed",
+    "zen:event-type:user.time_zone_changed",
+];
+export const endpoint = "/api/v2/webhooks";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(events), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when one of the selected Zendesk account events occurs.",
+    displayName: "Event Subscription",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "zendesk.on_event",
+    name: "on_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "subject", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "zendesk",
+    type: "integration",
+};