@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/indexed/runtime.js

@@ -0,0 +1,129 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment, queryParams } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerUserAgent, ProviderRequestError, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const indexedApiBaseUrl = "https://indexed.vc/api/v1";
+export const indexedActionHandlers = {
+    lookup_company_by_domain(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: { domain: requiredInputString(input.domain, "domain") },
+        });
+    },
+    lookup_companies_by_domains(input, context) {
+        return requestIndexed({ context, path: "/companies/lookup", body: { domains: input.domains } });
+    },
+    search_companies(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: {
+                q: optionalString(input.q),
+                industries: joinList(input.industries),
+                countries: joinList(input.countries),
+                employees: joinList(input.employees),
+                operatingStatus: joinList(input.operatingStatus),
+                minFunding: optionalInteger(input.minFunding),
+                maxFunding: optionalInteger(input.maxFunding),
+                minCompleteness: optionalInteger(input.minCompleteness),
+                updated_since: optionalString(input.updatedSince),
+                reveal_status: optionalString(input.revealStatus),
+                sort: optionalString(input.sort),
+                order: optionalString(input.order),
+                page: optionalInteger(input.page),
+                limit: optionalInteger(input.limit),
+                cursor: optionalString(input.cursor),
+            },
+        });
+    },
+    get_company(input, context) {
+        return requestIndexed({
+            context,
+            path: `/companies/${encodePathSegment(requiredInputString(input.slug, "slug"))}`,
+            query: { depth: optionalString(input.depth) },
+        });
+    },
+};
+/**
+ * Validate a key with GET /usage, which the API documents as free of credit charges.
+ */
+export async function validateIndexedCredential(input, options) {
+    const payload = await requestIndexed({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        path: "/usage",
+        phase: "validate",
+    });
+    const usage = optionalRecord(payload.data);
+    const tier = optionalString(usage?.tier);
+    return {
+        profile: {
+            accountId: "indexed",
+            displayName: tier ? `Indexed API Key (${tier} plan)` : "Indexed API Key",
+        },
+        grantedScopes: [],
+        metadata: compactObject({
+            apiBaseUrl: indexedApiBaseUrl,
+            validationEndpoint: "/usage",
+            tier,
+            creditsRemaining: optionalInteger(usage?.credits_remaining),
+        }),
+    };
+}
+function joinList(value) {
+    return Array.isArray(value) && value.length > 0 ? value.join(",") : undefined;
+}
+async function requestIndexed(input) {
+    const { context } = input;
+    const url = new URL(`${indexedApiBaseUrl}${input.path}`);
+    for (const [key, value] of Object.entries(queryParams(input.query ?? {}))) {
+        url.searchParams.set(key, value);
+    }
+    return runProviderRequest({ signal: context.signal, label: "Indexed" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: input.body ? "POST" : "GET",
+            headers: compactObject({
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+                "content-type": input.body ? "application/json" : undefined,
+            }),
+            body: input.body ? JSON.stringify(input.body) : undefined,
+            signal,
+        });
+        if (!response.ok) {
+            throw await readIndexedError(response, input.phase ?? "execute");
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "Indexed response"), {
+            emptyBody: {},
+            invalidJsonMessage: "Indexed returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "Indexed response");
+    });
+}
+/**
+ * Read an Indexed error response and map it onto the runtime's status conventions.
+ * 402 is a billing state (credits exhausted), reported as insufficient_credit.
+ * 403 TIER_UPGRADE_REQUIRED is a plan limit rather than a credential failure, so
+ * it is reported as invalid input instead of prompting a reconnect. During key
+ * validation a 401 or 403 is a field error on the submitted key. Every other
+ * status keeps its upstream value, so a 404 stays a not-found result.
+ */
+export async function readIndexedError(response, phase = "execute") {
+    const status = response.status;
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "Indexed error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "Indexed returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const body = optionalRecord(payload);
+    const message = optionalString(body?.error) ?? `Indexed request failed with HTTP ${status}`;
+    const details = withRetryAfterSeconds(response, payload);
+    if (status === 402) {
+        return new ProviderRequestError(402, message, details, "insufficient_credit");
+    }
+    if ((status === 401 || status === 403) &&
+        (phase === "validate" || optionalString(body?.code) === "TIER_UPGRADE_REQUIRED")) {
+        return new ProviderRequestError(400, message, details);
+    }
+    return new ProviderRequestError(status, message, details);
+}

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

@@ -1,4 +1,6 @@
 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";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 interface LinearActionContext {
     authorization: string;
@@ -10,4 +12,5 @@ export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
 export declare function fetchLinearViewer(authorization: string, fetcher: typeof fetch): Promise<Record<string, unknown>>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/linear/executors.js

@@ -1,5 +1,6 @@
 import { compactObject, optionalBoolean } from "../../core/cast.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { linearIssueChanged } from "./trigger-on-issue-changed.js";
 const linearApiBaseUrl = "https://api.linear.app";
 const linearGraphqlUrl = "https://api.linear.app/graphql";
 const linearFetch = createProviderFetch({ skipDnsValidation: true });
@@ -1904,3 +1905,4 @@ function asOptionalObject(value) {
     }
     return value;
 }
+export const triggers = [linearIssueChanged];

package/src/providers/linear/trigger-on-issue-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const linearIssueChanged: PollDefinition;

package/src/providers/linear/trigger-on-issue-changed.definition.d.ts

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

package/src/providers/linear/trigger-on-issue-changed.definition.js

@@ -0,0 +1,43 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const uuidPattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+const issueSchema = s.object({
+    id: s.string(),
+    identifier: s.string(),
+    title: s.string(),
+    url: s.string(),
+    teamId: s.string(),
+    createdAt: s.string(),
+    updatedAt: s.string(),
+    state: s.object({ id: s.string(), name: s.string(), type: s.string() }, { additionalProperties: false, required: ["id", "name", "type"] }),
+}, {
+    additionalProperties: false,
+    required: ["id", "identifier", "title", "url", "teamId", "createdAt", "updatedAt", "state"],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "teamId",
+            jsonSchema: { ...s.string({ pattern: uuidPattern }), title: "Team ID" },
+            nullable: false,
+            description: "Linear Team UUID. Use Copy model UUID in Linear to find it.",
+        },
+        {
+            handle: "stateIds",
+            jsonSchema: {
+                ...s.array(s.string({ pattern: uuidPattern }), { uniqueItems: true, maxItems: 50 }),
+                title: "Issue statuses",
+            },
+            nullable: false,
+            value: [],
+            description: "Choose statuses from the selected Team. Empty means all statuses. Matches the current status, not every transition into it.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Watches new and updated issues in a Linear team with periodic checks. Starts from now without running existing issues. Reports observed current states, not deletions or every intermediate status change.",
+    displayName: "Issue Created or Updated",
+    key: "linear.on_issue_changed",
+    name: "on_issue_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(issueSchema), nullable: false }],
+    provider: "linear",
+    type: "poll",
+};

package/src/providers/linear/trigger-on-issue-changed.js

@@ -0,0 +1,215 @@
+import { isJsonObject } from "../../triggers/common/json.js";
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot, uuidPattern } from "./trigger-on-issue-changed.definition.js";
+const uuid = new RegExp(uuidPattern);
+const overlapMs = 60_000;
+const pageSize = 50;
+export const linearIssueChanged = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    configOptions: options,
+    async poll(context) {
+        const teamId = typeof context.config.teamId == "string" ? context.config.teamId.toLowerCase() : context.config.teamId;
+        const stateIds = context.config.stateIds;
+        if (typeof teamId != "string" ||
+            !uuid.test(teamId) ||
+            !Array.isArray(stateIds) ||
+            stateIds.length > 50 ||
+            stateIds.some((name) => typeof name != "string" || !uuid.test(name)))
+            throw new PermanentPollError("Linear Issue configuration is invalid.");
+        if (context.checkpoint == null) {
+            const data = await query(context, "query LinearTeam($teamId: String!) { team(id: $teamId) { id } }", { teamId });
+            requireTeam(data.team, teamId);
+            const startedAt = context.now.toISOString();
+            return { checkpoint: { startedAt, since: startedAt }, events: [] };
+        }
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const until = checkpoint.until ?? new Date(Math.max(context.now.getTime(), Date.parse(checkpoint.since))).toISOString();
+        const since = new Date(Math.max(Date.parse(checkpoint.startedAt), Date.parse(checkpoint.since) - overlapMs)).toISOString();
+        const data = await query(context, `query LinearIssueChanges($teamId: String!, $filter: IssueFilter!, $after: String) {
+      team(id: $teamId) {
+        id
+        issues(first: ${pageSize}, after: $after, orderBy: updatedAt, includeArchived: true, filter: $filter) {
+          nodes { id identifier title url createdAt updatedAt state { id name type } }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }`, {
+            teamId,
+            after: checkpoint.after ?? null,
+            filter: {
+                updatedAt: { gte: since, lte: until },
+                ...(stateIds.length == 0 ? {} : { state: { id: { in: stateIds } } }),
+            },
+        });
+        const team = requireTeam(data.team, teamId);
+        const page = team.issues;
+        if (!isJsonObject(page) ||
+            !Array.isArray(page.nodes) ||
+            page.nodes.length > pageSize ||
+            !isJsonObject(page.pageInfo) ||
+            typeof page.pageInfo.hasNextPage != "boolean") {
+            throw new TransientPollError("Linear returned an invalid Issue page.");
+        }
+        const { hasNextPage, endCursor } = page.pageInfo;
+        if (hasNextPage &&
+            (typeof endCursor != "string" ||
+                endCursor.length == 0 ||
+                endCursor.length > 4096 ||
+                endCursor == checkpoint.after ||
+                page.nodes.length == 0)) {
+            throw new TransientPollError("Linear returned an invalid continuation cursor.");
+        }
+        const events = page.nodes.map((value) => {
+            if (!isJsonObject(value) ||
+                typeof value.id != "string" ||
+                !uuid.test(value.id) ||
+                typeof value.identifier != "string" ||
+                value.identifier.length == 0 ||
+                typeof value.title != "string" ||
+                typeof value.url != "string" ||
+                !timestamp(value.createdAt) ||
+                !timestamp(value.updatedAt) ||
+                Date.parse(value.createdAt) > Date.parse(value.updatedAt) ||
+                Date.parse(value.updatedAt) < Date.parse(since) ||
+                Date.parse(value.updatedAt) > Date.parse(until) ||
+                !isJsonObject(value.state) ||
+                typeof value.state.id != "string" ||
+                !uuid.test(value.state.id) ||
+                typeof value.state.name != "string" ||
+                typeof value.state.type != "string" ||
+                (stateIds.length > 0 && !stateIds.includes(value.state.id)))
+                throw new TransientPollError("Linear returned an invalid Issue.");
+            return {
+                dedupeKey: `${value.id}:${value.updatedAt}`,
+                payload: {
+                    id: value.id,
+                    identifier: value.identifier,
+                    title: value.title,
+                    url: value.url,
+                    teamId,
+                    createdAt: value.createdAt,
+                    updatedAt: value.updatedAt,
+                    state: { id: value.state.id, name: value.state.name, type: value.state.type },
+                },
+            };
+        });
+        return {
+            checkpoint: hasNextPage
+                ? { ...checkpoint, until, after: endCursor }
+                : { startedAt: checkpoint.startedAt, since: until },
+            events,
+            hasMore: hasNextPage,
+        };
+    },
+};
+function readCheckpoint(value) {
+    if (!isJsonObject(value) ||
+        !timestamp(value.startedAt) ||
+        !timestamp(value.since) ||
+        Date.parse(value.since) < Date.parse(value.startedAt) ||
+        (value.until != null && (!timestamp(value.until) || Date.parse(value.until) < Date.parse(value.since))) ||
+        (value.after != null &&
+            (typeof value.after != "string" || value.after.length == 0 || value.after.length > 4096 || value.until == null)))
+        throw new PermanentPollError("Linear Issue checkpoint is invalid.");
+    return {
+        startedAt: value.startedAt,
+        since: value.since,
+        ...(typeof value.until == "string" ? { until: value.until } : {}),
+        ...(typeof value.after == "string" ? { after: value.after } : {}),
+    };
+}
+function timestamp(value) {
+    return (typeof value == "string" &&
+        value.length <= 40 &&
+        /^\d{4}-\d{2}-\d{2}T/.test(value) &&
+        Number.isFinite(Date.parse(value)));
+}
+function requireTeam(value, teamId) {
+    if (value === null)
+        throw new PermanentPollError("The Linear team is unavailable or not accessible to this Connection.");
+    if (!isJsonObject(value) || value.id !== teamId)
+        throw new TransientPollError("Linear returned an invalid Team.");
+    return value;
+}
+async function query(context, document, variables) {
+    context.signal?.throwIfAborted();
+    const result = await context.connector.execute({ endpoint: "/graphql", method: "POST", body: { query: document, variables } }, context.signal);
+    context.signal?.throwIfAborted();
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError("Linear Issue access requires authorization.");
+    if (result.status == 429)
+        throw new TransientPollError("Linear Issue checks were rate limited.");
+    const body = result.data;
+    if (isJsonObject(body) && Array.isArray(body.errors) && body.errors.length > 0) {
+        const codes = new Set(body.errors.flatMap((error) => isJsonObject(error) && isJsonObject(error.extensions) ? [error.extensions.code] : []));
+        if (codes.has("UNAUTHENTICATED") || codes.has("FORBIDDEN") || codes.has("AUTHENTICATION_ERROR")) {
+            throw new PollConnectionError("Linear Issue access requires authorization.");
+        }
+        if (codes.has("RATELIMITED"))
+            throw new TransientPollError("Linear Issue checks were rate limited.");
+        if (codes.has("GRAPHQL_VALIDATION_FAILED") || codes.has("BAD_USER_INPUT"))
+            throw new PermanentPollError("Linear rejected the Issue query configuration.");
+        throw new TransientPollError("Linear Issue query failed; progress was retained.");
+    }
+    if (result.status != 200 ||
+        !isJsonObject(body) ||
+        !isJsonObject(body.data) ||
+        (body.errors != null && !Array.isArray(body.errors))) {
+        throw new TransientPollError(`Linear returned an invalid query response (HTTP ${result.status}).`);
+    }
+    return body.data;
+}
+async function options(context) {
+    const { field, config } = context;
+    if (field != "teamId" && field != "stateIds")
+        throw new PermanentPollError("Unknown Linear configuration field.");
+    if (field == "stateIds" && (typeof config.teamId != "string" || !uuid.test(config.teamId)))
+        throw new PermanentPollError("Select a Linear Team first.");
+    const choices = [];
+    const cursors = new Set();
+    let after = null;
+    for (let page = 0; page < 10; page++) {
+        const data = await query(context, field == "teamId"
+            ? "query LinearTeams($after: String) { teams(first: 100, after: $after) { nodes { id name key } pageInfo { hasNextPage endCursor } } }"
+            : "query LinearStates($teamId: String!, $after: String) { team(id: $teamId) { id states(first: 100, after: $after) { nodes { id name color position } pageInfo { hasNextPage endCursor } } } }", { after, ...(field == "teamId" ? {} : { teamId: config.teamId }) });
+        const values = field == "teamId" ? data.teams : requireTeam(data.team, String(config.teamId)).states;
+        if (!isJsonObject(values) ||
+            !Array.isArray(values.nodes) ||
+            values.nodes.length > 100 ||
+            !isJsonObject(values.pageInfo) ||
+            typeof values.pageInfo.hasNextPage != "boolean") {
+            throw new TransientPollError("Linear returned invalid configuration options.");
+        }
+        for (const item of values.nodes) {
+            if (!isJsonObject(item) ||
+                typeof item.id != "string" ||
+                !uuid.test(item.id) ||
+                typeof item.name != "string" ||
+                item.name.length == 0 ||
+                (field == "teamId"
+                    ? typeof item.key != "string"
+                    : typeof item.color != "string" || !/^#[0-9a-fA-F]{6}$/.test(item.color))) {
+                throw new TransientPollError("Linear returned an invalid configuration option.");
+            }
+            choices.push({
+                value: item.id,
+                label: field == "teamId" ? `${item.name} (${item.key})` : item.name,
+                ...(field == "stateIds" ? { color: String(item.color) } : {}),
+            });
+        }
+        if (!values.pageInfo.hasNextPage)
+            return choices;
+        const cursor = values.pageInfo.endCursor;
+        if (typeof cursor != "string" ||
+            cursor.length == 0 ||
+            cursor.length > 4096 ||
+            cursors.has(cursor) ||
+            values.nodes.length == 0) {
+            throw new TransientPollError("Linear returned an invalid options cursor.");
+        }
+        cursors.add(cursor);
+        after = cursor;
+    }
+    throw new PermanentPollError("The Linear options list exceeds the supported limit of 1000 entries.");
+}

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

@@ -1,4 +1,6 @@
 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";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 interface NotionActionContext {
     accessToken: string;
@@ -18,4 +20,5 @@ export declare const notionActionHandlers: ProviderActionHandlers<"notion", Noti
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/notion/executors.js

@@ -1,5 +1,6 @@
 import { compactObject } from "../../core/cast.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireBearerCredential, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { notionDatabasePageEvent } from "./trigger-on-database-page-event.js";
 const service = "notion";
 const notionApiBaseUrl = "https://api.notion.com/v1";
 const notionFetch = createProviderFetch({ skipDnsValidation: true });
@@ -805,3 +806,4 @@ function asNumber(value) {
 function asNonEmptyString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+export const triggers = [notionDatabasePageEvent];

package/src/providers/notion/trigger-on-database-page-event.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const notionDatabasePageEvent: PollDefinition;

package/src/providers/notion/trigger-on-database-page-event.definition.d.ts

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

package/src/providers/notion/trigger-on-database-page-event.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const idPattern = "^[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$";
+const eventSchema = s.object({
+    createdBy: { type: "object" },
+    createdTime: s.string(),
+    dataSourceId: s.string(),
+    databaseId: s.string(),
+    event: s.stringEnum(["page_added", "page_updated"]),
+    lastEditedBy: { type: "object" },
+    lastEditedTime: s.string(),
+    pageId: s.string(),
+    properties: { type: "object" },
+    title: s.string(),
+    url: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "event",
+        "pageId",
+        "databaseId",
+        "dataSourceId",
+        "url",
+        "title",
+        "createdTime",
+        "lastEditedTime",
+        "createdBy",
+        "lastEditedBy",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "dataSourceId",
+            jsonSchema: s.string({
+                pattern: "^(?:|[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12})$",
+            }),
+            nullable: false,
+            value: "",
+        },
+        { handle: "databaseId", jsonSchema: s.string({ pattern: idPattern }), nullable: false },
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(["page_added", "page_updated"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["page_added"],
+        },
+        { handle: "includeProperties", jsonSchema: s.boolean(), nullable: false, value: true },
+        {
+            handle: "maxItemsPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: 25,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls a Notion database and triggers when a page is added to it or an existing page is edited.",
+    displayName: "Database Page Added or Updated",
+    key: "notion.on_database_page_event",
+    name: "on_database_page_event",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "notion",
+    type: "poll",
+};