@zapier/trello-connector 0.0.0 → 0.1.0

package/scripts/findChecklist.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { nameContains, TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({ id: z.string().describe("24-char hex card id."), name: z.string() })
+  .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(),
+    idCard: z.string().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "findChecklist",
+  title: "Find Checklist",
+  description:
+    "Find checklists on a card whose name contains the search string.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}/checklists`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findChecklist", res);
+    const checklists = (await res.json()) as Array<{ name?: string }>;
+    const items = (Array.isArray(checklists) ? checklists : []).filter((cl) =>
+      nameContains(cl.name ?? "", input.name),
+    );
+    return { items };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/findChecklistItem.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { nameContains, TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z.object({ id: z.string(), name: z.string() }).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(),
+    state: z.enum(["complete", "incomplete"]),
+    idChecklist: z.string().nullable().optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "findChecklistItem",
+  title: "Find Checklist Item",
+  description: "Find checklist items whose name contains the search string.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/checklists/${encodeURIComponent(input.id)}/checkItems`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findChecklistItem", res);
+    const checkItems = (await res.json()) as Array<{ name?: string }>;
+    const items = (Array.isArray(checkItems) ? checkItems : []).filter((item) =>
+      nameContains(item.name ?? "", input.name),
+    );
+    return { items };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/findLabel.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { nameContains, TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex board id."),
+    name: z.string(),
+  })
+  .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: "findLabel",
+  title: "Find Label",
+  description: "Find labels on a board whose name contains the search string.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/boards/${encodeURIComponent(input.id)}/labels`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findLabel", res);
+    const labels = (await res.json()) as Array<{ name?: string | null }>;
+    const items = (Array.isArray(labels) ? labels : []).filter((label) =>
+      nameContains(label.name ?? "", input.name),
+    );
+    return { items };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/findList.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";
+import { nameContains, TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex board id."),
+    name: z.string(),
+  })
+  .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: "findList",
+  title: "Find List",
+  description: "Find lists on a board whose name contains the search string.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/boards/${encodeURIComponent(input.id)}/lists`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findList", res);
+    const lists = (await res.json()) as Array<{ name?: string }>;
+    const items = (Array.isArray(lists) ? lists : []).filter((list) =>
+      nameContains(list.name ?? "", input.name),
+    );
+    return { items };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/findOrganizationMember.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({ query: z.string(), organizationId: z.string().optional() })
+  .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: "findOrganizationMember",
+  title: "Find Organization Member",
+  description: "Find members via GET /search/members/.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`${TRELLO_BASE}/search/members/`);
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("limit", "20");
+    if (input.organizationId !== undefined) {
+      url.searchParams.set("idOrganization", input.organizationId);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("findOrganizationMember", res);
+    const data = await res.json();
+    return { items: Array.isArray(data) ? data : [] };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getAction.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() }).strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  type: z.string(),
+  date: z.string().datetime({ offset: true }),
+  data: z
+    .object({
+      text: z.string().nullable().optional(),
+      card: z
+        .object({
+          id: z.string().nullable().optional(),
+          name: z.string().nullable().optional(),
+        })
+        .nullable()
+        .optional(),
+    })
+    .nullable()
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "getAction",
+  title: "Get Action",
+  description: "Get an action (activity) by id, including comments.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/actions/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getAction ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getBoard.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 outputSchema = 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 definition = defineTool({
+  name: "getBoard",
+  title: "Get Board",
+  description: "Get a board 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/boards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getCard.ts

@@ -0,0 +1,79 @@
+#!/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 outputSchema = 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.array(z.string()).nullable().optional(),
+  idMembers: z.array(z.string()).nullable().optional(),
+  labels: 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(),
+      }),
+    )
+    .nullable()
+    .optional(),
+  pos: z.number().nullable().optional(),
+  customFields: z
+    .record(z.string(), z.any())
+    .nullable()
+    .describe("Custom field values keyed by field name when requested.")
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "getCard",
+  title: "Get Card",
+  description: "Get a card 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/cards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getCard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getChecklist.ts

@@ -0,0 +1,45 @@
+#!/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(),
+  idCard: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "getChecklist",
+  title: "Get Checklist",
+  description: "Get a checklist 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/checklists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getChecklist ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getChecklistItem.ts

@@ -0,0 +1,48 @@
+#!/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(), idCheckItem: 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(),
+  state: z.enum(["complete", "incomplete"]),
+  idChecklist: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "getChecklistItem",
+  title: "Get Checklist Item",
+  description: "Get a checklist item 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/checklists/${encodeURIComponent(input.id)}/checkItems/${encodeURIComponent(input.idCheckItem)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getCurrentMember.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({}).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: "getCurrentMember",
+  title: "Get Current Member",
+  description: "Get the authenticated member (identity resolver).",
+  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`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getCurrentMember ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/getLabel.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)."),
+  idBoard: z.string(),
+  name: z.string().nullable().optional(),
+  color: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "getLabel",
+  title: "Get Label",
+  description: "Get a label 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/labels/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getLabel ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });