@oomol-lab/open-connector 1.9.1 → 1.9.2

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

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

package/src/providers/vercel/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential } from "../provider-runtime.js";
 import { readVercelTeamScope, validateVercelCredential, vercelActionHandlers, vercelApiBaseUrl } from "./runtime.js";
+import { vercelDeploymentEvent } from "./trigger-on-deployment-event.js";
 const service = "vercel";
 const vercelProxyUserAgent = "oomol-connector/1.0 (+https://oomol.com)";
 export const executors = defineProviderExecutors({
@@ -29,3 +30,4 @@ export const credentialValidators = {
         return validateVercelCredential(input, fetcher);
     },
 };
+export const triggers = [vercelDeploymentEvent];

package/src/providers/vercel/trigger-on-deployment-event.d.ts

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

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

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const events: readonly ["deployment.ready", "deployment.error"];
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/vercel/trigger-on-deployment-event.definition.js

@@ -0,0 +1,41 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["deployment.ready", "deployment.error"];
+export const snapshot = {
+    key: "vercel.on_deployment_event",
+    provider: "vercel",
+    name: "on_deployment_event",
+    displayName: "Deployment Ready or Failed",
+    description: "Receives successful and failed deployments for a Vercel project.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "teamId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Team ID" },
+            nullable: false,
+        },
+        {
+            handle: "projectId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Project ID" },
+            nullable: false,
+        },
+        {
+            handle: "environment",
+            jsonSchema: { type: "string", enum: ["all", "production", "preview"], title: "Environment" },
+            nullable: false,
+            value: "all",
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "deploymentId", jsonSchema: s.string(), nullable: false },
+        { handle: "projectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/vercel/trigger-on-deployment-event.js

@@ -0,0 +1,102 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot, events } from "./trigger-on-deployment-event.definition.js";
+export const vercelDeploymentEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const query = { teamId: String(context.config.teamId) };
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/v1/webhooks/${encodeURIComponent(id)}`, method: "DELETE", query });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint: "/v1/webhooks", method: "GET", query });
+                if (!Array.isArray(result.data) ||
+                    result.data.some((item) => !isJsonObject(item) || typeof item.url != "string" || typeof item.id != "string"))
+                    throw new TransientIntegrationError("Vercel returned an invalid webhook list.");
+                const matches = result.data.filter((item) => isJsonObject(item) && item.url == context.endpointUrl);
+                if (matches.length > 1)
+                    throw new PermanentIntegrationError("Multiple Vercel webhooks match this subscription. Remove duplicates before retrying.");
+                const found = [];
+                for (const item of matches) {
+                    const id = item.id;
+                    if (item.ownerId != context.config.teamId ||
+                        !Array.isArray(item.projectIds) ||
+                        item.projectIds.length != 1 ||
+                        item.projectIds[0] != context.config.projectId ||
+                        !Array.isArray(item.events) ||
+                        item.events.length != events.length ||
+                        !events.every((event) => item.events.includes(event)))
+                        throw new PermanentIntegrationError("The Vercel webhook scope differs from this subscription. Restore its project and event settings.");
+                    const state = context.state;
+                    if (state.subscription.hookId == id && typeof state.subscription.secret == "string") {
+                        found.push({ id, secret: state.subscription.secret });
+                    }
+                    else {
+                        // Vercel only returns the secret on creation. Remove the owned orphan before recreating it.
+                        await remove(id);
+                        await state.saveSubscription({}, context.now);
+                    }
+                }
+                return found;
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint: "/v1/webhooks",
+                    method: "POST",
+                    query,
+                    body: { url: context.endpointUrl, events: [...events], projectIds: [context.config.projectId] },
+                });
+                const data = result.data;
+                if (!isJsonObject(data) ||
+                    typeof data.id != "string" ||
+                    !data.id ||
+                    typeof data.secret != "string" ||
+                    !data.secret)
+                    throw new TransientIntegrationError("Vercel webhook creation returned no identity or secret.");
+                return { id: data.id, secret: data.secret };
+            },
+            remove,
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-vercel-signature"), "SHA-1")))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) || typeof body.type != "string" || !events.includes(body.type))
+            return { outcome: "ignored", reason: "Vercel event does not match." };
+        const payload = body.payload;
+        if (!isJsonObject(payload) ||
+            !isJsonObject(payload.team) ||
+            payload.team.id != context.config.teamId ||
+            !isJsonObject(payload.project) ||
+            payload.project.id != context.config.projectId)
+            return { outcome: "ignored", reason: "Vercel project or Team does not match." };
+        if ((context.config.environment == "production" && payload.target != "production") ||
+            (context.config.environment == "preview" && payload.target !== null))
+            return { outcome: "ignored", reason: "Vercel environment does not match." };
+        if (typeof body.id != "string" ||
+            !body.id ||
+            !isJsonObject(payload.deployment) ||
+            typeof payload.deployment.id != "string" ||
+            !payload.deployment.id)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: body.id,
+            outputs: {
+                event: body.type,
+                deliveryId: body.id,
+                deploymentId: payload.deployment.id,
+                projectId: payload.project.id,
+                body: payload,
+            },
+        };
+    },
+};

package/src/providers/weixin_bot/runtime.d.ts

@@ -17,5 +17,4 @@ export interface WeixinRequestOptions {
 type WeixinBotActionHandler = (input: Record<string, unknown>, context: WeixinBotContext) => Promise<Record<string, unknown>>;
 export declare const weixinBotActionHandlers: ProviderActionHandlers<"weixin_bot", WeixinBotActionHandler>;
 export declare function requestWeixin(options: WeixinRequestOptions): Promise<Record<string, unknown>>;
-export declare function parseWeixinJson(text: string): unknown;
 export {};

package/src/providers/weixin_bot/runtime.js

@@ -137,7 +137,7 @@ function readTypingStatus(value) {
         return status;
     throw new ProviderRequestError(400, "status must be typing or cancel");
 }
-export function parseWeixinJson(text) {
+function parseWeixinJson(text) {
     const losslessIds = new Set(["message_id", "msg_id", "svr_id"]);
     let output = "";
     let position = 0;

package/src/providers/weixin_store/access-token.d.ts

@@ -44,9 +44,9 @@ export declare function readWechatErrcode(record: Record<string, unknown> | unde
 export declare function isWechatTokenError(errcode: number | null): boolean;
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
- * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes and the documented invalid-input store errcodes become
- * 400, and everything else becomes a 502.
+ * and invitation quotas become 429; missing permissions and policy bans become
+ * 403; duplicate/cooperation-capacity conflicts become 409; absent promotion
+ * products become 404. Documented input errors become 400; other failures 502.
  */
 export declare function normalizeWechatApiError(result: WechatApiResult): ProviderRequestError;
 export {};

package/src/providers/weixin_store/access-token.js

@@ -12,7 +12,9 @@ const accessTokenRefreshSkewMs = 120_000;
  * input, so they map to 400 instead of an upstream failure.
  */
 const wechatInvalidInputErrcodes = new Set([
-    9401020, 9700234, 10020017, 10020059, 10020060, 10020062, 10020063, 10020087, 10020094, 10020127, 10020504,
+    9401020, 9700234, 10020017, 10020059, 10020060, 10020062, 10020063, 10020087, 10020094, 10020127, 10020504, 10021069,
+    10023000, 10023001, 10024003, 10023100, 10023102, 10023104, 10023105, 10023106, 10023107, 10023108, 10023109,
+    10023110, 10023111, 10023112, 10023113, 10023116, 10023117, 10023121,
 ]);
 const accessTokenCache = new Map();
 const accessTokenInFlight = new Map();
@@ -133,9 +135,9 @@ export function isWechatTokenError(errcode) {
 }
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
- * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes and the documented invalid-input store errcodes become
- * 400, and everything else becomes a 502.
+ * and invitation quotas become 429; missing permissions and policy bans become
+ * 403; duplicate/cooperation-capacity conflicts become 409; absent promotion
+ * products become 404. Documented input errors become 400; other failures 502.
  */
 export function normalizeWechatApiError(result) {
     const errcode = readWechatErrcode(result.record);
@@ -147,11 +149,17 @@ export function normalizeWechatApiError(result) {
         // A bare HTTP 403 with no errcode envelope is the store's optional IP whitelist rejecting the caller.
         message = `${message}. If the store has an IP whitelist configured (微信小店后台 → 服务市场 → 经营工具 → 自研 → IP 白名单), add this runtime's public egress IP to it and try again.`;
     }
-    if (result.status === 429 || errcode === 45009 || errcode === 45011) {
+    if (result.status === 429 || errcode === 45009 || errcode === 45011 || errcode === 10020510 || errcode === 10023002) {
         return new ProviderRequestError(429, message, result.record);
     }
-    if (errcode === 48001) {
-        return new ProviderRequestError(403, message, result.record);
+    if (errcode === 48001 || errcode === 10023007 || errcode === 10023114 || errcode === 10023115) {
+        return new ProviderRequestError(403, message, result.record, "provider_error");
+    }
+    if (errcode === 10023003 || errcode === 10023004 || errcode === 10023006) {
+        return new ProviderRequestError(409, message, result.record);
+    }
+    if (errcode === 10023103) {
+        return new ProviderRequestError(404, message, result.record);
     }
     if (errcode !== null && ((errcode >= 40000 && errcode < 50000) || wechatInvalidInputErrcodes.has(errcode))) {
         return new ProviderRequestError(400, message, result.record);

package/src/providers/weixin_store/executors.js

@@ -1,4 +1,4 @@
-import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, positiveInteger, } from "../../core/cast.js";
+import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalNumber, 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,219 @@ const deliveryProductFieldMap = {
     productCnt: "product_cnt",
 };
 const weixinStoreActionHandlers = {
+    async list_league_promoter_products(input, context) {
+        const talentAppid = requiredInputString(input.talentAppid, "talentAppid");
+        const dataType = positiveInteger(input.dataType, "dataType", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        if (![1, 2].includes(dataType) || !Number.isSafeInteger(pageIndex) || pageSize > 20) {
+            throw providerInputError("dataType must be 1 or 2, pageIndex a safe positive integer, and pageSize at most 20");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/talent/getproductdatalist",
+            body: { talent_appid: talentAppid, get_data_type: dataType, page_index: pageIndex, page_size: pageSize },
+        });
+    },
+    async list_product_promotion_talents(input, context) {
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 10, "pageSize", providerInputError);
+        if (![productId, promotionPlanId, pageIndex].every(Number.isSafeInteger) || pageSize > 10) {
+            throw providerInputError("Ids and pageIndex must be safe positive integers; pageSize must be at most 10");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promotion/talent/list",
+            body: compactObject({
+                product_id: productId,
+                promotion_plan_id: promotionPlanId,
+                page_index: pageIndex,
+                page_size: pageSize,
+                talent_appid: input.talentAppid === undefined ? undefined : requiredInputString(input.talentAppid, "talentAppid"),
+            }),
+        });
+    },
+    get_product_audit_strategy(_input, context) {
+        return callWechatApi(context, { method: "POST", path: "/channels/ec/product/auditstrategy/get", body: {} });
+    },
+    async list_product_promotion_plans(input, context) {
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        const type = input.promotionPlanType === undefined
+            ? undefined
+            : positiveInteger(input.promotionPlanType, "promotionPlanType", providerInputError);
+        if (![productId, pageIndex].every(Number.isSafeInteger) ||
+            pageSize > 20 ||
+            (type !== undefined && ![100, 200, 300].includes(type))) {
+            throw providerInputError("Ids and pageIndex must be safe positive integers, pageSize at most 20, and promotionPlanType 100, 200 or 300");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promotion/plan/list",
+            body: compactObject({
+                product_id: productId,
+                page_index: pageIndex,
+                page_size: pageSize,
+                promotion_plan_type: type,
+            }),
+        });
+    },
+    async list_league_products(input, context) {
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        const productId = input.productId === undefined ? undefined : positiveInteger(input.productId, "productId", providerInputError);
+        if (!Number.isSafeInteger(pageIndex) ||
+            pageSize > 100 ||
+            pageSize * pageIndex > 5000 ||
+            (productId !== undefined && !Number.isSafeInteger(productId))) {
+            throw providerInputError("Product id must be safe, pageSize at most 100, and pageSize multiplied by pageIndex at most 5000");
+        }
+        if (input.needTotalNum !== undefined && typeof input.needTotalNum !== "boolean") {
+            throw providerInputError("needTotalNum must be a boolean");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/list/get",
+            body: compactObject({
+                page_index: pageIndex,
+                page_size: pageSize,
+                product_id: productId,
+                need_total_num: input.needTotalNum,
+            }),
+        });
+    },
+    async get_league_plan(input, context) {
+        const type = positiveInteger(input.type, "type", providerInputError);
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = input.promotionPlanId === undefined
+            ? undefined
+            : positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        if (![100, 300].includes(type) ||
+            !Number.isSafeInteger(productId) ||
+            (promotionPlanId !== undefined && !Number.isSafeInteger(promotionPlanId))) {
+            throw providerInputError("type must be 100 or 300 and ids must be safe positive integers");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/get",
+            body: compactObject({ type, product_id: productId, promotion_plan_id: promotionPlanId }),
+        });
+    },
+    async invite_league_promoter(input, context) {
+        if ((input.promoterId !== undefined) === (input.finderId !== undefined)) {
+            throw providerInputError("Supply exactly one of promoterId or finderId");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/add",
+            body: input.promoterId !== undefined
+                ? { promoter_id: requiredInputString(input.promoterId, "promoterId") }
+                : { finder_id: requiredInputString(input.finderId, "finderId") },
+        });
+    },
+    async update_league_plan(input, context) {
+        const type = positiveInteger(input.type, "type", providerInputError);
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        const operateType = positiveInteger(input.operateType, "operateType", providerInputError);
+        if (![100, 300].includes(type) ||
+            ![productId, promotionPlanId].every(Number.isSafeInteger) ||
+            ![1, 2, 4].includes(operateType)) {
+            throw providerInputError("type must be 100 or 300, ids safe positive integers, and operateType 1, 2 or 4");
+        }
+        const ratio = optionalNumber(input.ratio);
+        if (operateType === 1
+            ? ratio === undefined || !Number.isFinite(ratio) || ratio < 0 || ratio > 90
+            : input.ratio !== undefined) {
+            throw providerInputError("ratio must be between 0 and 90 for operateType 1 and omitted for operateType 2 or 4");
+        }
+        if (input.exclusiveInfo !== undefined || input.exclusive_info !== undefined) {
+            throw providerInputError("Audience and timing edits are not supported by this action");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/upd",
+            body: compactObject({
+                type,
+                product_id: productId,
+                promotion_plan_id: promotionPlanId,
+                operate_type: operateType,
+                ratio,
+            }),
+        });
+    },
+    async list_league_promoters(input, context) {
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        if (!Number.isSafeInteger(pageIndex) || pageSize > 20) {
+            throw providerInputError("pageIndex must be a safe positive integer and pageSize must be at most 20");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/list/get",
+            body: { page_index: pageIndex, page_size: pageSize },
+        });
+    },
+    async get_league_promoter(input, context) {
+        if ((input.talentAppid !== undefined) === (input.talentSearchKey !== undefined)) {
+            throw providerInputError("Supply exactly one of talentAppid or talentSearchKey");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/get",
+            body: input.talentAppid !== undefined
+                ? { talent_appid: requiredInputString(input.talentAppid, "talentAppid") }
+                : { talent_search_key: requiredInputString(input.talentSearchKey, "talentSearchKey") },
+        });
+    },
+    async get_compass_product_data(input, context) {
+        const date = requiredInputString(input.date, "date");
+        const parsed = /^\d{8}$/.test(date)
+            ? new Date(`${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}T00:00:00Z`)
+            : new Date(Number.NaN);
+        const today = new Intl.DateTimeFormat("en-CA", {
+            timeZone: "Asia/Shanghai",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        })
+            .format(new Date())
+            .replaceAll("-", "");
+        if (!Number.isFinite(parsed.getTime()) ||
+            parsed.toISOString().slice(0, 10).replaceAll("-", "") !== date ||
+            date >= today) {
+            throw providerInputError("date must be a valid YYYYMMDD date, yesterday or earlier in Asia/Shanghai");
+        }
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        if (!Number.isSafeInteger(productId)) {
+            throw providerInputError("productId must be a safe positive integer");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/compass/shop/product/data/get",
+            body: { ds: date, product_id: productId },
+        });
+    },
+    async get_product_restricted_info(input, context) {
+        if (!Array.isArray(input.productIds) || input.productIds.length < 1 || input.productIds.length > 50) {
+            throw providerInputError("productIds must contain 1 to 50 product ids");
+        }
+        const productIds = input.productIds.map((value) => {
+            const id = positiveInteger(value, "productIds", providerInputError);
+            if (!Number.isSafeInteger(id)) {
+                throw providerInputError("productIds must contain only safe positive integers");
+            }
+            return id;
+        });
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/product/getproductrestrictedinfo",
+            body: { product_ids: productIds },
+        });
+    },
     async upload_qualification_image(input, context) {
         const file = await readTransitFileInput(input.file, context);
         if (file.sizeBytes > 2 * 1024 * 1024) {

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

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

package/src/providers/zoom/executors.js

@@ -1,5 +1,6 @@
 import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { fetchZoomCurrentAccount, zoomActionHandlers, zoomApiBaseUrl } from "./runtime.js";
+import { zoomRecordingReady } from "./trigger-on-recording-ready.js";
 const service = "zoom";
 export const executors = defineOAuthProviderExecutors(service, zoomActionHandlers);
 export const proxy = defineProviderProxy({
@@ -13,3 +14,4 @@ export const credentialValidators = {
         return fetchZoomCurrentAccount(input.accessToken, input.metadata, fetcher, signal);
     },
 };
+export const triggers = [zoomRecordingReady];

package/src/providers/zoom/trigger-on-recording-ready.d.ts

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

package/src/providers/zoom/trigger-on-recording-ready.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/zoom/trigger-on-recording-ready.definition.js

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "zoom.on_recording_ready",
+    provider: "zoom",
+    name: "on_recording_ready",
+    displayName: "Cloud Recording Ready",
+    description: "Receives completed cloud recordings hosted by the connected Zoom user through a verified application event source.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["recording.completed"],
+                },
+                minItems: 1,
+                maxItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["recording.completed"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "accountId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "meetingUuid", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/zoom/trigger-on-recording-ready.js

@@ -0,0 +1,39 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { zoomApplication } from "../../triggers/sources/zoom.js";
+import { snapshot } from "./trigger-on-recording-ready.definition.js";
+export const zoomRecordingReady = {
+    snapshot,
+    eventSource: "zoom",
+    source: zoomApplication,
+    async sourceIdentity(context) {
+        const result = await webhookRequest(context, { method: "GET", endpoint: "/users/me" });
+        if (!context.connector.providerAccountId ||
+            !isJsonObject(result.data) ||
+            typeof result.data.id !== "string" ||
+            !result.data.id ||
+            typeof result.data.account_id !== "string" ||
+            !result.data.account_id)
+            throw new PermanentIntegrationError("Zoom did not return a verified user and account identity.");
+        return {
+            accountId: context.connector.providerAccountId,
+            userId: result.data.id,
+            zoomAccountId: result.data.account_id,
+        };
+    },
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Zoom event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Zoom event sources.");
+    },
+};

package/src/server/api/action-example.js

@@ -33,6 +33,14 @@ export function buildExampleInput(schema) {
             }
         }
     }
+    // De Morgan's law exposes positive choices encoded as not(allOf(not(...))).
+    if (isSchemaObject(seedSchema.not) && Array.isArray(seedSchema.not.allOf)) {
+        const members = seedSchema.not.allOf;
+        if (members.length > 0 && members.every((member) => isSchemaObject(member) && isSchemaObject(member.not))) {
+            const choices = members.map((member) => member.not);
+            seedRequirementBranches({ ...seedSchema, not: undefined, anyOf: choices }, properties, input);
+        }
+    }
     applyConditionalRequirements(seedSchema, seedSchema, input);
     return input;
 }
@@ -293,7 +301,10 @@ function stringExample(schema) {
     const minLength = typeof schema.minLength === "number" && schema.minLength > 0 ? schema.minLength : 0;
     const maxLength = typeof schema.maxLength === "number" ? schema.maxLength : undefined;
     if (typeof schema.format === "string") {
-        return formatStringExample(schema.format, minLength, maxLength);
+        const formatted = formatStringExample(schema.format, minLength, maxLength);
+        if (new Validator(schema, "2020-12").validate(formatted).valid) {
+            return formatted;
+        }
     }
     if (typeof schema.pattern === "string") {
         const sample = samplePattern(schema.pattern, { minLength });