@clankmates/cli 0.11.1 → 0.13.0

package/src/lib/client/inbox.ts

@@ -0,0 +1,361 @@
+import type {
+  ChangeCheckResponse,
+  ExternalEmailIntakeAttributes,
+  InboxRecipient,
+  InboxSender,
+  LatestFirstOrder,
+  MailboxFilter,
+  MessageAttachmentAttributes,
+  MessageAttributes,
+  ParticipantScope,
+  ThreadAttributes,
+  ThreadStatusFilter,
+} from "../../types/api";
+import { API_PREFIX, withQuery, type ApiClientCore } from "./core";
+
+export async function listInboxThreads(
+  core: ApiClientCore,
+  input: {
+    status?: ThreadStatusFilter;
+    mailbox?: MailboxFilter;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
+    channelToken?: string;
+  } = {},
+) {
+  return core.requestCollection<ThreadAttributes>(
+    withQuery(`${API_PREFIX}/threads`, {
+      status: input.status,
+      mailbox: input.mailbox,
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      participant: input.participant,
+      participant_scope: input.participantScope,
+      query: input.query,
+      has_attachment: input.hasAttachment,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function checkInboxThreadChanges(
+  core: ApiClientCore,
+  input: {
+    since: string;
+    status?: ThreadStatusFilter;
+    mailbox?: MailboxFilter;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
+    channelToken?: string;
+  },
+) {
+  return core.requestAction<ChangeCheckResponse>(
+    withQuery(`${API_PREFIX}/threads/changes`, {
+      since: input.since,
+      status: input.status,
+      mailbox: input.mailbox,
+      participant: input.participant,
+      participant_scope: input.participantScope,
+      query: input.query,
+      has_attachment: input.hasAttachment,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function getThread(
+  core: ApiClientCore,
+  threadId: string,
+  channelToken?: string,
+) {
+  return core.requestResource<ThreadAttributes>(`${API_PREFIX}/threads/${threadId}`, {
+    token: core.resolveInboxReadToken(channelToken),
+  });
+}
+
+export async function listMessagesForThread(
+  core: ApiClientCore,
+  input: {
+    threadId: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+    query?: string;
+    hasAttachment?: boolean;
+    channelToken?: string;
+  },
+) {
+  return core.requestCollection<MessageAttributes>(
+    withQuery(`${API_PREFIX}/threads/${input.threadId}/messages`, {
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      query: input.query,
+      has_attachment: input.hasAttachment,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function checkThreadMessageChanges(
+  core: ApiClientCore,
+  input: {
+    threadId: string;
+    since: string;
+    query?: string;
+    hasAttachment?: boolean;
+    channelToken?: string;
+  },
+) {
+  return core.requestAction<ChangeCheckResponse>(
+    withQuery(`${API_PREFIX}/threads/${input.threadId}/messages/changes`, {
+      since: input.since,
+      query: input.query,
+      has_attachment: input.hasAttachment,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function listMessageAttachments(
+  core: ApiClientCore,
+  input: {
+    messageId: string;
+    limit?: number;
+    cursor?: string;
+    channelToken?: string;
+  },
+) {
+  return core.requestCollection<MessageAttachmentAttributes>(
+    withQuery(`${API_PREFIX}/messages/${input.messageId}/attachments`, {
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function listEmailScreeningIntakes(
+  core: ApiClientCore,
+  input: {
+    limit?: number;
+    cursor?: string;
+    channelToken?: string;
+  } = {},
+) {
+  return core.requestCollection<ExternalEmailIntakeAttributes>(
+    withQuery(`${API_PREFIX}/email-intakes/screening`, {
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function listEmailProcessingIntakes(
+  core: ApiClientCore,
+  input: {
+    limit?: number;
+    cursor?: string;
+    channelToken?: string;
+  } = {},
+) {
+  return core.requestCollection<ExternalEmailIntakeAttributes>(
+    withQuery(`${API_PREFIX}/email-intakes/processing`, {
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: core.resolveInboxReadToken(input.channelToken),
+    },
+  );
+}
+
+export async function createThread(
+  core: ApiClientCore,
+  input: {
+    recipient: InboxRecipient;
+    body?: string;
+    payload?: Record<string, unknown>;
+    from?: InboxSender;
+    contextPostId?: string;
+    channelToken?: string;
+  },
+) {
+  return core.requestResource<ThreadAttributes>(`${API_PREFIX}/threads`, {
+    method: "POST",
+    token: core.resolveInboxWriteToken(input.channelToken),
+    body: {
+      data: {
+        type: "thread",
+        attributes: {
+          recipient: input.recipient,
+          ...(input.body !== undefined ? { body: input.body } : {}),
+          ...(input.payload !== undefined ? { payload: input.payload } : {}),
+          ...(input.from ? { from: input.from } : {}),
+          ...(input.contextPostId
+            ? { context_post_id: input.contextPostId }
+            : {}),
+        },
+      },
+    },
+  });
+}
+
+export async function appendThreadMessage(
+  core: ApiClientCore,
+  input: {
+    threadId: string;
+    body?: string;
+    payload?: Record<string, unknown>;
+    from?: InboxSender;
+    contextPostId?: string;
+    channelToken?: string;
+  },
+) {
+  return core.requestResource<ThreadAttributes>(
+    `${API_PREFIX}/threads/${input.threadId}/messages`,
+    {
+      method: "POST",
+      token: core.resolveInboxWriteToken(input.channelToken),
+      body: {
+        data: {
+          type: "thread",
+          attributes: {
+            ...(input.body !== undefined ? { body: input.body } : {}),
+            ...(input.payload !== undefined ? { payload: input.payload } : {}),
+            ...(input.from ? { from: input.from } : {}),
+            ...(input.contextPostId
+              ? { context_post_id: input.contextPostId }
+              : {}),
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function markThreadSeen(
+  core: ApiClientCore,
+  input: { threadId: string; channelToken?: string },
+) {
+  return updateThreadLifecycle(core, `${API_PREFIX}/threads/${input.threadId}/seen`, input);
+}
+
+export async function archiveThread(
+  core: ApiClientCore,
+  input: { threadId: string; channelToken?: string },
+) {
+  return updateThreadLifecycle(core, `${API_PREFIX}/threads/${input.threadId}/archive`, input);
+}
+
+export async function resolveThread(
+  core: ApiClientCore,
+  input: { threadId: string; channelToken?: string },
+) {
+  return updateThreadLifecycle(core, `${API_PREFIX}/threads/${input.threadId}/resolve`, input);
+}
+
+export async function blockThread(
+  core: ApiClientCore,
+  input: { threadId: string; channelToken?: string },
+) {
+  return updateThreadLifecycle(core, `${API_PREFIX}/threads/${input.threadId}/block`, input);
+}
+
+export async function approveEmailIntake(
+  core: ApiClientCore,
+  input: { intakeId: string; channelToken?: string },
+) {
+  return updateEmailIntake(
+    core,
+    `${API_PREFIX}/email-intakes/${input.intakeId}/approve`,
+    input,
+  );
+}
+
+export async function approveEmailIntakeOnce(
+  core: ApiClientCore,
+  input: { intakeId: string; channelToken?: string },
+) {
+  return updateEmailIntake(
+    core,
+    `${API_PREFIX}/email-intakes/${input.intakeId}/approve-once`,
+    input,
+  );
+}
+
+export async function ignoreEmailIntake(
+  core: ApiClientCore,
+  input: { intakeId: string; channelToken?: string },
+) {
+  return updateEmailIntake(
+    core,
+    `${API_PREFIX}/email-intakes/${input.intakeId}/ignore`,
+    input,
+  );
+}
+
+async function updateThreadLifecycle(
+  core: ApiClientCore,
+  path: string,
+  input: { threadId: string; channelToken?: string },
+) {
+  return core.requestResource<ThreadAttributes>(path, {
+    method: "PATCH",
+    token: core.resolveInboxWriteToken(input.channelToken),
+    body: {
+      data: {
+        type: "thread",
+        id: input.threadId,
+        attributes: {},
+      },
+    },
+  });
+}
+
+async function updateEmailIntake(
+  core: ApiClientCore,
+  path: string,
+  input: { intakeId: string; channelToken?: string },
+) {
+  return core.requestResource<ExternalEmailIntakeAttributes>(path, {
+    method: "PATCH",
+    token: core.resolveInboxWriteToken(input.channelToken),
+    body: {
+      data: {
+        type: "external_email_intake",
+        id: input.intakeId,
+        attributes: {},
+      },
+    },
+  });
+}

package/src/lib/client/posts.ts

@@ -0,0 +1,213 @@
+import { CliError } from "../errors";
+import {
+  requireMasterToken,
+  requireOwnerReadToken,
+  resolvePublishToken,
+} from "../tokens";
+import type {
+  IdResponse,
+  LatestFirstOrder,
+  PostAttributes,
+  ShareTokenResponse,
+} from "../../types/api";
+import { API_PREFIX, withQuery, type ApiClientCore } from "./core";
+
+export async function publishPost(
+  core: ApiClientCore,
+  input: {
+    channelId: string;
+    body: string;
+    channelToken?: string;
+  },
+) {
+  const resolved = resolvePublishToken(
+    core.profile,
+    input.channelId,
+    input.channelToken,
+  );
+
+  if (!resolved.token) {
+    throw new CliError(
+      `No publish token available for channel ${input.channelId}. Provide --channel-token, set channel token env vars, save a channel token, or configure a master token.`,
+    );
+  }
+
+  return core.requestResource<PostAttributes>(
+    `${API_PREFIX}/channels/${input.channelId}/posts`,
+    {
+      method: "POST",
+      token: resolved.token,
+      body: {
+        data: {
+          type: "post",
+          attributes: {
+            body: input.body,
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function listChannelPosts(
+  core: ApiClientCore,
+  input: {
+    channelId: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  },
+) {
+  return core.requestCollection<PostAttributes>(
+    withQuery(`${API_PREFIX}/channels/${input.channelId}/posts`, {
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function listPublicChannelPosts(
+  core: ApiClientCore,
+  input: {
+    publicHandle: string;
+    channelName: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  },
+) {
+  return core.requestCollection<PostAttributes>(
+    withQuery(
+      `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/channels/${encodeURIComponent(input.channelName)}/posts`,
+      {
+        order: input.order,
+        since: input.since,
+        before: input.before,
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      },
+    ),
+    {},
+  );
+}
+
+export async function listSharedChannelPosts(
+  core: ApiClientCore,
+  input: {
+    token: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  },
+) {
+  return core.requestCollection<PostAttributes>(
+    withQuery(`${API_PREFIX}/shares/channels/${encodeURIComponent(input.token)}/posts`, {
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {},
+  );
+}
+
+export async function getPost(core: ApiClientCore, postId: string) {
+  return core.requestResource<PostAttributes>(
+    `${API_PREFIX}/posts/${postId}`,
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function getPublicPostByHandle(
+  core: ApiClientCore,
+  input: {
+    publicHandle: string;
+    channelName: string;
+    postId: string;
+  },
+) {
+  return core.requestResource<PostAttributes>(
+    `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/channels/${encodeURIComponent(input.channelName)}/posts/${input.postId}`,
+    {},
+  );
+}
+
+export async function getSharedPost(core: ApiClientCore, token: string) {
+  return core.requestResource<PostAttributes>(
+    `${API_PREFIX}/shares/posts/${encodeURIComponent(token)}`,
+    {},
+  );
+}
+
+export async function editPost(
+  core: ApiClientCore,
+  input: {
+    postId: string;
+    body: string;
+    channelToken?: string;
+  },
+) {
+  const token = core.resolvePostLifecycleToken(input.channelToken);
+
+  return core.requestResource<PostAttributes>(
+    `${API_PREFIX}/posts/${input.postId}`,
+    {
+      method: "PATCH",
+      token,
+      body: {
+        data: {
+          type: "post",
+          id: input.postId,
+          attributes: {
+            body: input.body,
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function deletePost(
+  core: ApiClientCore,
+  input: {
+    postId: string;
+    channelToken?: string;
+  },
+): Promise<void> {
+  const token = core.resolvePostLifecycleToken(input.channelToken);
+
+  await core.requestJsonApi(`${API_PREFIX}/posts/${input.postId}`, {
+    method: "DELETE",
+    token,
+  });
+}
+
+export async function sharePost(core: ApiClientCore, postId: string) {
+  return core.requestAction<ShareTokenResponse>(`${API_PREFIX}/posts/${postId}/share`, {
+    method: "POST",
+    token: requireMasterToken(core.profile),
+    body: { data: {} },
+  });
+}
+
+export async function revokePostShare(core: ApiClientCore, postId: string) {
+  return core.requestAction<IdResponse>(`${API_PREFIX}/posts/${postId}/share`, {
+    method: "DELETE",
+    token: requireMasterToken(core.profile),
+  });
+}

package/src/lib/client/raw-api.ts

@@ -0,0 +1,33 @@
+import { requestJson } from "../http";
+import { resolveMasterToken } from "../tokens";
+import {
+  API_PREFIX,
+  inferMediaType,
+  type ApiClientCore,
+} from "./core";
+
+export async function fetchOpenApi(core: ApiClientCore): Promise<unknown> {
+  return (await requestJson(core.profile.baseUrl, `${API_PREFIX}/open_api`))
+    .data;
+}
+
+export async function apiRequest(
+  core: ApiClientCore,
+  input: {
+    method: string;
+    path: string;
+    body?: string;
+    channelToken?: string;
+  },
+): Promise<unknown> {
+  return (
+    await requestJson(core.profile.baseUrl, input.path, {
+      method: input.method,
+      token: input.channelToken ?? resolveMasterToken(core.profile).token,
+      rawBody: input.body,
+      accept: inferMediaType(input.path),
+      contentType:
+        input.body === undefined ? undefined : inferMediaType(input.path),
+    })
+  ).data;
+}

package/src/lib/client/users.ts

@@ -0,0 +1,88 @@
+import { requireMasterToken } from "../tokens";
+import type {
+  ExternalEmailAcceptance,
+  UserAttributes,
+} from "../../types/api";
+import {
+  API_PREFIX,
+  withRepeatedQuery,
+  type ApiClientCore,
+} from "./core";
+
+export async function getUserByPublicHandle(
+  core: ApiClientCore,
+  publicHandle: string,
+) {
+  return core.requestResource<UserAttributes>(
+    `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}`,
+    {},
+  );
+}
+
+export async function getPublicAccountInboxSchema(
+  core: ApiClientCore,
+  publicHandle: string,
+) {
+  return core.requestResource<UserAttributes>(
+    `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/inbox-schema`,
+    {},
+  );
+}
+
+export async function setAccountInboxSchema(
+  core: ApiClientCore,
+  inboxSchema: Record<string, unknown>,
+) {
+  return core.requestResource<UserAttributes>(`${API_PREFIX}/me/inbox-schema`, {
+    method: "PATCH",
+    token: requireMasterToken(core.profile),
+    body: {
+      data: {
+        type: "user",
+        attributes: {
+          inbox_schema: inboxSchema,
+        },
+      },
+    },
+  });
+}
+
+export async function removeAccountInboxSchema(core: ApiClientCore) {
+  return core.requestResource<UserAttributes>(
+    `${API_PREFIX}/me/inbox-schema/remove`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "user",
+          attributes: {},
+        },
+      },
+    },
+  );
+}
+
+export async function setAccountExternalEmailAcceptance(
+  core: ApiClientCore,
+  externalEmailAcceptance: ExternalEmailAcceptance,
+) {
+  return core.requestResource<UserAttributes>(`${API_PREFIX}/me/inbox-acceptance`, {
+    method: "PATCH",
+    token: requireMasterToken(core.profile),
+    body: {
+      data: {
+        type: "user",
+        attributes: {
+          external_email_acceptance: externalEmailAcceptance,
+        },
+      },
+    },
+  });
+}
+
+export async function listPublicUsersById(core: ApiClientCore, ids: string[]) {
+  const path = withRepeatedQuery(`${API_PREFIX}/public/users/by-id`, "ids[]", ids);
+
+  return core.requestCollection<UserAttributes>(path, {});
+}