@bpmn-sdk/connector-gen 0.0.1

package/dist/build-template.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectorTemplate, GeneratorOptions, OperationWithMeta } from "./types.js";
+export declare function buildTemplate(op: OperationWithMeta, opts: GeneratorOptions): ConnectorTemplate;
+export declare function buildTemplates(ops: OperationWithMeta[], opts: GeneratorOptions): ConnectorTemplate[];
+//# sourceMappingURL=build-template.d.ts.map

package/dist/build-template.js

@@ -0,0 +1,513 @@
+import { CONNECTOR_SCHEMA as SCHEMA_URL } from "./types.js";
+// ─── Slugify / ID helpers ──────────────────────────────────────────────────────
+function slugify(s) {
+    return s
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+}
+function operationName(op) {
+    if (op.operation.operationId)
+        return op.operation.operationId;
+    // Fallback: METHOD_path_segments
+    const segs = op.path
+        .split("/")
+        .filter(Boolean)
+        .map((s) => s.replace(/[{}]/g, ""));
+    return `${op.method}_${segs.join("_")}`;
+}
+function toDisplayName(id) {
+    // "listRepoIssues" → "List Repo Issues"; "list-repo-issues" → "List Repo Issues"
+    return id
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/[-_]+/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase())
+        .trim();
+}
+// ─── FEEL URL construction ────────────────────────────────────────────────────
+/**
+ * Build the URL value and whether it needs FEEL.
+ * For paths with parameters (e.g. /repos/{owner}/{repo}), returns a FEEL expression
+ * and feel="optional" so it's visible and editable in the modeler.
+ */
+function buildUrlField(op) {
+    const base = op.baseUrl;
+    const hasPathParams = op.pathParams.length > 0;
+    if (!hasPathParams) {
+        return {
+            type: "Hidden",
+            value: `${base}${op.path}`,
+            binding: { type: "zeebe:input", name: "url" },
+        };
+    }
+    // Build FEEL expression: ="https://api/repos/" + owner + "/" + repo + "/issues"
+    const parts = op.path.split(/(\{[^}]+\})/);
+    const feelParts = parts.map((part) => {
+        const match = /^\{([^}]+)\}$/.exec(part);
+        if (match) {
+            const paramName = match[1] ?? part.slice(1, -1);
+            return paramName; // variable reference
+        }
+        const segment = `${base}${part}`;
+        return JSON.stringify(segment); // string literal
+    });
+    // Filter out empty string literals
+    const nonEmpty = feelParts.filter((p) => p !== '""');
+    const feelExpr = `=${nonEmpty.join(" + ")}`;
+    return {
+        label: "URL",
+        type: "String",
+        value: feelExpr,
+        group: "endpoint",
+        feel: "optional",
+        binding: { type: "zeebe:input", name: "url" },
+        constraints: { notEmpty: true },
+    };
+}
+// ─── Path parameter fields ────────────────────────────────────────────────────
+function buildPathParamField(param) {
+    return {
+        id: param.name,
+        label: toDisplayName(param.name),
+        description: param.description,
+        type: "String",
+        group: "endpoint",
+        feel: "optional",
+        binding: { type: "zeebe:input", name: param.name },
+        constraints: param.required !== false ? { notEmpty: true } : undefined,
+    };
+}
+// ─── Query parameter field ────────────────────────────────────────────────────
+function buildQueryParamsField(queryParams) {
+    if (queryParams.length === 0) {
+        return {
+            label: "Query parameters",
+            type: "Text",
+            group: "endpoint",
+            feel: "required",
+            optional: true,
+            binding: { type: "zeebe:input", name: "queryParameters" },
+            value: "={}",
+        };
+    }
+    // Build a FEEL context with all params as example keys
+    const entries = queryParams.map((p) => `"${p.name}": ${p.name}Value`).join(", ");
+    const defaultValue = `={${entries}}`;
+    const names = queryParams.map((p) => `\`${p.name}\``).join(", ");
+    const reqNames = queryParams
+        .filter((p) => p.required)
+        .map((p) => `\`${p.name}\``)
+        .join(", ");
+    return {
+        label: "Query parameters",
+        description: `Available: ${names}${reqNames ? `. Required: ${reqNames}.` : ""} Remove unused keys from the FEEL context.`,
+        type: "Text",
+        group: "endpoint",
+        feel: "required",
+        optional: queryParams.every((p) => !p.required),
+        binding: { type: "zeebe:input", name: "queryParameters" },
+        value: defaultValue,
+    };
+}
+// ─── Headers field ────────────────────────────────────────────────────────────
+function buildHeadersField(headerParams) {
+    if (headerParams.length === 0) {
+        return {
+            label: "Headers",
+            type: "Text",
+            group: "endpoint",
+            feel: "required",
+            optional: true,
+            binding: { type: "zeebe:input", name: "headers" },
+            value: "={}",
+        };
+    }
+    const entries = headerParams.map((p) => `"${p.name}": ${slugify(p.name)}Value`).join(", ");
+    return {
+        label: "Headers",
+        type: "Text",
+        group: "endpoint",
+        feel: "required",
+        optional: headerParams.every((p) => !p.required),
+        binding: { type: "zeebe:input", name: "headers" },
+        value: `={${entries}}`,
+    };
+}
+// ─── Body field ───────────────────────────────────────────────────────────────
+const BODY_METHODS = ["post", "put", "patch"];
+function buildBodyFields(op, expandBody) {
+    if (!BODY_METHODS.includes(op.method))
+        return [];
+    const condition = {
+        property: "method",
+        oneOf: ["POST", "PUT", "PATCH"],
+        type: "simple",
+    };
+    if (!expandBody || !op.requestBodySchema?.properties) {
+        return [
+            {
+                label: "Request body",
+                description: op.requestBodySchema?.description,
+                type: "Text",
+                group: "payload",
+                feel: "required",
+                optional: true,
+                binding: { type: "zeebe:input", name: "body" },
+                value: "={}",
+                condition,
+            },
+        ];
+    }
+    // Expand each top-level property into its own field
+    const schema = op.requestBodySchema;
+    const required = new Set(schema.required ?? []);
+    const fields = [];
+    for (const [name, rawProp] of Object.entries(schema.properties ?? {})) {
+        const prop = rawProp;
+        const fieldType = prop.type === "boolean"
+            ? "Boolean"
+            : prop.type === "number" || prop.type === "integer"
+                ? "Number"
+                : "String";
+        fields.push({
+            id: `body.${name}`,
+            label: toDisplayName(name),
+            description: prop.description,
+            type: fieldType,
+            group: "payload",
+            feel: "optional",
+            optional: !required.has(name),
+            binding: { type: "zeebe:input", name: `body.${name}` },
+            constraints: required.has(name) ? { notEmpty: true } : undefined,
+            condition,
+        });
+    }
+    return fields;
+}
+// ─── Authentication block ─────────────────────────────────────────────────────
+const AUTH_CHOICES = [
+    { name: "No auth", value: "noAuth" },
+    { name: "API key", value: "apiKey" },
+    { name: "Basic auth", value: "basic" },
+    { name: "Bearer token", value: "bearer" },
+    { name: "OAuth 2.0 (Client Credentials)", value: "oauth-client-credentials-flow" },
+];
+function authCond(equals) {
+    return { property: "authentication.type", equals, type: "simple" };
+}
+function buildAuthBlock(defaultAuthType = "noAuth") {
+    return [
+        {
+            id: "authentication.type",
+            label: "Type",
+            type: "Dropdown",
+            group: "authentication",
+            value: defaultAuthType,
+            binding: { type: "zeebe:input", name: "authentication.type" },
+            choices: AUTH_CHOICES,
+        },
+        // API key
+        {
+            id: "authentication.apiKeyLocation",
+            label: "API key location",
+            type: "Dropdown",
+            group: "authentication",
+            value: "headers",
+            binding: { type: "zeebe:input", name: "authentication.apiKeyLocation" },
+            condition: authCond("apiKey"),
+            choices: [
+                { name: "Header", value: "headers" },
+                { name: "Query parameter", value: "query" },
+            ],
+        },
+        {
+            id: "authentication.apiKeyName",
+            label: "API key name",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.apiKeyName" },
+            condition: authCond("apiKey"),
+            constraints: { notEmpty: true },
+        },
+        {
+            id: "authentication.apiKeyValue",
+            label: "API key value",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.apiKeyValue" },
+            condition: authCond("apiKey"),
+            constraints: { notEmpty: true },
+        },
+        // Basic
+        {
+            id: "authentication.username",
+            label: "Username",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.username" },
+            condition: authCond("basic"),
+            constraints: { notEmpty: true },
+        },
+        {
+            id: "authentication.password",
+            label: "Password",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.password" },
+            condition: authCond("basic"),
+            constraints: { notEmpty: true },
+        },
+        // Bearer
+        {
+            id: "authentication.token",
+            label: "Bearer token",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.token" },
+            condition: authCond("bearer"),
+            constraints: { notEmpty: true },
+        },
+        // OAuth2 client credentials
+        {
+            id: "authentication.oauthTokenEndpoint",
+            label: "OAuth token endpoint",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.oauthTokenEndpoint" },
+            condition: authCond("oauth-client-credentials-flow"),
+            constraints: { notEmpty: true },
+        },
+        {
+            id: "authentication.clientId",
+            label: "Client ID",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.clientId" },
+            condition: authCond("oauth-client-credentials-flow"),
+            constraints: { notEmpty: true },
+        },
+        {
+            id: "authentication.clientSecret",
+            label: "Client secret",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            binding: { type: "zeebe:input", name: "authentication.clientSecret" },
+            condition: authCond("oauth-client-credentials-flow"),
+            constraints: { notEmpty: true },
+        },
+        {
+            id: "authentication.clientAuthentication",
+            label: "Client authentication",
+            type: "Dropdown",
+            group: "authentication",
+            value: "basicAuthHeader",
+            binding: { type: "zeebe:input", name: "authentication.clientAuthentication" },
+            condition: authCond("oauth-client-credentials-flow"),
+            choices: [
+                { name: "Send as Basic Auth header", value: "basicAuthHeader" },
+                { name: "Send client credentials in body", value: "requestBody" },
+            ],
+        },
+        {
+            id: "authentication.scopes",
+            label: "Scopes",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            optional: true,
+            binding: { type: "zeebe:input", name: "authentication.scopes" },
+            condition: authCond("oauth-client-credentials-flow"),
+        },
+        {
+            id: "authentication.audience",
+            label: "Audience",
+            type: "String",
+            group: "authentication",
+            feel: "optional",
+            optional: true,
+            binding: { type: "zeebe:input", name: "authentication.audience" },
+            condition: authCond("oauth-client-credentials-flow"),
+        },
+    ];
+}
+// ─── Timeout block ────────────────────────────────────────────────────────────
+function buildTimeoutBlock() {
+    return [
+        {
+            label: "Connection timeout (seconds)",
+            type: "Number",
+            group: "timeout",
+            value: 20,
+            feel: "optional",
+            optional: true,
+            binding: { type: "zeebe:input", name: "connectionTimeoutInSeconds" },
+        },
+        {
+            label: "Read timeout (seconds)",
+            type: "Number",
+            group: "timeout",
+            value: 20,
+            feel: "optional",
+            optional: true,
+            binding: { type: "zeebe:input", name: "readTimeoutInSeconds" },
+        },
+    ];
+}
+// ─── Output / error / retry blocks ───────────────────────────────────────────
+function buildOutputBlock(responseSchema) {
+    let resultExprHint = "";
+    if (responseSchema?.properties) {
+        const keys = Object.keys(responseSchema.properties).slice(0, 3);
+        if (keys.length > 0) {
+            const pairs = keys.map((k) => `${k}: response.body.${k}`).join(", ");
+            resultExprHint = `={${pairs}}`;
+        }
+    }
+    return [
+        {
+            label: "Result variable",
+            type: "String",
+            group: "output",
+            feel: "static",
+            optional: true,
+            binding: { type: "zeebe:taskHeader", key: "resultVariable" },
+        },
+        {
+            label: "Result expression",
+            description: resultExprHint
+                ? `Example: \`${resultExprHint}\``
+                : "FEEL expression to extract values from the response",
+            type: "Text",
+            group: "output",
+            feel: "required",
+            optional: true,
+            binding: { type: "zeebe:taskHeader", key: "resultExpression" },
+        },
+    ];
+}
+function buildErrorBlock() {
+    return [
+        {
+            label: "Error expression",
+            description: 'Example: `=if error.code = 404 then bpmnError("NOT_FOUND", error.message) else null`',
+            type: "Text",
+            group: "errors",
+            feel: "required",
+            optional: true,
+            binding: { type: "zeebe:taskHeader", key: "errorExpression" },
+        },
+    ];
+}
+function buildRetryBlock() {
+    return [
+        {
+            label: "Retries",
+            type: "String",
+            group: "retries",
+            value: "3",
+            binding: { type: "zeebe:taskDefinition", property: "retries" },
+            constraints: { notEmpty: true },
+        },
+        {
+            label: "Retry backoff",
+            description: "ISO 8601 duration, e.g. PT5S for 5 seconds",
+            type: "String",
+            group: "retries",
+            value: "PT0S",
+            feel: "static",
+            optional: true,
+            binding: { type: "zeebe:taskHeader", key: "retryBackoff" },
+        },
+    ];
+}
+// ─── Standard groups ──────────────────────────────────────────────────────────
+const STANDARD_GROUPS = [
+    { id: "endpoint", label: "HTTP Endpoint" },
+    { id: "authentication", label: "Authentication" },
+    { id: "timeout", label: "Timeout", openByDefault: false },
+    { id: "payload", label: "Payload" },
+    { id: "output", label: "Output Mapping" },
+    { id: "errors", label: "Error Handling" },
+    { id: "retries", label: "Retries", openByDefault: false },
+];
+// ─── Main builder ─────────────────────────────────────────────────────────────
+export function buildTemplate(op, opts) {
+    const name = operationName(op);
+    const displayName = op.operation.summary ? op.operation.summary : toDisplayName(name);
+    const templateId = `${opts.idPrefix}.${slugify(name)}`;
+    const properties = [];
+    // 1. Hidden: job type
+    properties.push({
+        type: "Hidden",
+        value: "io.camunda:http-json:1",
+        binding: { type: "zeebe:taskDefinition", property: "type" },
+    });
+    // 2. Hidden: method
+    properties.push({
+        type: "Hidden",
+        value: op.method.toUpperCase(),
+        binding: { type: "zeebe:input", name: "method" },
+    });
+    // 3. URL (hidden if no path params, editable FEEL string if path params)
+    properties.push(buildUrlField(op));
+    // 4. Path params as individual inputs (above URL display)
+    for (const param of op.pathParams) {
+        properties.push(buildPathParamField(param));
+    }
+    // 5. Query parameters
+    properties.push(buildQueryParamsField(op.queryParams));
+    // 6. Headers
+    properties.push(buildHeadersField(op.headerParams));
+    // 7. Body (POST/PUT/PATCH only)
+    for (const f of buildBodyFields(op, opts.expandBody ?? false)) {
+        properties.push(f);
+    }
+    // 8. Auth block
+    for (const f of buildAuthBlock(opts.defaultAuthType)) {
+        properties.push(f);
+    }
+    // 9. Timeout
+    for (const f of buildTimeoutBlock()) {
+        properties.push(f);
+    }
+    // 10. Output
+    for (const f of buildOutputBlock(op.responseSchema)) {
+        properties.push(f);
+    }
+    // 11. Errors
+    for (const f of buildErrorBlock()) {
+        properties.push(f);
+    }
+    // 12. Retries
+    for (const f of buildRetryBlock()) {
+        properties.push(f);
+    }
+    // Drop payload group if no body fields
+    const hasPayload = properties.some((p) => p.group === "payload");
+    const groups = hasPayload ? STANDARD_GROUPS : STANDARD_GROUPS.filter((g) => g.id !== "payload");
+    return {
+        $schema: SCHEMA_URL,
+        name: displayName,
+        id: templateId,
+        version: 1,
+        description: op.operation.description ?? op.operation.summary,
+        documentationRef: op.operation.externalDocs?.url,
+        category: { id: "connectors", name: "Connectors" },
+        appliesTo: ["bpmn:Task"],
+        elementType: { value: "bpmn:ServiceTask" },
+        groups,
+        properties,
+    };
+}
+export function buildTemplates(ops, opts) {
+    return ops.map((op) => buildTemplate(op, opts));
+}
+//# sourceMappingURL=build-template.js.map

package/dist/catalog.d.ts

@@ -0,0 +1,13 @@
+export interface CatalogEntry {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    /** Suggested id prefix for generated templates */
+    idPrefix: string;
+    /** Default auth hint */
+    defaultAuth: "noAuth" | "apiKey" | "basic" | "bearer" | "oauth-client-credentials-flow";
+}
+export declare const CATALOG: CatalogEntry[];
+export declare function getCatalogEntry(id: string): CatalogEntry | undefined;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.js

@@ -0,0 +1,166 @@
+export const CATALOG = [
+    {
+        id: "github",
+        name: "GitHub REST API",
+        description: "Manage repos, issues, PRs, actions, and more via the GitHub REST API",
+        url: "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json",
+        idPrefix: "io.github",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "cloudflare",
+        name: "Cloudflare API",
+        description: "Manage DNS, zones, Workers, and other Cloudflare resources",
+        url: "https://raw.githubusercontent.com/cloudflare/api-schemas/main/openapi.json",
+        idPrefix: "io.cloudflare",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "stripe",
+        name: "Stripe API",
+        description: "Payments, subscriptions, invoices, and more via the Stripe REST API",
+        url: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",
+        idPrefix: "io.stripe",
+        defaultAuth: "basic",
+    },
+    {
+        id: "notion",
+        name: "Notion API",
+        description: "Read and write Notion pages, databases, and blocks",
+        url: "https://raw.githubusercontent.com/notion-sdk-python/notion-sdk-py/main/openapi.yaml",
+        idPrefix: "io.notion",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "resend",
+        name: "Resend Email API",
+        description: "Send transactional emails via the Resend API",
+        url: "https://raw.githubusercontent.com/resendlabs/resend-openapi/main/resend.yaml",
+        idPrefix: "io.resend",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "openai",
+        name: "OpenAI API",
+        description: "Chat completions, embeddings, images, and more from the OpenAI platform",
+        url: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
+        idPrefix: "io.openai",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "figma",
+        name: "Figma API",
+        description: "Read and write Figma files, components, comments, and team resources",
+        url: "https://raw.githubusercontent.com/figma/rest-api-spec/main/openapi/openapi.yaml",
+        idPrefix: "io.figma",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "twilio",
+        name: "Twilio Messaging API",
+        description: "Send and manage SMS, MMS, and WhatsApp messages via Twilio",
+        url: "https://raw.githubusercontent.com/twilio/twilio-oai/main/spec/json/twilio_messaging_v1.json",
+        idPrefix: "io.twilio",
+        defaultAuth: "basic",
+    },
+    {
+        id: "slack",
+        name: "Slack Web API",
+        description: "Post messages, manage channels, users, and workflows in Slack",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/slack.com/1.7.0/openapi.yaml",
+        idPrefix: "io.slack",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "jira",
+        name: "Atlassian Jira API",
+        description: "Manage Jira issues, projects, boards, and sprints",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/atlassian.com/jira/1001.0.0-SNAPSHOT/openapi.yaml",
+        idPrefix: "io.atlassian.jira",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "hubspot",
+        name: "HubSpot CRM API",
+        description: "Manage contacts, companies, deals, and pipelines in the HubSpot CRM platform",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/hubapi.com/crm/v3/openapi.yaml",
+        idPrefix: "com.hubspot",
+        defaultAuth: "oauth-client-credentials-flow",
+    },
+    {
+        id: "discord",
+        name: "Discord API",
+        description: "Manage Discord bots, messages, channels, guilds, and webhooks",
+        url: "https://raw.githubusercontent.com/discord/discord-api-spec/main/specs/openapi.json",
+        idPrefix: "com.discord",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "pagerduty",
+        name: "PagerDuty API",
+        description: "Create and manage incidents, escalation policies, and on-call schedules",
+        url: "https://raw.githubusercontent.com/PagerDuty/api-schema/main/reference/REST/openapiv3.json",
+        idPrefix: "com.pagerduty",
+        defaultAuth: "apiKey",
+    },
+    {
+        id: "zoom",
+        name: "Zoom API",
+        description: "Create and manage Zoom meetings, webinars, recordings, and users",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/zoom.us/2.0.0/openapi.yaml",
+        idPrefix: "us.zoom",
+        defaultAuth: "oauth-client-credentials-flow",
+    },
+    {
+        id: "mailchimp",
+        name: "Mailchimp API",
+        description: "Manage email campaigns, audiences, automations, and transactional messages",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/mailchimp.com/3.0.55/openapi.yaml",
+        idPrefix: "com.mailchimp",
+        defaultAuth: "apiKey",
+    },
+    {
+        id: "asana",
+        name: "Asana API",
+        description: "Manage tasks, projects, teams, and workspaces in Asana",
+        url: "https://raw.githubusercontent.com/Asana/openapi/master/defs/asana_oas.yaml",
+        idPrefix: "com.asana",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "sendgrid",
+        name: "SendGrid Mail API",
+        description: "Send transactional and marketing emails with templates, tracking, and analytics",
+        url: "https://raw.githubusercontent.com/twilio/sendgrid-oai/main/spec/json/tsg_mail_v3.json",
+        idPrefix: "com.sendgrid",
+        defaultAuth: "bearer",
+    },
+    {
+        id: "paypal",
+        name: "PayPal Payments API",
+        description: "Authorize, capture, and refund online payment transactions via PayPal",
+        url: "https://raw.githubusercontent.com/paypal/paypal-rest-api-specifications/main/openapi/payments_payment_v2.json",
+        idPrefix: "com.paypal",
+        defaultAuth: "oauth-client-credentials-flow",
+    },
+    {
+        id: "plaid",
+        name: "Plaid API",
+        description: "Link bank accounts, read transactions, and verify identity via Plaid",
+        url: "https://raw.githubusercontent.com/plaid/plaid-openapi/master/2020-09-14.yml",
+        idPrefix: "com.plaid",
+        defaultAuth: "apiKey",
+    },
+    {
+        id: "vercel",
+        name: "Vercel API",
+        description: "Manage Vercel deployments, projects, domains, and team resources",
+        url: "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/vercel.com/0.0.1/openapi.yaml",
+        idPrefix: "com.vercel",
+        defaultAuth: "bearer",
+    },
+];
+export function getCatalogEntry(id) {
+    return CATALOG.find((e) => e.id === id);
+}
+//# sourceMappingURL=catalog.js.map

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+export { buildTemplate, buildTemplates } from "./build-template.js";
+export { CATALOG, getCatalogEntry } from "./catalog.js";
+export type { CatalogEntry } from "./catalog.js";
+export { detectDefaultAuth, getBaseUrl, getOperations, getServers, isRef, parseOpenApi, resolve, resolveRef, } from "./parse-openapi.js";
+export type { DetectedAuth } from "./parse-openapi.js";
+export type { ApiResponse, AuthHint, Binding, Components, ConnectorGroup, ConnectorTemplate, Constraints, GeneratorOptions, HttpMethod, MediaType, OpenApiDoc, OpenApiInfo, OpenApiServer, Operation, OperationWithMeta, OAuthFlows, Parameter, PathItem, PropertyDef, Ref, RequestBody, Schema, SecurityRequirement, SecurityScheme, WriteOptions, } from "./types.js";
+export { CONNECTOR_SCHEMA } from "./types.js";
+export { writeTemplates } from "./write-templates.js";
+import type { CatalogEntry } from "./catalog.js";
+import type { ConnectorTemplate, GeneratorOptions, WriteOptions } from "./types.js";
+export interface GenerateOptions extends GeneratorOptions, Partial<WriteOptions> {
+    /** If provided, write files to disk. Otherwise return the templates. */
+    outputDir?: string;
+}
+/**
+ * Parse an OpenAPI spec (string or object) and generate connector templates.
+ * Returns the generated templates; call `writeTemplates` separately if you need
+ * to write them to disk.
+ */
+export declare function generate(specText: string, opts: GeneratorOptions): ConnectorTemplate[];
+/**
+ * Download an OpenAPI spec from a URL, generate connector templates, and
+ * optionally write them to disk.
+ */
+export declare function generateFromUrl(url: string, opts: GenerateOptions): Promise<{
+    templates: ConnectorTemplate[];
+    files: string[];
+}>;
+/**
+ * Generate connector templates from a catalog entry by ID.
+ * Downloads the spec from the catalog URL.
+ */
+export declare function generateFromCatalog(id: string, overrides?: Partial<GenerateOptions>): Promise<{
+    templates: ConnectorTemplate[];
+    files: string[];
+    entry: CatalogEntry;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,54 @@
+export { buildTemplate, buildTemplates } from "./build-template.js";
+export { CATALOG, getCatalogEntry } from "./catalog.js";
+export { detectDefaultAuth, getBaseUrl, getOperations, getServers, isRef, parseOpenApi, resolve, resolveRef, } from "./parse-openapi.js";
+export { CONNECTOR_SCHEMA } from "./types.js";
+export { writeTemplates } from "./write-templates.js";
+import { buildTemplates } from "./build-template.js";
+import { CATALOG, getCatalogEntry } from "./catalog.js";
+import { detectDefaultAuth, getOperations, parseOpenApi } from "./parse-openapi.js";
+import { writeTemplates } from "./write-templates.js";
+/**
+ * Parse an OpenAPI spec (string or object) and generate connector templates.
+ * Returns the generated templates; call `writeTemplates` separately if you need
+ * to write them to disk.
+ */
+export function generate(specText, opts) {
+    const doc = parseOpenApi(specText);
+    const defaultAuth = opts.defaultAuthType ?? detectDefaultAuth(doc);
+    const ops = getOperations(doc, opts.filter);
+    return buildTemplates(ops, { ...opts, defaultAuthType: defaultAuth });
+}
+/**
+ * Download an OpenAPI spec from a URL, generate connector templates, and
+ * optionally write them to disk.
+ */
+export async function generateFromUrl(url, opts) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch spec from ${url}: ${res.status} ${res.statusText}`);
+    const text = await res.text();
+    const templates = generate(text, opts);
+    const files = opts.outputDir
+        ? await writeTemplates(templates, { outputDir: opts.outputDir, format: opts.format })
+        : [];
+    return { templates, files };
+}
+/**
+ * Generate connector templates from a catalog entry by ID.
+ * Downloads the spec from the catalog URL.
+ */
+export async function generateFromCatalog(id, overrides = {}) {
+    const entry = getCatalogEntry(id);
+    if (!entry) {
+        const ids = CATALOG.map((e) => e.id).join(", ");
+        throw new Error(`Unknown catalog entry "${id}". Available: ${ids}`);
+    }
+    const opts = {
+        idPrefix: overrides.idPrefix ?? entry.idPrefix,
+        defaultAuthType: overrides.defaultAuthType ?? entry.defaultAuth,
+        ...overrides,
+    };
+    const { templates, files } = await generateFromUrl(entry.url, opts);
+    return { templates, files, entry };
+}
+//# sourceMappingURL=index.js.map

package/dist/parse-openapi.d.ts

@@ -0,0 +1,12 @@
+import type { OpenApiDoc, OpenApiServer, OperationWithMeta, Ref } from "./types.js";
+export declare function isRef(obj: unknown): obj is Ref;
+export declare function resolveRef<T>(doc: OpenApiDoc, ref: string): T;
+/** Resolve a value that may be a $ref or a concrete type. */
+export declare function resolve<T>(doc: OpenApiDoc, obj: T | Ref): T;
+export declare function parseOpenApi(text: string): OpenApiDoc;
+export declare function getBaseUrl(doc: OpenApiDoc, override?: string): string;
+export declare function getOperations(doc: OpenApiDoc, filter?: string): OperationWithMeta[];
+export type DetectedAuth = "noAuth" | "apiKey" | "basic" | "bearer" | "oauth-client-credentials-flow";
+export declare function detectDefaultAuth(doc: OpenApiDoc): DetectedAuth;
+export declare function getServers(doc: OpenApiDoc): OpenApiServer[];
+//# sourceMappingURL=parse-openapi.d.ts.map

package/dist/parse-openapi.js

@@ -0,0 +1,208 @@
+import { parse as parseYaml } from "yaml";
+// ─── $ref helpers ─────────────────────────────────────────────────────────────
+export function isRef(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        "$ref" in obj &&
+        typeof obj.$ref === "string");
+}
+export function resolveRef(doc, ref) {
+    if (!ref.startsWith("#/")) {
+        throw new Error(`External $ref not supported: "${ref}". Only local #/ refs are resolved.`);
+    }
+    const parts = ref.slice(2).split("/");
+    let current = doc;
+    for (const part of parts) {
+        if (typeof current !== "object" || current === null) {
+            throw new Error(`Cannot resolve $ref "${ref}": path segment "${part}" is not an object`);
+        }
+        const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+        current = current[decoded];
+        if (current === undefined) {
+            throw new Error(`Cannot resolve $ref "${ref}": key "${decoded}" not found`);
+        }
+    }
+    return current;
+}
+/** Resolve a value that may be a $ref or a concrete type. */
+export function resolve(doc, obj) {
+    if (isRef(obj))
+        return resolveRef(doc, obj.$ref);
+    return obj;
+}
+// ─── Parse ────────────────────────────────────────────────────────────────────
+export function parseOpenApi(text) {
+    const trimmed = text.trimStart();
+    // JSON starts with { or [; everything else is treated as YAML
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse OpenAPI JSON: ${String(e)}`);
+        }
+    }
+    try {
+        return parseYaml(text);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse OpenAPI YAML: ${String(e)}`);
+    }
+}
+// ─── Base URL ─────────────────────────────────────────────────────────────────
+export function getBaseUrl(doc, override) {
+    if (override)
+        return override.replace(/\/$/, "");
+    const server = doc.servers?.[0];
+    if (!server)
+        return "";
+    let url = server.url.replace(/\/$/, "");
+    // Expand server variables with their defaults
+    if (server.variables) {
+        for (const [key, variable] of Object.entries(server.variables)) {
+            url = url.replace(`{${key}}`, variable.default);
+        }
+    }
+    return url;
+}
+// ─── Parameter resolution (path-level params merged with op-level) ────────────
+function resolveParameters(doc, pathItem, operation) {
+    const all = [
+        ...(pathItem.parameters ?? []),
+        ...(operation.parameters ?? []),
+    ];
+    // Op-level overrides path-level by name+in (later entries win)
+    const map = new Map();
+    for (const item of all) {
+        const param = resolve(doc, item);
+        map.set(`${param.in}:${param.name}`, param);
+    }
+    return [...map.values()];
+}
+// ─── Body / response schema resolution ───────────────────────────────────────
+function resolveBodySchema(doc, requestBody) {
+    if (!requestBody)
+        return null;
+    const body = resolve(doc, requestBody);
+    const json = body.content["application/json"];
+    if (!json?.schema)
+        return null;
+    try {
+        return resolve(doc, json.schema);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveResponseSchema(doc, responses) {
+    if (!responses)
+        return null;
+    const ok = responses["200"] ?? responses["201"] ?? responses["2XX"] ?? responses.default;
+    if (!ok)
+        return null;
+    try {
+        const resp = resolve(doc, ok);
+        const json = resp.content?.["application/json"];
+        if (!json?.schema)
+            return null;
+        return resolve(doc, json.schema);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Server validation ────────────────────────────────────────────────────────
+function validateDoc(doc) {
+    if (!doc || typeof doc !== "object") {
+        throw new Error("Invalid OpenAPI document: must be an object");
+    }
+    const version = doc.openapi ?? doc.swagger;
+    if (typeof version !== "string") {
+        throw new Error("Invalid OpenAPI document: missing `openapi` version field");
+    }
+    if (version.startsWith("2.")) {
+        throw new Error(`OpenAPI 2.x (Swagger) is not supported. Found version "${version}". Please convert to OpenAPI 3.x first (e.g. using https://editor.swagger.io).`);
+    }
+}
+// ─── Main: enumerate all operations ──────────────────────────────────────────
+const HTTP_METHODS = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options",
+    "trace",
+];
+export function getOperations(doc, filter) {
+    validateDoc(doc);
+    const baseUrl = getBaseUrl(doc);
+    const filterRe = filter ? new RegExp(filter, "i") : null;
+    const results = [];
+    for (const [path, rawPathItem] of Object.entries(doc.paths ?? {})) {
+        let pathItem;
+        try {
+            pathItem = resolve(doc, rawPathItem);
+        }
+        catch {
+            continue;
+        }
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem[method];
+            if (!operation)
+                continue;
+            if (filterRe) {
+                const haystack = `${operation.operationId ?? ""} ${operation.summary ?? ""} ${path}`;
+                if (!filterRe.test(haystack))
+                    continue;
+            }
+            const params = resolveParameters(doc, pathItem, operation);
+            let responseSchema = null;
+            try {
+                responseSchema = resolveResponseSchema(doc, operation.responses);
+            }
+            catch {
+                // ignore resolution errors for response schemas
+            }
+            results.push({
+                path,
+                method,
+                operation,
+                baseUrl,
+                pathParams: params.filter((p) => p.in === "path"),
+                queryParams: params.filter((p) => p.in === "query"),
+                headerParams: params.filter((p) => p.in === "header"),
+                requestBodySchema: resolveBodySchema(doc, operation.requestBody),
+                responseSchema,
+            });
+        }
+    }
+    return results;
+}
+export function detectDefaultAuth(doc) {
+    const schemes = doc.components?.securitySchemes;
+    if (!schemes)
+        return "noAuth";
+    for (const raw of Object.values(schemes)) {
+        try {
+            const scheme = resolve(doc, raw);
+            if (scheme.type === "http" && scheme.scheme === "bearer")
+                return "bearer";
+            if (scheme.type === "http" && scheme.scheme === "basic")
+                return "basic";
+            if (scheme.type === "apiKey")
+                return "apiKey";
+            if (scheme.type === "oauth2" && scheme.flows?.clientCredentials) {
+                return "oauth-client-credentials-flow";
+            }
+        }
+        catch { }
+    }
+    return "noAuth";
+}
+// Re-export server info helper used downstream
+export function getServers(doc) {
+    return doc.servers ?? [];
+}
+//# sourceMappingURL=parse-openapi.js.map

package/dist/types.d.ts

@@ -0,0 +1,245 @@
+export type HttpMethod = "get" | "post" | "put" | "patch" | "delete" | "head" | "options" | "trace";
+export interface OpenApiDoc {
+    openapi: string;
+    info: OpenApiInfo;
+    externalDocs?: {
+        url?: string;
+        description?: string;
+    };
+    servers?: OpenApiServer[];
+    paths?: Record<string, PathItem | Ref>;
+    components?: Components;
+    security?: SecurityRequirement[];
+}
+export interface OpenApiInfo {
+    title: string;
+    version: string;
+    description?: string;
+}
+export interface OpenApiServer {
+    url: string;
+    description?: string;
+    variables?: Record<string, {
+        default: string;
+        description?: string;
+        enum?: string[];
+    }>;
+}
+export interface PathItem {
+    summary?: string;
+    description?: string;
+    get?: Operation;
+    put?: Operation;
+    post?: Operation;
+    delete?: Operation;
+    options?: Operation;
+    head?: Operation;
+    patch?: Operation;
+    trace?: Operation;
+    parameters?: Array<Parameter | Ref>;
+}
+export interface Operation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: Array<Parameter | Ref>;
+    requestBody?: RequestBody | Ref;
+    responses?: Record<string, ApiResponse | Ref>;
+    security?: SecurityRequirement[];
+    deprecated?: boolean;
+    externalDocs?: {
+        url?: string;
+        description?: string;
+    };
+}
+export interface Parameter {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    schema?: Schema | Ref;
+}
+export interface RequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, MediaType>;
+}
+export interface MediaType {
+    schema?: Schema | Ref;
+}
+export interface ApiResponse {
+    description?: string;
+    content?: Record<string, MediaType>;
+}
+export interface Schema {
+    type?: string;
+    format?: string;
+    title?: string;
+    description?: string;
+    properties?: Record<string, Schema | Ref>;
+    required?: string[];
+    items?: Schema | Ref;
+    enum?: unknown[];
+    default?: unknown;
+    nullable?: boolean;
+    allOf?: Array<Schema | Ref>;
+    oneOf?: Array<Schema | Ref>;
+    anyOf?: Array<Schema | Ref>;
+    $ref?: string;
+}
+export interface Ref {
+    $ref: string;
+}
+export interface Components {
+    schemas?: Record<string, Schema | Ref>;
+    parameters?: Record<string, Parameter | Ref>;
+    requestBodies?: Record<string, RequestBody | Ref>;
+    responses?: Record<string, ApiResponse | Ref>;
+    securitySchemes?: Record<string, SecurityScheme | Ref>;
+}
+export type SecurityScheme = {
+    type: "apiKey";
+    name: string;
+    in: "header" | "query" | "cookie";
+    description?: string;
+} | {
+    type: "http";
+    scheme: string;
+    bearerFormat?: string;
+    description?: string;
+} | {
+    type: "oauth2";
+    flows: OAuthFlows;
+    description?: string;
+} | {
+    type: "openIdConnect";
+    openIdConnectUrl: string;
+    description?: string;
+};
+export interface OAuthFlows {
+    clientCredentials?: {
+        tokenUrl: string;
+        scopes?: Record<string, string>;
+    };
+    authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        scopes?: Record<string, string>;
+    };
+}
+export type SecurityRequirement = Record<string, string[]>;
+export interface OperationWithMeta {
+    path: string;
+    method: HttpMethod;
+    operation: Operation;
+    baseUrl: string;
+    pathParams: Parameter[];
+    queryParams: Parameter[];
+    headerParams: Parameter[];
+    requestBodySchema: Schema | null;
+    responseSchema: Schema | null;
+}
+export declare const CONNECTOR_SCHEMA = "https://unpkg.com/@camunda/zeebe-element-templates-json-schema/resources/schema.json";
+export interface ConnectorTemplate {
+    $schema: string;
+    name: string;
+    id: string;
+    version: number;
+    description?: string;
+    documentationRef?: string;
+    category?: {
+        id: string;
+        name: string;
+    };
+    appliesTo: string[];
+    elementType: {
+        value: string;
+    };
+    engines?: {
+        camunda?: string;
+    };
+    groups: ConnectorGroup[];
+    properties: PropertyDef[];
+    icon?: {
+        contents: string;
+    };
+    metadata?: {
+        keywords?: string[];
+    };
+}
+export interface ConnectorGroup {
+    id: string;
+    label: string;
+    tooltip?: string;
+    openByDefault?: boolean;
+}
+export type Binding = {
+    type: "zeebe:taskDefinition";
+    property: "type" | "retries";
+} | {
+    type: "zeebe:input";
+    name: string;
+} | {
+    type: "zeebe:output";
+    name: string;
+} | {
+    type: "zeebe:taskHeader";
+    key: string;
+} | {
+    type: "zeebe:property";
+    name: string;
+};
+export interface Condition {
+    property: string;
+    equals?: string;
+    oneOf?: string[];
+    type?: "simple";
+}
+export interface Constraints {
+    notEmpty?: boolean;
+    pattern?: {
+        value: string;
+        message?: string;
+    };
+    minLength?: number;
+    maxLength?: number;
+}
+export interface PropertyDef {
+    id?: string;
+    label?: string;
+    description?: string;
+    type: "String" | "Text" | "Number" | "Boolean" | "Dropdown" | "Hidden";
+    value?: string | boolean | number;
+    group?: string;
+    binding: Binding;
+    feel?: "optional" | "required" | "static";
+    optional?: boolean;
+    constraints?: Constraints;
+    condition?: Condition;
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    tooltip?: string;
+}
+export type AuthHint = "noAuth" | "apiKey" | "basic" | "bearer" | "oauth-client-credentials-flow";
+export interface GeneratorOptions {
+    /** Reverse-DNS prefix for template IDs, e.g. "io.mycompany" */
+    idPrefix: string;
+    /** Override the base URL from the spec */
+    baseUrl?: string;
+    /** Decompose top-level request body properties into individual fields */
+    expandBody?: boolean;
+    /** Filter operations by operationId/summary regex */
+    filter?: string;
+    /** Pre-select a specific auth type */
+    defaultAuthType?: AuthHint;
+}
+export interface WriteOptions {
+    outputDir: string;
+    /** "one-per-op": one file per operation; "array": all in one file */
+    format?: "one-per-op" | "array";
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,4 @@
+// ─── OpenAPI 3.x types (minimal subset needed for generation) ─────────────────
+// ─── Connector template types ─────────────────────────────────────────────────
+export const CONNECTOR_SCHEMA = "https://unpkg.com/@camunda/zeebe-element-templates-json-schema/resources/schema.json";
+//# sourceMappingURL=types.js.map

package/dist/write-templates.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectorTemplate, WriteOptions } from "./types.js";
+export declare function writeTemplates(templates: ConnectorTemplate[], opts: WriteOptions): Promise<string[]>;
+//# sourceMappingURL=write-templates.d.ts.map

package/dist/write-templates.js

@@ -0,0 +1,27 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function safeName(id) {
+    // Strip idPrefix (everything up to and including the first dot), lowercase
+    const base = id.includes(".") ? id.slice(id.indexOf(".") + 1) : id;
+    return base.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+}
+export async function writeTemplates(templates, opts) {
+    await mkdir(opts.outputDir, { recursive: true });
+    const format = opts.format ?? "one-per-op";
+    const written = [];
+    if (format === "array") {
+        const filePath = join(opts.outputDir, "connector-templates.json");
+        await writeFile(filePath, JSON.stringify(templates, null, 2), "utf8");
+        written.push(filePath);
+    }
+    else {
+        for (const tpl of templates) {
+            const fileName = `${safeName(tpl.id)}.json`;
+            const filePath = join(opts.outputDir, fileName);
+            await writeFile(filePath, JSON.stringify(tpl, null, 2), "utf8");
+            written.push(filePath);
+        }
+    }
+    return written;
+}
+//# sourceMappingURL=write-templates.js.map

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@bpmn-sdk/connector-gen",
+	"version": "0.0.1",
+	"private": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": ["dist/**/*.js", "dist/**/*.d.ts"],
+	"scripts": {
+		"build": "tsc",
+		"typecheck": "tsc --noEmit",
+		"check": "biome check .",
+		"test": "vitest run"
+	},
+	"dependencies": {
+		"yaml": "^2.7.0"
+	},
+	"description": "Generate Camunda REST connector element templates from OpenAPI/Swagger specs",
+	"keywords": ["camunda", "connector", "openapi", "swagger", "bpmn", "element-template"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/bpmn-sdk/monorepo"
+	}
+}