@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/feishu_app_bot/trigger-subscriptions.js

@@ -0,0 +1,70 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { feishuResourceKind } from "./trigger-config.js";
+export function feishuSubscriptions(config, provider) {
+    if (config.resource == null)
+        return [];
+    if (!isJsonObject(config.resource))
+        throw new PermanentIntegrationError("Invalid Feishu resource.");
+    const { kind, id, documentType } = config.resource;
+    if (typeof id != "string" || id.length == 0)
+        throw new PermanentIntegrationError("A Feishu resource ID is required.");
+    if (kind != feishuResourceKind(config.eventTypes))
+        throw new PermanentIntegrationError("The selected events do not support this resource subscription.");
+    const resource = encodeURIComponent(id);
+    if (kind == "document") {
+        if (typeof documentType != "string" ||
+            !["doc", "docx", "sheet", "bitable", "file", "folder", "slides"].includes(documentType)) {
+            throw new PermanentIntegrationError("A supported document type is required.");
+        }
+        return config.eventTypes.map((eventType) => {
+            const query = { file_type: documentType, event_type: eventType };
+            const prefix = `/drive/v1/files/${resource}`;
+            return {
+                key: JSON.stringify(["document", documentType, id, eventType]),
+                subscribe: { endpoint: `${prefix}/subscribe`, method: "POST", query },
+                unsubscribe: { endpoint: `${prefix}/delete_subscribe`, method: "DELETE", query },
+                inspect: { endpoint: `${prefix}/get_subscribe`, method: "GET", query },
+            };
+        });
+    }
+    if (kind == "calendar") {
+        const prefix = `/calendar/v4/calendars/${resource}/events`;
+        return [
+            {
+                key: JSON.stringify(["calendar", id]),
+                subscribe: { endpoint: `${prefix}/subscription`, method: "POST" },
+                unsubscribe: { endpoint: `${prefix}/unsubscription`, method: "POST" },
+            },
+        ];
+    }
+    if (kind == "approval") {
+        if (provider != "feishu_app_bot")
+            throw new PermanentIntegrationError("Approval definition subscriptions require an application Connection.");
+        const prefix = `/approval/v4/approvals/${resource}`;
+        return [
+            {
+                key: JSON.stringify(["approval", id]),
+                subscribe: { endpoint: `${prefix}/subscribe`, method: "POST" },
+                unsubscribe: { endpoint: `${prefix}/unsubscribe`, method: "POST" },
+            },
+        ];
+    }
+    throw new PermanentIntegrationError("Unsupported Feishu resource subscription.");
+}
+export function feishuResponse(result) {
+    if (!isJsonObject(result.data))
+        throw new TransientIntegrationError("Feishu returned an invalid response.");
+    const code = result.data.code;
+    if (result.status >= 200 && result.status < 300 && code === 0)
+        return isJsonObject(result.data.data) ? result.data.data : {};
+    const details = `HTTP ${result.status}${typeof code == "number" && Number.isSafeInteger(code) ? `, Feishu code ${code}` : ""}`;
+    if (result.status == 401 ||
+        result.status == 403 ||
+        [99991661, 99991663, 99991668, 99991671, 99991677].includes(Number(code))) {
+        throw new IntegrationConnectionError(`Feishu rejected the Connection (${details}).`);
+    }
+    if (result.status == 429 || result.status >= 500 || code === 99991400)
+        throw new TransientIntegrationError(`Feishu is temporarily unavailable (${details}).`);
+    throw new PermanentIntegrationError(`Feishu rejected the request (${details}). Check the application's API permissions and request parameters.`);
+}

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

@@ -6,6 +6,8 @@ import { releaseActionHandlers } from "./runtime-release.js";
 import { repositoryActionHandlers } from "./runtime-repository.js";
 import { searchActionHandlers } from "./runtime-search.js";
 import { githubApiBaseUrl, githubApiVersion, githubDefaultAcceptHeader, githubRequestJson } from "./runtime-shared.js";
+import { githubRepoEvent } from "./trigger-on-repo-event.js";
+import { githubPullRequestListener } from "./trigger-watch-pull-request.js";
 const service = "github";
 export const executors = defineProviderExecutors({
     service,
@@ -57,3 +59,7 @@ async function validateGitHubToken(accessToken, fetcher) {
         },
     };
 }
+export const triggers = [
+    githubRepoEvent,
+    githubPullRequestListener,
+];

package/src/providers/github/trigger-on-repo-event.d.ts

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

package/src/providers/github/trigger-on-repo-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/github/trigger-on-repo-event.definition.js

@@ -0,0 +1,94 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = [
+    "*",
+    "branch_protection_configuration",
+    "branch_protection_rule",
+    "check_run",
+    "check_suite",
+    "code_scanning_alert",
+    "commit_comment",
+    "create",
+    "custom_property_values",
+    "delete",
+    "dependabot_alert",
+    "deploy_key",
+    "deployment",
+    "deployment_status",
+    "discussion",
+    "discussion_comment",
+    "fork",
+    "gollum",
+    "issue_comment",
+    "issue_dependencies",
+    "issues",
+    "label",
+    "member",
+    "meta",
+    "milestone",
+    "package",
+    "page_build",
+    "project",
+    "project_card",
+    "project_column",
+    "public",
+    "pull_request",
+    "pull_request_review",
+    "pull_request_review_comment",
+    "pull_request_review_thread",
+    "push",
+    "registry_package",
+    "release",
+    "repository",
+    "repository_advisory",
+    "repository_import",
+    "repository_ruleset",
+    "repository_vulnerability_alert",
+    "secret_scanning_alert",
+    "secret_scanning_alert_location",
+    "secret_scanning_scan",
+    "security_and_analysis",
+    "star",
+    "status",
+    "sub_issues",
+    "team_add",
+    "watch",
+    "workflow_job",
+    "workflow_run",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(events), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+        { handle: "insecureSsl", jsonSchema: s.boolean(), nullable: false, value: false },
+        {
+            handle: "owner",
+            jsonSchema: s.string({ pattern: "^[a-zA-Z0-9](?:[a-zA-Z0-9]|-(?=[a-zA-Z0-9])){0,38}$" }),
+            nullable: false,
+        },
+        {
+            handle: "repo",
+            jsonSchema: s.string({ pattern: "^(?!\\.{1,2}$)[a-zA-Z0-9._-]{1,100}$" }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected GitHub webhook events occur in a repository.",
+    displayName: "Repository Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "github.on_repo_event",
+    name: "on_repo_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "github",
+    type: "integration",
+};

package/src/providers/github/trigger-on-repo-event.js

@@ -0,0 +1,168 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-repo-event.definition.js";
+export const githubRepoEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        const signature = context.header("x-hub-signature-256");
+        if (!signature?.startsWith("sha256=") ||
+            !(await verifyHexHmac(context.callbackSecret, [context.rawBody], signature.slice(7)))) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const event = context.header("x-github-event")?.trim();
+        if (!event)
+            return { outcome: "ignored", reason: "GitHub event header is missing." };
+        if (event == "ping")
+            return { outcome: "ignored", reason: "GitHub ping handshake." };
+        const config = resolveConfig(context.config);
+        if (!config.events.includes("*") && !config.events.includes(event)) {
+            return { outcome: "ignored", reason: "GitHub event is not subscribed." };
+        }
+        const deliveryId = context.header("x-github-delivery") ?? "";
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: { body: context.payload, deliveryId, event },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        let hookId = subscriptionId(state);
+        if (!context.active) {
+            if (hookId == null)
+                hookId = await findByUrl(context, config);
+            if (hookId != null) {
+                const result = await request(context, "hook delete", {
+                    endpoint: `${endpoint(config)}/${hookId}`,
+                    method: "DELETE",
+                });
+                if (result.status != 404)
+                    success(result, "hook delete");
+            }
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const desired = body(context.endpointUrl, context.callbackSecret, config);
+        if (hookId == null) {
+            const result = await request(context, "hook create", {
+                body: desired,
+                endpoint: endpoint(config),
+                method: "POST",
+            });
+            if (result.status == 201)
+                hookId = id(result.data);
+            else if (result.status == 422) {
+                hookId = await findByUrl(context, config);
+                if (hookId == null)
+                    throw new PermanentIntegrationError("GitHub rejected the webhook configuration.");
+            }
+            else {
+                success(result, "hook create");
+                throw new TransientIntegrationError(`GitHub hook create returned unexpected status ${result.status}.`);
+            }
+        }
+        await state.saveSubscription({ hookId }, context.now);
+        const aligned = await request(context, "hook update", {
+            body: desired,
+            endpoint: `${endpoint(config)}/${hookId}`,
+            method: "PATCH",
+        });
+        if (aligned.status == 404) {
+            await state.saveSubscription({}, context.now);
+            return { outcome: "pending" };
+        }
+        success(aligned, "hook update");
+        await state.saveSubscription({ hookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: [...new Set(value.events)],
+        insecureSsl: value.insecureSsl,
+        owner: value.owner,
+        repo: value.repo,
+    };
+}
+function endpoint(config) {
+    return `/repos/${encodeURIComponent(config.owner)}/${encodeURIComponent(config.repo)}/hooks`;
+}
+function body(url, secret, config) {
+    return {
+        active: true,
+        config: { content_type: "json", insecure_ssl: config.insecureSsl ? "1" : "0", secret, url },
+        events: config.events,
+        name: "web",
+    };
+}
+async function findByUrl(context, config) {
+    for (let page = 1; page <= 10; page += 1) {
+        const result = await request(context, "hook list", {
+            endpoint: endpoint(config),
+            method: "GET",
+            query: { page, per_page: 100 },
+        });
+        if (result.status == 404)
+            return null;
+        success(result, "hook list");
+        const hooks = Array.isArray(result.data) ? result.data : [];
+        for (const hook of hooks) {
+            const value = record(hook);
+            if (record(value?.config)?.url === context.endpointUrl &&
+                (typeof value?.id == "number" || typeof value?.id == "string")) {
+                return String(value.id);
+            }
+        }
+        if (hooks.length < 100)
+            return null;
+    }
+    return null;
+}
+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(`GitHub ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const message = record(result.data)?.message;
+    if (result.status == 403 && typeof message == "string" && /rate limit/i.test(message)) {
+        throw new TransientIntegrationError(`GitHub ${operation} was rate limited.`);
+    }
+    if ([401, 403].includes(result.status))
+        throw new IntegrationConnectionError(`GitHub ${operation} rejected the Connection.`);
+    if ([404, 422].includes(result.status))
+        throw new PermanentIntegrationError(`GitHub ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`GitHub ${operation} failed with status ${result.status}.`);
+}
+function id(data) {
+    const value = record(data)?.id;
+    if (typeof value != "number" && typeof value != "string")
+        throw new TransientIntegrationError("GitHub hook response is missing its ID.");
+    return String(value);
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("GitHub Integration state is missing.");
+    return value;
+}
+function subscriptionId(state) {
+    const value = state.subscription.hookId;
+    return typeof value == "string" && value.length > 0 ? value : null;
+}
+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/github/trigger-watch-pull-request.d.ts

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

package/src/providers/github/trigger-watch-pull-request.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/github/trigger-watch-pull-request.definition.js

@@ -0,0 +1,49 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { snapshot as githubRepoEventSnapshot } from "./trigger-on-repo-event.definition.js";
+const pullRequestSchema = s.object({
+    id: s.integer(),
+    number: s.integer(),
+    title: s.string(),
+    url: s.string(),
+    state: s.stringEnum(["open", "closed"]),
+    draft: s.boolean(),
+    merged: s.boolean(),
+    updatedAt: s.string(),
+    headSha: s.string(),
+    baseSha: s.string(),
+}, {
+    additionalProperties: false,
+    required: ["id", "number", "title", "url", "state", "draft", "merged", "updatedAt", "headSha", "baseSha"],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "owner",
+            jsonSchema: s.string({ pattern: "^[a-zA-Z0-9](?:[a-zA-Z0-9]|-(?=[a-zA-Z0-9])){0,38}$" }),
+            nullable: false,
+        },
+        {
+            handle: "repo",
+            jsonSchema: s.string({ pattern: "^(?!\\.{1,2}$)[a-zA-Z0-9._-]{1,100}$" }),
+            nullable: false,
+        },
+        {
+            handle: "number",
+            jsonSchema: s.integer({ minimum: 1 }),
+            nullable: false,
+            description: "Number of the pull request to watch.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Watches one pull request using notifications and periodic checks. Starts from its current state; reports observed changes, not every intermediate transition or review event.",
+    displayName: "Watch Pull Request",
+    endpoint: githubRepoEventSnapshot.endpoint,
+    key: "github.watch_pull_request",
+    name: "watch_pull_request",
+    provider: "github",
+    type: "integration",
+    outputs: [
+        { handle: "pullRequest", jsonSchema: pullRequestSchema, nullable: false },
+        { handle: "version", jsonSchema: s.string(), nullable: false },
+    ],
+};

package/src/providers/github/trigger-watch-pull-request.js

@@ -0,0 +1,106 @@
+import { canonicalJsonBytes, digestBytes } from "../../triggers/common/encoding.js";
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { githubRepoEvent } from "./trigger-on-repo-event.js";
+import { snapshot } from "./trigger-watch-pull-request.definition.js";
+function hookConfig(config) {
+    return { owner: config.owner, repo: config.repo, events: ["pull_request"], insecureSsl: false };
+}
+export const githubPullRequestListener = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        if (context.state == null)
+            throw new PermanentIntegrationError("GitHub listener state is missing.");
+        if (context.active && context.state.checkpoint == null) {
+            const current = await readPullRequest(context);
+            await context.state.saveCheckpoint({ version: current.version, sequence: 0 });
+        }
+        return await githubRepoEvent.reconcile({ ...context, config: hookConfig(context.config) });
+    },
+    async receive(context) {
+        const received = await githubRepoEvent.receive({
+            ...context,
+            config: hookConfig(context.config),
+        });
+        if (received.outcome != "event")
+            return received;
+        if (!isJsonObject(context.payload) || context.payload.number !== context.config.number)
+            return { outcome: "ignored", reason: "Different pull request." };
+        return { outcome: "wake" };
+    },
+    listener: {
+        intervalMs: 300_000,
+        async read(context) {
+            const checkpoint = context.checkpoint;
+            if (!isJsonObject(checkpoint) ||
+                typeof checkpoint.version != "string" ||
+                !Number.isSafeInteger(checkpoint.sequence) ||
+                Number(checkpoint.sequence) < 0 ||
+                Number(checkpoint.sequence) >= Number.MAX_SAFE_INTEGER) {
+                throw new PermanentIntegrationError("GitHub listener checkpoint is invalid.");
+            }
+            const current = await readPullRequest(context);
+            if (current.version == checkpoint.version)
+                return { checkpoint, dedupeKey: current.version, hasMore: false, outputs: null };
+            const sequence = Number(checkpoint.sequence) + 1;
+            return {
+                checkpoint: { version: current.version, sequence },
+                dedupeKey: `${sequence}:${current.version}`,
+                hasMore: false,
+                outputs: current,
+            };
+        },
+    },
+};
+async function readPullRequest(context) {
+    const { owner, repo, number } = context.config;
+    if (typeof owner != "string" || typeof repo != "string" || !Number.isSafeInteger(number) || Number(number) < 1)
+        throw new PermanentIntegrationError("GitHub pull request configuration is invalid.");
+    const result = await context.connector.execute({
+        endpoint: `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}`,
+        method: "GET",
+    }, context.signal);
+    context.signal?.throwIfAborted();
+    const value = result.data;
+    if (result.status == 429 ||
+        (result.status == 403 &&
+            isJsonObject(value) &&
+            typeof value.message == "string" &&
+            /rate limit/i.test(value.message)))
+        throw new TransientIntegrationError("GitHub pull request checks were rate limited.");
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError("GitHub pull request access requires authorization.");
+    if (result.status == 404)
+        throw new PermanentIntegrationError("The pull request is unavailable; it may no longer be accessible.");
+    if (result.status != 200)
+        throw new TransientIntegrationError(`GitHub pull request check failed with status ${result.status}.`);
+    if (!isJsonObject(value) ||
+        !Number.isSafeInteger(value.id) ||
+        value.number !== number ||
+        typeof value.title != "string" ||
+        typeof value.html_url != "string" ||
+        (value.state != "open" && value.state != "closed") ||
+        typeof value.draft != "boolean" ||
+        typeof value.merged != "boolean" ||
+        typeof value.updated_at != "string" ||
+        !Number.isFinite(Date.parse(value.updated_at)) ||
+        !isJsonObject(value.head) ||
+        typeof value.head.sha != "string" ||
+        !isJsonObject(value.base) ||
+        typeof value.base.sha != "string")
+        throw new TransientIntegrationError("GitHub returned an invalid pull request.");
+    const pullRequest = {
+        id: Number(value.id),
+        number: Number(number),
+        title: value.title,
+        url: value.html_url,
+        state: value.state,
+        draft: value.draft,
+        merged: value.merged,
+        updatedAt: value.updated_at,
+        headSha: value.head.sha,
+        baseSha: value.base.sha,
+    };
+    return { pullRequest, version: await digestBytes(canonicalJsonBytes(pullRequest)) };
+}

package/src/providers/gitlab/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";
 type GitlabActionInput = Record<string, unknown>;
 type GitlabActionHandler = (input: GitlabActionInput, context: GitlabActionContext) => Promise<unknown>;
@@ -23,4 +25,5 @@ export declare const credentialValidators: CredentialValidators;
  * `allowPrivateNetwork` may be passed explicitly (used by tests).
  */
 export declare function normalizeGitlabApiBaseUrl(value: unknown, allowPrivateNetwork?: boolean): string;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/gitlab/executors.js

@@ -1,6 +1,7 @@
 import { compactObject, optionalBoolean, optionalIntegerLike, optionalRecord, optionalString as asOptionalString, recordOrEmpty, } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
 import { createProviderFetch, defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { gitlabProjectEvent } from "./trigger-on-project-event.js";
 const defaultGitlabApiBaseUrl = "https://gitlab.com/api/v4";
 const service = "gitlab";
 export const gitlabActionHandlers = {
@@ -515,3 +516,4 @@ function asOptionalPositiveInteger(value, fieldName) {
     }
     return parsed;
 }
+export const triggers = [gitlabProjectEvent];

package/src/providers/gitlab/trigger-on-project-event.d.ts

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

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

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

package/src/providers/gitlab/trigger-on-project-event.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = [
+    "push",
+    "tag_push",
+    "issues",
+    "confidential_issues",
+    "note",
+    "confidential_note",
+    "merge_requests",
+    "job",
+    "pipeline",
+    "wiki_page",
+    "deployment",
+    "feature_flag",
+    "releases",
+    "milestone",
+    "emoji",
+    "resource_access_token",
+    "resource_deploy_token",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(events), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+        { handle: "insecureSsl", jsonSchema: s.boolean(), nullable: false, value: false },
+        {
+            handle: "project",
+            jsonSchema: s.string({
+                maxLength: 255,
+                minLength: 1,
+                pattern: "^(?:[0-9]+|(?!\\.{1,2}(?:/|$))[A-Za-z0-9_.][A-Za-z0-9_.-]*(?:/(?!\\.{1,2}(?:/|$))[A-Za-z0-9_.][A-Za-z0-9_.-]*)*)$",
+            }),
+            nullable: false,
+        },
+        {
+            handle: "pushBranchFilter",
+            jsonSchema: s.string({ maxLength: 255 }),
+            nullable: false,
+            value: "",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected GitLab webhook events occur in a project.",
+    displayName: "Project Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "gitlab.on_project_event",
+    name: "on_project_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "gitlabEvent", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "gitlab",
+    type: "integration",
+};