@zapier/trello-connector 0.0.0 → 0.1.0

package/scripts/addCardMember.ts

@@ -0,0 +1,93 @@
+#!/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."),
+    value: z.string().describe("Member id to add."),
+  })
+  .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: "addCardMember",
+  title: "Add Card Member",
+  description: "Add a member to a card.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/idMembers`;
+    const body: Record<string, unknown> = {};
+    if (input.value !== undefined) body["value"] = input.value;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addCardMember ${res.status}: ${errBody}`);
+    }
+    const cardRes = await ctx.fetch(
+      `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`,
+    );
+    if (!cardRes.ok) {
+      const errBody = await cardRes.text();
+      throw new Error(`Trello addCardMember ${cardRes.status}: ${errBody}`);
+    }
+    return cardRes.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/addChecklistItem.ts

@@ -0,0 +1,98 @@
+#!/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(),
+    name: z.string(),
+    pos: z
+      .any()
+      .superRefine((x, ctx) => {
+        const schemas = [z.enum(["top", "bottom"]), z.number()];
+        const { errors, failed } = schemas.reduce<{
+          errors: z.core.$ZodIssue[];
+          failed: number;
+        }>(
+          ({ errors, failed }, schema) =>
+            ((result) =>
+              result.error
+                ? {
+                    errors: [...errors, ...result.error.issues],
+                    failed: failed + 1,
+                  }
+                : { errors, failed })(schema.safeParse(x)),
+          { errors: [], failed: 0 },
+        );
+        const passed = schemas.length - failed;
+        if (passed !== 1) {
+          ctx.addIssue(
+            errors.length
+              ? {
+                  path: [],
+                  code: "invalid_union",
+                  errors: [errors],
+                  message:
+                    "Invalid input: Should pass single schema. Passed " +
+                    passed,
+                }
+              : {
+                  path: [],
+                  code: "custom",
+                  errors: [errors],
+                  message:
+                    "Invalid input: Should pass single schema. Passed " +
+                    passed,
+                },
+          );
+        }
+      })
+      .optional(),
+  })
+  .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: "addChecklistItem",
+  title: "Add Checklist Item",
+  description: "Add an item to a checklist.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}/checkItems`;
+    const body: Record<string, unknown> = {};
+    if (input.name !== undefined) body["name"] = input.name;
+    if (input.pos !== undefined) body["pos"] = input.pos;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/addMemberToBoard.ts

@@ -0,0 +1,57 @@
+#!/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."),
+    email: z.string().describe("Member email to invite/add."),
+    type: z
+      .enum(["normal", "admin", "observer"])
+      .describe("Membership type.")
+      .optional(),
+    fullName: z
+      .string()
+      .describe("Display name when inviting by email.")
+      .optional(),
+  })
+  .strict();
+const outputSchema = z.object({ status: z.number() });
+
+const definition = defineTool({
+  name: "addMemberToBoard",
+  title: "Add Member To Board",
+  description: "Add a member to a board by member id or email.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/memberships`;
+    const body: Record<string, unknown> = {};
+    if (input.email !== undefined) body["email"] = input.email;
+    if (input.type !== undefined) body["type"] = input.type;
+    if (input.fullName !== undefined) body["fullName"] = input.fullName;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addMemberToBoard ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/archiveCard.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Authored by the implementation agent: thin intent wrapper over PUT /cards/{id} (closed=true).
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import {
+  TRELLO_BASE,
+  TRELLO_ID_REGEX,
+  trelloError,
+  trelloFormBody,
+  trelloFormHeaders,
+} from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex card id to archive."),
+    closed: z
+      .boolean()
+      .default(true)
+      .describe("Archive when true (default); set false to reopen."),
+  })
+  .strict();
+
+const outputSchema = z.object({
+  id: z.string().regex(TRELLO_ID_REGEX),
+  name: z.string(),
+  closed: z.boolean(),
+  idBoard: z.string(),
+  idList: z.string(),
+  url: z.string(),
+  shortUrl: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "archiveCard",
+  title: "Archive Card",
+  description:
+    "Archive (close) a card by id. Prefer this over updateCard when the job is only archiving. Reopen with closed=false.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: trelloFormHeaders,
+      body: trelloFormBody({ closed: input.closed }),
+    });
+    if (!res.ok) await trelloError("archiveCard", res);
+    const card = (await res.json()) as z.infer<typeof outputSchema>;
+    if (input.closed && card.closed) {
+      return card;
+    }
+    return card;
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/closeBoard.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."),
+    closed: z
+      .boolean()
+      .default(true)
+      .describe("Set true to archive the board."),
+  })
+  .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: "closeBoard",
+  title: "Close Board",
+  description: "Archive (close) a board by setting closed to true.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}`;
+    const body: Record<string, unknown> = {};
+    if (input.closed !== undefined) body["closed"] = input.closed;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello closeBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/completeChecklistItem.ts

@@ -0,0 +1,56 @@
+#!/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."),
+    idCheckItem: z.string(),
+    state: z.enum(["complete", "incomplete"]),
+  })
+  .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: "completeChecklistItem",
+  title: "Complete Checklist Item",
+  description: "Mark a checklist item complete or incomplete.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/checkItem/${encodeURIComponent(input.idCheckItem)}`;
+    const body: Record<string, unknown> = {};
+    if (input.state !== undefined) body["state"] = input.state;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello completeChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/copyBoard.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import {
+  TRELLO_BASE,
+  trelloError,
+  trelloFormBody,
+  trelloFormHeaders,
+} from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex board id."),
+    name: z.string().describe("Name for the copy.").optional(),
+    idOrganization: z.string().describe("Destination workspace id.").optional(),
+    keepFromSource: z
+      .string()
+      .describe("Comma-separated props to keep, e.g. cards,labels.")
+      .optional(),
+    idBoardSource: z
+      .string()
+      .describe(
+        "Source board id (wire name idBoardSource; same as path id when omitted).",
+      )
+      .optional(),
+  })
+  .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: "copyBoard",
+  title: "Copy Board",
+  description:
+    "Copy an existing board, optionally keeping cards and changing the destination workspace.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const fields: Record<string, string | number | boolean> = {
+      idBoardSource: input.idBoardSource ?? input.id,
+    };
+    if (input.name !== undefined) fields.name = input.name;
+    if (input.idOrganization !== undefined) {
+      fields.idOrganization = input.idOrganization;
+    }
+    if (input.keepFromSource !== undefined) {
+      fields.keepFromSource = input.keepFromSource;
+    }
+    const res = await ctx.fetch(`${TRELLO_BASE}/boards`, {
+      method: "POST",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(fields),
+    });
+    if (!res.ok) await trelloError("copyBoard", res);
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/createBoard.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    name: z.string().describe("Board name."),
+    desc: z.string().describe("Board description.").optional(),
+    idOrganization: z
+      .string()
+      .describe("Workspace (organization) id. Resolve via listOrganizations.")
+      .optional(),
+    defaultLists: z
+      .boolean()
+      .describe("Create default To Do / Doing / Done lists. Default true.")
+      .optional(),
+  })
+  .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: "createBoard",
+  title: "Create Board",
+  description: "Create a new Trello board in a workspace.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards`;
+    const body: Record<string, unknown> = {};
+    if (input.name !== undefined) body["name"] = input.name;
+    if (input.desc !== undefined) body["desc"] = input.desc;
+    if (input.idOrganization !== undefined)
+      body["idOrganization"] = input.idOrganization;
+    if (input.defaultLists !== undefined)
+      body["defaultLists"] = input.defaultLists;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });