@zapier/trello-connector 0.0.0 → 0.1.0

package/scripts/getList.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({ id: z.string() }).strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  name: z.string(),
+  closed: z.boolean().nullable().optional(),
+  idBoard: z.string(),
+  pos: z.number().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "getList",
+  title: "Get List",
+  description: "Get a list by id.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/lists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getList ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getMember.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({ id: z.string() }).strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  username: z.string(),
+  fullName: z.string().nullable().optional(),
+  initials: z.string().nullable().optional(),
+  avatarUrl: z.string().nullable().optional(),
+  email: z
+    .string()
+    .nullable()
+    .describe("Present only when token has account read scope.")
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "getMember",
+  title: "Get Member",
+  description: "Get a member by id.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/members/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getMember ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getOrganization.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({ id: z.string() }).strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  name: z.string(),
+  displayName: z.string(),
+  url: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "getOrganization",
+  title: "Get Organization",
+  description: "Get a workspace (organization) by id.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/organizations/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getOrganization ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listBoardMembers.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({ id: z.string().describe("24-char hex board id.") })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    username: z.string(),
+    fullName: z.string().nullable().optional(),
+    initials: z.string().nullable().optional(),
+    avatarUrl: z.string().nullable().optional(),
+    email: z
+      .string()
+      .nullable()
+      .describe("Present only when token has account read scope.")
+      .optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listBoardMembers",
+  title: "List Board Members",
+  description: "List members of a board.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/members`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listBoardMembers ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listBoards.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    filter: z
+      .enum([
+        "all",
+        "closed",
+        "members",
+        "none",
+        "open",
+        "organization",
+        "pinned",
+        "public",
+        "starred",
+        "unpinned",
+      ])
+      .default("all"),
+  })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    desc: z.string().nullable().optional(),
+    closed: z.boolean().nullable().optional(),
+    idOrganization: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+    shortUrl: z.string().nullable().optional(),
+    dateLastActivity: z
+      .string()
+      .datetime({ offset: true })
+      .nullable()
+      .optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listBoards",
+  title: "List Boards",
+  description: "List boards the authenticated member can access.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`https://api.trello.com/1/members/me/boards`);
+    if (input.filter !== undefined) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listBoards ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listCardAttachments.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({ id: z.string().describe("24-char hex card id.") })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    url: z.string().nullable().optional(),
+    mimeType: z.string().nullable().optional(),
+    bytes: z.union([z.number().int(), z.null()]).optional(),
+    isUpload: z.boolean().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listCardAttachments",
+  title: "List Card Attachments",
+  description:
+    "List attachments on a card (metadata only; use download URLs from response).",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/attachments`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCardAttachments ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listCards.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex board id."),
+    filter: z
+      .enum(["all", "closed", "none", "open", "visible"])
+      .default("open"),
+    before: z
+      .string()
+      .describe("Return cards older than this card id (cursor for next page).")
+      .optional(),
+    limit: z
+      .number()
+      .int()
+      .gte(1)
+      .lte(1000)
+      .describe(
+        "Defaults to 20 when omitted; pass a value when you need a specific number of results.",
+      )
+      .optional(),
+  })
+  .strict();
+const outputSchema = z.object({
+  items: z
+    .array(
+      z.object({
+        id: z
+          .string()
+          .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+          .describe("Trello object id (24 hex chars)."),
+        name: z.string(),
+        desc: z.string().nullable().optional(),
+        closed: z.boolean().nullable().optional(),
+        idBoard: z.string(),
+        idList: z.string(),
+        idShort: z.number().int().nullable().optional(),
+        shortLink: z.string().nullable().optional(),
+        shortUrl: z.string().nullable().optional(),
+        url: z.string().nullable().optional(),
+        due: z
+          .union([z.string().datetime({ offset: true }), z.null()])
+          .optional(),
+        dueComplete: z.boolean().nullable().optional(),
+        dateLastActivity: z
+          .string()
+          .datetime({ offset: true })
+          .nullable()
+          .optional(),
+        idLabels: z
+          .any()
+          .nullable()
+          .describe("Nested object — shape passes through.")
+          .optional(),
+        idMembers: z
+          .any()
+          .nullable()
+          .describe("Nested object — shape passes through.")
+          .optional(),
+        labels: z
+          .any()
+          .nullable()
+          .describe("Nested object — shape passes through.")
+          .optional(),
+        pos: z.number().nullable().optional(),
+        customFields: z
+          .any()
+          .nullable()
+          .describe("Nested object — shape passes through.")
+          .optional(),
+      }),
+    )
+    .nullable()
+    .optional(),
+  has_more: z
+    .boolean()
+    .nullable()
+    .describe(
+      "True when the page is full and before-cursor paging may return more.",
+    )
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "listCards",
+  title: "List Cards",
+  description:
+    "List cards on a board with optional filter and before-cursor pagination.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/cards`,
+    );
+    if (input.filter !== undefined) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    if (input.before !== undefined) {
+      url.searchParams.set("before", String(input.before));
+    }
+    url.searchParams.set("limit", String(input.limit ?? 20));
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCards ${res.status}: ${errBody}`);
+    }
+    const limit = input.limit ?? 20;
+    const cards = (await res.json()) as unknown[];
+    const items = Array.isArray(cards) ? cards : [];
+    return { items, has_more: items.length >= limit };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listCustomFields.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({ id: z.string().describe("24-char hex board id.") })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    type: z.enum(["checkbox", "date", "list", "number", "text"]),
+    options: z
+      .array(
+        z.object({
+          id: z.string(),
+          value: z.object({ text: z.string().optional() }).optional(),
+          color: z.string().optional(),
+        }),
+      )
+      .nullable()
+      .optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listCustomFields",
+  title: "List Custom Fields",
+  description:
+    "List custom field definitions on a board. Use before setting custom field values on cards.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/customFields`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCustomFields ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listLabels.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({ id: z.string().describe("24-char hex board id.") })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    idBoard: z.string(),
+    name: z.string().nullable().optional(),
+    color: z.string().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listLabels",
+  title: "List Labels",
+  description: "List labels defined on a board.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/labels`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listLabels ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listLists.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex board id."),
+    filter: z.enum(["all", "closed", "none", "open"]).default("open"),
+  })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    closed: z.boolean().nullable().optional(),
+    idBoard: z.string(),
+    pos: z.number().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listLists",
+  title: "List Lists",
+  description: "List all lists on a board. Use findList to match by name.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/lists`,
+    );
+    if (input.filter !== undefined) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listLists ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/listOrganizations.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({}).strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    displayName: z.string(),
+    url: z.string().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "listOrganizations",
+  title: "List Organizations",
+  description: "List workspaces the authenticated member belongs to.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (_input, ctx) => {
+    const url = `https://api.trello.com/1/members/me/organizations`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listOrganizations ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });