@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -1,5 +1,6 @@
 import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { sentryActionHandlers, sentryApiBaseUrl, validateSentryCredential } from "./runtime.js";
+import { sentryIssueAlert } from "./trigger-on-issue-alert.js";
 const service = "sentry";
 export const executors = defineOAuthProviderExecutors(service, sentryActionHandlers);
 export const proxy = defineProviderProxy({
@@ -12,3 +13,4 @@ export const credentialValidators = {
         return validateSentryCredential(input.accessToken, fetcher);
     },
 };
+export const triggers = [sentryIssueAlert];

package/src/providers/sentry/trigger-on-issue-alert.d.ts

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

package/src/providers/sentry/trigger-on-issue-alert.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/sentry/trigger-on-issue-alert.definition.js

@@ -0,0 +1,64 @@
+export const snapshot = {
+    key: "sentry.on_issue_alert",
+    provider: "sentry",
+    name: "on_issue_alert",
+    displayName: "Issue Alert",
+    description: "Receives Issue Alert Rule notifications from a verified Sentry Custom Integration installation.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "projectIds",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", pattern: "^[0-9]+$" },
+                uniqueItems: true,
+                title: "Project IDs",
+            },
+            nullable: true,
+        },
+        {
+            handle: "ruleNames",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                uniqueItems: true,
+                title: "Alert rule names",
+            },
+            nullable: true,
+        },
+        {
+            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: ["issue.alert"],
+                },
+                minItems: 1,
+                maxItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["issue.alert"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "organizationId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "issueId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/sentry/trigger-on-issue-alert.js

@@ -0,0 +1,80 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { sentryApplication } from "../../triggers/sources/sentry.js";
+import { snapshot } from "./trigger-on-issue-alert.definition.js";
+export const sentryIssueAlert = {
+    snapshot,
+    eventSource: "sentry",
+    source: sentryApplication,
+    async sourceIdentity(context) {
+        const accountId = context.connector.providerAccountId;
+        const { appId, installationId, organizationId } = context.config;
+        if (!accountId ||
+            typeof organizationId !== "string" ||
+            !organizationId ||
+            typeof appId !== "string" ||
+            !appId ||
+            typeof installationId !== "string" ||
+            !installationId)
+            throw new PermanentIntegrationError("Sentry requires a verified organization, application UUID and installation UUID.");
+        const organizationResponse = await webhookRequest(context, {
+            method: "GET",
+            endpoint: `/organizations/${encodeURIComponent(organizationId)}/`,
+        });
+        const organization = organizationResponse.data;
+        if (!isJsonObject(organization) || typeof organization.id !== "string" || typeof organization.slug !== "string")
+            throw new PermanentIntegrationError("Invalid Sentry organization response.");
+        const seen = new Set();
+        let cursor;
+        for (;;) {
+            const result = await webhookRequest(context, {
+                method: "GET",
+                endpoint: `/organizations/${encodeURIComponent(organizationId)}/sentry-app-installations/`,
+                query: cursor == null ? {} : { cursor },
+            });
+            if (!Array.isArray(result.data))
+                throw new PermanentIntegrationError("Invalid Sentry installations response.");
+            for (const item of result.data) {
+                if (!isJsonObject(item) || !isJsonObject(item.app) || !isJsonObject(item.organization))
+                    throw new PermanentIntegrationError("Invalid Sentry installation.");
+                if (item.uuid !== installationId)
+                    continue;
+                if (item.app.uuid !== appId || item.status !== "installed" || item.organization.slug !== organization.slug)
+                    throw new PermanentIntegrationError("Sentry integration is not installed in the connected organization.");
+                return {
+                    accountId,
+                    organizationId: organization.id,
+                    organizationSlug: organization.slug,
+                    appId,
+                    installationId,
+                };
+            }
+            const next = (result.headers?.link ?? "")
+                .split(",")
+                .find((link) => /rel="next"/.test(link) && /results="true"/.test(link));
+            if (next == null)
+                break;
+            const match = /cursor="([^"]+)"/.exec(next);
+            if (!match || seen.has(match[1]))
+                throw new PermanentIntegrationError("Invalid Sentry installation pagination.");
+            cursor = match[1];
+            seen.add(cursor);
+        }
+        throw new PermanentIntegrationError("Install the selected Sentry integration in the connected organization first.");
+    },
+    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 Sentry event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Sentry event sources.");
+    },
+};

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

@@ -1,6 +1,5 @@
 import type { CredentialValidationResult } from "../../core/types.ts";
 import type { ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
-export declare const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
 type SfExpressPhase = "validate" | "execute";
 /**
  * The msgDigest algorithm a partnerID is bound to. SF fixes the choice when the
@@ -27,21 +26,6 @@ export declare function optionalFlagNumber(value: unknown): 1 | 0 | undefined;
 /** Read an optional value-added service list (name + value…value4) from action input. */
 export declare function readServiceValueList(value: unknown, fieldName: string): Array<Record<string, unknown>> | undefined;
 export declare function validateSfExpressCredential(values: Record<string, string>, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
-/**
- * Sign one request with the algorithm the application was created against. All
- * three sign the same `msgData + timestamp + checkWord` string and differ only
- * in how they turn it into msgDigest:
- *
- * - `standard_md5` runs it through `URLEncoder.encode(text, "UTF-8")`
- *   first, then Base64(MD5(...)). Skipping that step fails verification for
- *   every payload, because JSON always carries characters the encoder rewrites.
- * - `simple_md5` is the same Base64(MD5(...)) over the raw string.
- * - `sm3` is the lowercase hexadecimal SM3 digest of the raw string.
- *
- * Standard MD5 is the default because SF used it before offering
- * the choice and what every application created back then still uses.
- */
-export declare function signSfExpressPayload(msgData: string, timestamp: string, checkWord: string, algorithm?: SfExpressSignatureAlgorithm): string;
 /**
  * Call one SF Express Open Platform service: POST form-urlencoded with the
  * business JSON in msgData, signed by {@link signSfExpressPayload}. msgData is

package/src/providers/sf_express/runtime.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { compactObject, objectArray, optionalBoolean, optionalNumberLike, optionalRecord, optionalString, } from "../../core/cast.js";
 import { sm3Hex } from "../../core/sm3.js";
 import { parseProviderJsonBodyText, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, readProviderJson, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
-export const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
+const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
 /** The sandbox gateway; every documented sandbox-environment row names this host. */
 const sfExpressSandboxBaseUrl = "https://sfapi-sbox.sf-express.com/std/service";
 /** Endpoints whose production URL differs from the default gateway, per their documented common-parameters sections. */
@@ -157,7 +157,7 @@ function javaFormUrlEncode(value) {
  * Standard MD5 is the default because SF used it before offering
  * the choice and what every application created back then still uses.
  */
-export function signSfExpressPayload(msgData, timestamp, checkWord, algorithm = "standard_md5") {
+function signSfExpressPayload(msgData, timestamp, checkWord, algorithm = "standard_md5") {
     const text = msgData + timestamp + checkWord;
     if (algorithm === "sm3") {
         return sm3Hex(text);

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

@@ -1,4 +1,33 @@
 import type { OAuthClientConfig } from "../../oauth/oauth-client-config-service.ts";
+interface ShopeeSignatureInput {
+    partnerId: number;
+    partnerKey: string;
+    path: string;
+    timestamp: number;
+    accessToken?: string;
+    entityId?: number;
+}
+interface ShopeeRefreshInventoryInput {
+    clientConfig: OAuthClientConfig;
+    providerSecret?: Record<string, unknown>;
+    fallbackRefreshToken: string;
+    fetcher: typeof fetch;
+    now?: Date;
+}
+interface ShopeeTokenRequestInput {
+    clientConfig: OAuthClientConfig;
+    body: Record<string, unknown>;
+    path: "/api/v2/auth/token/get" | "/api/v2/auth/access_token/get";
+    fetcher: typeof fetch;
+    now?: Date;
+}
+interface ShopeeEntityInfoInput {
+    entityType: "shop" | "merchant";
+    entityId: number;
+    accessToken: string;
+    clientConfig: OAuthClientConfig;
+    fetcher: typeof fetch;
+}
 interface ShopeeEntityToken {
     accessToken: string;
     refreshToken: string;
@@ -43,37 +72,12 @@ export interface ShopeeRefreshInventoryResult {
 }
 export declare function resolveShopeeApiBaseUrl(clientConfig: OAuthClientConfig): string;
 export declare function parseShopeePartnerId(clientConfig: OAuthClientConfig): number;
-export declare function createShopeeSignature(input: {
-    partnerId: number;
-    partnerKey: string;
-    path: string;
-    timestamp: number;
-    accessToken?: string;
-    entityId?: number;
-}): string;
+export declare function createShopeeSignature(input: ShopeeSignatureInput): string;
 export declare function parseShopeeToken(payload: ShopeeTokenPayload, now?: Date): ShopeeParsedToken;
 export declare function createInitialShopeeTokenInventory(token: ShopeeParsedToken): ShopeeTokenInventory;
 export declare function readShopeeTokenInventory(providerSecret: Record<string, unknown> | undefined): ShopeeTokenInventory;
-export declare function refreshShopeeTokenInventory(input: {
-    clientConfig: OAuthClientConfig;
-    providerSecret?: Record<string, unknown>;
-    fallbackRefreshToken: string;
-    fetcher: typeof fetch;
-    now?: Date;
-}): Promise<ShopeeRefreshInventoryResult>;
-export declare function requestShopeeToken(input: {
-    clientConfig: OAuthClientConfig;
-    body: Record<string, unknown>;
-    path: "/api/v2/auth/token/get" | "/api/v2/auth/access_token/get";
-    fetcher: typeof fetch;
-    now?: Date;
-}): Promise<ShopeeParsedToken>;
+export declare function refreshShopeeTokenInventory(input: ShopeeRefreshInventoryInput): Promise<ShopeeRefreshInventoryResult>;
+export declare function requestShopeeToken(input: ShopeeTokenRequestInput): Promise<ShopeeParsedToken>;
 export declare function executeShopeeAction(actionName: string, input: Record<string, unknown>, context: ShopeeActionContext): Promise<ShopeeNormalizedResponse>;
-export declare function fetchShopeeEntityInfo(input: {
-    entityType: "shop" | "merchant";
-    entityId: number;
-    accessToken: string;
-    clientConfig: OAuthClientConfig;
-    fetcher: typeof fetch;
-}): Promise<Record<string, unknown>>;
+export declare function fetchShopeeEntityInfo(input: ShopeeEntityInfoInput): Promise<Record<string, unknown>>;
 export {};