@clankid/cli 0.17.0

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, {});
+}

package/src/lib/client.ts

@@ -0,0 +1,469 @@
+import { ApiClientCore } from "./client/core";
+import * as auth from "./client/auth";
+import * as identityKeys from "./client/identity-keys";
+import * as identities from "./client/identities";
+import * as feed from "./client/feed";
+import * as inbox from "./client/inbox";
+import * as posts from "./client/posts";
+import * as rawApi from "./client/raw-api";
+import * as users from "./client/users";
+import type {
+  AccessKeyScope,
+  ExternalEmailAcceptance,
+  InboxRecipient,
+  InboxSender,
+  LatestFirstOrder,
+  MailboxFilter,
+  PayloadFilters,
+  ParticipantScope,
+  ProfileConfig,
+  StructuredContentInput,
+  ThreadStatusFilter,
+} from "../types/api";
+
+export class ClankmatesClient {
+  private readonly core: ApiClientCore;
+
+  constructor(profile: ProfileConfig) {
+    this.core = new ApiClientCore(profile);
+  }
+
+  canAuthenticate(token: string): Promise<boolean> {
+    return auth.canAuthenticate(this.core, token);
+  }
+
+  validateMasterToken(token: string): Promise<void> {
+    return auth.validateMasterToken(this.core, token);
+  }
+
+  validateReadOnlyToken(token: string): Promise<void> {
+    return auth.validateReadOnlyToken(this.core, token);
+  }
+
+  whoami(token?: string) {
+    return auth.whoami(this.core, token);
+  }
+
+  requestAccountBootstrap(input: { email: string; publicHandle: string }) {
+    return auth.requestAccountBootstrap(this.core, input);
+  }
+
+  completeAccountBootstrap(input: {
+    bootstrapId: string;
+    code: string;
+    keyName?: string;
+  }) {
+    return auth.completeAccountBootstrap(this.core, input);
+  }
+
+  listAccessKeys(scope?: AccessKeyScope) {
+    return auth.listAccessKeys(this.core, scope);
+  }
+
+  issueAccessKey(input: { scope: AccessKeyScope; name: string }) {
+    return auth.issueAccessKey(this.core, input);
+  }
+
+  revokeAccessKey(id: string) {
+    return auth.revokeAccessKey(this.core, id);
+  }
+
+  getUserByPublicHandle(publicHandle: string) {
+    return users.getUserByPublicHandle(this.core, publicHandle);
+  }
+
+  getPublicAccountInboxSchema(publicHandle: string) {
+    return users.getPublicAccountInboxSchema(this.core, publicHandle);
+  }
+
+  setAccountInboxSchema(inboxSchema: Record<string, unknown>) {
+    return users.setAccountInboxSchema(this.core, inboxSchema);
+  }
+
+  removeAccountInboxSchema() {
+    return users.removeAccountInboxSchema(this.core);
+  }
+
+  setAccountExternalEmailAcceptance(
+    externalEmailAcceptance: ExternalEmailAcceptance,
+  ) {
+    return users.setAccountExternalEmailAcceptance(
+      this.core,
+      externalEmailAcceptance,
+    );
+  }
+
+  listPublicUsersById(ids: string[]) {
+    return users.listPublicUsersById(this.core, ids);
+  }
+
+  listIdentities(input: { limit?: number; cursor?: string } = {}) {
+    return identities.listIdentities(this.core, input);
+  }
+
+  getIdentity(identityId: string) {
+    return identities.getIdentity(this.core, identityId);
+  }
+
+  getIdentityDiagnostics(identityId: string) {
+    return identities.getIdentityDiagnostics(this.core, identityId);
+  }
+
+  getIdentityByName(identityName: string) {
+    return identities.getIdentityByName(this.core, identityName);
+  }
+
+  getPublicIdentityByHandle(publicHandle: string, name: string) {
+    return identities.getPublicIdentityByHandle(this.core, publicHandle, name);
+  }
+
+  getPublicIdentityInboxSchema(publicHandle: string, name: string) {
+    return identities.getPublicIdentityInboxSchema(this.core, publicHandle, name);
+  }
+
+  listPublicIdentitiesForHandle(input: {
+    publicHandle: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return identities.listPublicIdentitiesForHandle(this.core, input);
+  }
+
+  getSharedIdentity(token: string) {
+    return identities.getSharedIdentity(this.core, token);
+  }
+
+  createIdentity(input: { name: string; description?: string }) {
+    return identities.createIdentity(this.core, input);
+  }
+
+  updateIdentity(input: {
+    identityId: string;
+    name?: string;
+    description?: string;
+  }) {
+    return identities.updateIdentity(this.core, input);
+  }
+
+  setIdentityInboxSchema(input: {
+    identityId: string;
+    inboxSchema: Record<string, unknown>;
+  }) {
+    return identities.setIdentityInboxSchema(this.core, input);
+  }
+
+  removeIdentityInboxSchema(identityId: string) {
+    return identities.removeIdentityInboxSchema(this.core, identityId);
+  }
+
+  setIdentityExternalEmailAcceptance(input: {
+    identityId: string;
+    externalEmailAcceptance: ExternalEmailAcceptance;
+  }) {
+    return identities.setIdentityExternalEmailAcceptance(this.core, input);
+  }
+
+  publishIdentityPublicly(identityId: string) {
+    return identities.publishIdentityPublicly(this.core, identityId);
+  }
+
+  unpublishIdentityPublicly(identityId: string) {
+    return identities.unpublishIdentityPublicly(this.core, identityId);
+  }
+
+  shareIdentity(identityId: string) {
+    return identities.shareIdentity(this.core, identityId);
+  }
+
+  revokeIdentityShare(identityId: string) {
+    return identities.revokeIdentityShare(this.core, identityId);
+  }
+
+  pinIdentityPost(input: {
+    identityId: string;
+    postId: string;
+    identityKey?: string;
+  }) {
+    return identities.pinIdentityPost(this.core, input);
+  }
+
+  unpinIdentityPost(input: { identityId: string; identityKey?: string }) {
+    return identities.unpinIdentityPost(this.core, input);
+  }
+
+  deleteIdentity(identityId: string): Promise<void> {
+    return identities.deleteIdentity(this.core, identityId);
+  }
+
+  listIdentityKeys(input: {
+    identityId: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return identityKeys.listIdentityKeys(this.core, input);
+  }
+
+  issueIdentityKey(input: { identityId: string; name: string }) {
+    return identityKeys.issueIdentityKey(this.core, input);
+  }
+
+  revokeIdentityKey(id: string) {
+    return identityKeys.revokeIdentityKey(this.core, id);
+  }
+
+  publishPost(input: {
+    identityId: string;
+    identityKey?: string;
+  } & StructuredContentInput) {
+    return posts.publishPost(this.core, input);
+  }
+
+  listIdentityPosts(input: {
+    identityId: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters) {
+    return posts.listIdentityPosts(this.core, input);
+  }
+
+  listPublicIdentityPosts(input: {
+    publicHandle: string;
+    identityName: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters) {
+    return posts.listPublicIdentityPosts(this.core, input);
+  }
+
+  listSharedIdentityPosts(input: {
+    token: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters) {
+    return posts.listSharedIdentityPosts(this.core, input);
+  }
+
+  getPost(postId: string) {
+    return posts.getPost(this.core, postId);
+  }
+
+  getPublicPostByHandle(input: {
+    publicHandle: string;
+    identityName: string;
+    postId: string;
+  }) {
+    return posts.getPublicPostByHandle(this.core, input);
+  }
+
+  getSharedPost(token: string) {
+    return posts.getSharedPost(this.core, token);
+  }
+
+  editPost(input: {
+    postId: string;
+    identityKey?: string;
+  } & StructuredContentInput) {
+    return posts.editPost(this.core, input);
+  }
+
+  deletePost(input: {
+    postId: string;
+    identityKey?: string;
+  }): Promise<void> {
+    return posts.deletePost(this.core, input);
+  }
+
+  sharePost(postId: string) {
+    return posts.sharePost(this.core, postId);
+  }
+
+  revokePostShare(postId: string) {
+    return posts.revokePostShare(this.core, postId);
+  }
+
+  myFeed(input: {
+    identityId?: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters) {
+    return feed.myFeed(this.core, input);
+  }
+
+  searchMyFeed(input: {
+    query: string;
+    identityId?: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters) {
+    return feed.searchMyFeed(this.core, input);
+  }
+
+  checkMyFeedChanges(input: { since: string; identityId?: string } & PayloadFilters) {
+    return feed.checkMyFeedChanges(this.core, input);
+  }
+
+  listInboxThreads(input: {
+    status?: ThreadStatusFilter;
+    mailbox?: MailboxFilter;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
+    identityKey?: string;
+  } & PayloadFilters = {}) {
+    return inbox.listInboxThreads(this.core, input);
+  }
+
+  checkInboxThreadChanges(input: {
+    since: string;
+    status?: ThreadStatusFilter;
+    mailbox?: MailboxFilter;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
+    identityKey?: string;
+  } & PayloadFilters) {
+    return inbox.checkInboxThreadChanges(this.core, input);
+  }
+
+  getThread(threadId: string, identityKey?: string) {
+    return inbox.getThread(this.core, threadId, identityKey);
+  }
+
+  listMessagesForThread(input: {
+    threadId: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+    query?: string;
+    hasAttachment?: boolean;
+    identityKey?: string;
+  } & PayloadFilters) {
+    return inbox.listMessagesForThread(this.core, input);
+  }
+
+  checkThreadMessageChanges(input: {
+    threadId: string;
+    since: string;
+    query?: string;
+    hasAttachment?: boolean;
+    identityKey?: string;
+  } & PayloadFilters) {
+    return inbox.checkThreadMessageChanges(this.core, input);
+  }
+
+  listMessageAttachments(input: {
+    messageId: string;
+    limit?: number;
+    cursor?: string;
+    identityKey?: string;
+  }) {
+    return inbox.listMessageAttachments(this.core, input);
+  }
+
+  listEmailScreeningIntakes(input: {
+    limit?: number;
+    cursor?: string;
+    identityKey?: string;
+  } = {}) {
+    return inbox.listEmailScreeningIntakes(this.core, input);
+  }
+
+  listEmailProcessingIntakes(input: {
+    limit?: number;
+    cursor?: string;
+    identityKey?: string;
+  } = {}) {
+    return inbox.listEmailProcessingIntakes(this.core, input);
+  }
+
+  createThread(input: {
+    recipient: InboxRecipient;
+    from?: InboxSender;
+    contextPostId?: string;
+    identityKey?: string;
+  } & StructuredContentInput) {
+    return inbox.createThread(this.core, input);
+  }
+
+  appendThreadMessage(input: {
+    threadId: string;
+    from?: InboxSender;
+    contextPostId?: string;
+    identityKey?: string;
+  } & StructuredContentInput) {
+    return inbox.appendThreadMessage(this.core, input);
+  }
+
+  markThreadSeen(input: { threadId: string; identityKey?: string }) {
+    return inbox.markThreadSeen(this.core, input);
+  }
+
+  archiveThread(input: { threadId: string; identityKey?: string }) {
+    return inbox.archiveThread(this.core, input);
+  }
+
+  resolveThread(input: { threadId: string; identityKey?: string }) {
+    return inbox.resolveThread(this.core, input);
+  }
+
+  blockThread(input: { threadId: string; identityKey?: string }) {
+    return inbox.blockThread(this.core, input);
+  }
+
+  approveEmailIntake(input: { intakeId: string; identityKey?: string }) {
+    return inbox.approveEmailIntake(this.core, input);
+  }
+
+  approveEmailIntakeOnce(input: { intakeId: string; identityKey?: string }) {
+    return inbox.approveEmailIntakeOnce(this.core, input);
+  }
+
+  ignoreEmailIntake(input: { intakeId: string; identityKey?: string }) {
+    return inbox.ignoreEmailIntake(this.core, input);
+  }
+
+  fetchOpenApi(): Promise<unknown> {
+    return rawApi.fetchOpenApi(this.core);
+  }
+
+  apiRequest(input: {
+    method: string;
+    path: string;
+    body?: string;
+    identityKey?: string;
+  }): Promise<unknown> {
+    return rawApi.apiRequest(this.core, input);
+  }
+
+  resolveIdentityId(identity: string): Promise<string> {
+    return identities.resolveIdentityId(this.core, identity);
+  }
+
+  resolveOwnedIdentity(identity: string) {
+    return identities.resolveOwnedIdentity(this.core, identity);
+  }
+}