@clankid/cli 0.17.0

package/src/lib/client/feed.ts

@@ -0,0 +1,93 @@
+import { requireOwnerReadToken } from "../tokens";
+import type {
+  ChangeCheckResponse,
+  LatestFirstOrder,
+  PayloadFilters,
+  PostAttributes,
+} from "../../types/api";
+import { API_PREFIX, withQuery, type ApiClientCore } from "./core";
+
+export async function myFeed(
+  core: ApiClientCore,
+  input: {
+    identityId?: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters,
+) {
+  return core.requestCollection<PostAttributes>(
+    withQuery(`${API_PREFIX}/feeds/my`, {
+      identity_id: input.identityId,
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      content_format: input.contentFormat,
+      payload_contains: input.payloadContains,
+      payload_path: input.payloadPath,
+      payload_op: input.payloadOp,
+      payload_value: input.payloadValue,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function searchMyFeed(
+  core: ApiClientCore,
+  input: {
+    query: string;
+    identityId?: string;
+    limit?: number;
+    cursor?: string;
+    before?: string;
+    order?: LatestFirstOrder;
+    since?: string;
+  } & PayloadFilters,
+) {
+  return core.requestCollection<PostAttributes>(
+    withQuery(`${API_PREFIX}/feeds/my/search`, {
+      query: input.query,
+      identity_id: input.identityId,
+      order: input.order,
+      since: input.since,
+      before: input.before,
+      content_format: input.contentFormat,
+      payload_contains: input.payloadContains,
+      payload_path: input.payloadPath,
+      payload_op: input.payloadOp,
+      payload_value: input.payloadValue,
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function checkMyFeedChanges(
+  core: ApiClientCore,
+  input: { since: string; identityId?: string } & PayloadFilters,
+) {
+  return core.requestAction<ChangeCheckResponse>(
+    withQuery(`${API_PREFIX}/feeds/my/changes`, {
+      since: input.since,
+      identity_id: input.identityId,
+      identity_ids: undefined,
+      content_format: input.contentFormat,
+      payload_contains: input.payloadContains,
+      payload_path: input.payloadPath,
+      payload_op: input.payloadOp,
+      payload_value: input.payloadValue,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}

package/src/lib/client/identities.ts

@@ -0,0 +1,364 @@
+import { CliError } from "../errors";
+import {
+  requireMasterToken,
+  requireOwnerReadToken,
+  resolveOwnerReadToken,
+} from "../tokens";
+import type {
+  IdentityAttributes,
+  IdentityDiagnosticsResponse,
+  IdentityPinResponse,
+  IdentityPublicationResponse,
+  ExternalEmailAcceptance,
+  IdResponse,
+  ShareTokenResponse,
+} from "../../types/api";
+import {
+  API_PREFIX,
+  looksLikeUuid,
+  withQuery,
+  type ApiClientCore,
+} from "./core";
+
+export async function listIdentities(
+  core: ApiClientCore,
+  input: { limit?: number; cursor?: string } = {},
+) {
+  return core.requestCollection<IdentityAttributes>(
+    withQuery(`${API_PREFIX}/identities`, {
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function getIdentity(core: ApiClientCore, identityId: string) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${identityId}`,
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function getIdentityDiagnostics(
+  core: ApiClientCore,
+  identityId: string,
+) {
+  return core.requestAction<IdentityDiagnosticsResponse>(
+    `${API_PREFIX}/identities/${identityId}/diagnostics`,
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function getIdentityByName(
+  core: ApiClientCore,
+  identityName: string,
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/by-name/${encodeURIComponent(identityName)}`,
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function getPublicIdentityByHandle(
+  core: ApiClientCore,
+  publicHandle: string,
+  name: string,
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/identities/${encodeURIComponent(name)}`,
+    {},
+  );
+}
+
+export async function getPublicIdentityInboxSchema(
+  core: ApiClientCore,
+  publicHandle: string,
+  name: string,
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/identities/${encodeURIComponent(name)}/inbox-schema`,
+    {},
+  );
+}
+
+export async function listPublicIdentitiesForHandle(
+  core: ApiClientCore,
+  input: {
+    publicHandle: string;
+    limit?: number;
+    cursor?: string;
+  },
+) {
+  return core.requestCollection<IdentityAttributes>(
+    withQuery(
+      `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/identities`,
+      {
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      },
+    ),
+    {},
+  );
+}
+
+export async function getSharedIdentity(core: ApiClientCore, token: string) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/shares/identities/${encodeURIComponent(token)}`,
+    {},
+  );
+}
+
+export async function createIdentity(
+  core: ApiClientCore,
+  input: { name: string; description?: string },
+) {
+  return core.requestResource<IdentityAttributes>(`${API_PREFIX}/identities`, {
+    method: "POST",
+    token: requireMasterToken(core.profile),
+    body: {
+      data: {
+        type: "identity",
+        attributes: {
+          name: input.name,
+          ...(input.description ? { description: input.description } : {}),
+        },
+      },
+    },
+  });
+}
+
+export async function updateIdentity(
+  core: ApiClientCore,
+  input: {
+    identityId: string;
+    name?: string;
+    description?: string;
+  },
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${input.identityId}`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "identity",
+          id: input.identityId,
+          attributes: {
+            ...(input.name !== undefined ? { name: input.name } : {}),
+            ...(input.description !== undefined
+              ? { description: input.description }
+              : {}),
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function setIdentityInboxSchema(
+  core: ApiClientCore,
+  input: {
+    identityId: string;
+    inboxSchema: Record<string, unknown>;
+  },
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${input.identityId}/inbox-schema`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "identity",
+          id: input.identityId,
+          attributes: {
+            inbox_schema: input.inboxSchema,
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function removeIdentityInboxSchema(
+  core: ApiClientCore,
+  identityId: string,
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${identityId}/inbox-schema/remove`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "identity",
+          id: identityId,
+          attributes: {},
+        },
+      },
+    },
+  );
+}
+
+export async function setIdentityExternalEmailAcceptance(
+  core: ApiClientCore,
+  input: {
+    identityId: string;
+    externalEmailAcceptance: ExternalEmailAcceptance;
+  },
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${input.identityId}/inbox-acceptance`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "identity",
+          id: input.identityId,
+          attributes: {
+            external_email_acceptance: input.externalEmailAcceptance,
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function publishIdentityPublicly(
+  core: ApiClientCore,
+  identityId: string,
+) {
+  return core.requestResource<IdentityAttributes>(
+    `${API_PREFIX}/identities/${identityId}/publication`,
+    {
+      method: "PATCH",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          type: "identity",
+          id: identityId,
+        },
+      },
+    },
+  );
+}
+
+export async function unpublishIdentityPublicly(
+  core: ApiClientCore,
+  identityId: string,
+) {
+  return core.requestAction<IdentityPublicationResponse>(
+    `${API_PREFIX}/identities/${identityId}/publication`,
+    {
+      method: "DELETE",
+      token: requireMasterToken(core.profile),
+    },
+  );
+}
+
+export async function shareIdentity(core: ApiClientCore, identityId: string) {
+  return core.requestAction<ShareTokenResponse>(
+    `${API_PREFIX}/identities/${identityId}/share`,
+    {
+      method: "POST",
+      token: requireMasterToken(core.profile),
+      body: { data: {} },
+    },
+  );
+}
+
+export async function revokeIdentityShare(
+  core: ApiClientCore,
+  identityId: string,
+) {
+  return core.requestAction<IdResponse>(`${API_PREFIX}/identities/${identityId}/share`, {
+    method: "DELETE",
+    token: requireMasterToken(core.profile),
+  });
+}
+
+export async function pinIdentityPost(
+  core: ApiClientCore,
+  input: {
+    identityId: string;
+    postId: string;
+    identityKey?: string;
+  },
+) {
+  return core.requestAction<IdentityPinResponse>(
+    `${API_PREFIX}/identities/${input.identityId}/pinned-post`,
+    {
+      method: "POST",
+      token: core.resolveIdentityConfigKey(input.identityId, input.identityKey),
+      body: {
+        data: {
+          attributes: {
+            post_id: input.postId,
+          },
+        },
+      },
+    },
+  );
+}
+
+export async function unpinIdentityPost(
+  core: ApiClientCore,
+  input: { identityId: string; identityKey?: string },
+) {
+  return core.requestAction<IdentityPinResponse>(
+    `${API_PREFIX}/identities/${input.identityId}/pinned-post`,
+    {
+      method: "DELETE",
+      token: core.resolveIdentityConfigKey(input.identityId, input.identityKey),
+    },
+  );
+}
+
+export async function deleteIdentity(
+  core: ApiClientCore,
+  identityId: string,
+): Promise<void> {
+  await core.requestJsonApi(`${API_PREFIX}/identities/${identityId}`, {
+    method: "DELETE",
+    token: requireMasterToken(core.profile),
+  });
+}
+
+export async function resolveIdentityId(
+  core: ApiClientCore,
+  identity: string,
+): Promise<string> {
+  if (looksLikeUuid(identity)) {
+    return identity;
+  }
+
+  return (await resolveOwnedIdentity(core, identity)).id;
+}
+
+export async function resolveOwnedIdentity(
+  core: ApiClientCore,
+  identity: string,
+) {
+  if (looksLikeUuid(identity)) {
+    return getIdentity(core, identity);
+  }
+
+  if (!resolveOwnerReadToken(core.profile).token) {
+    throw new CliError(
+      `Resolving identity name "${identity}" requires an owner read token. Use the identity UUID or configure a read-only or master token.`,
+    );
+  }
+
+  return getIdentityByName(core, identity);
+}

package/src/lib/client/identity-keys.ts

@@ -0,0 +1,57 @@
+import {
+  requireMasterToken,
+  requireOwnerReadToken,
+} from "../tokens";
+import type {
+  IdentityKeyAttributes,
+  IdentityKeyIssueResponse,
+  IdentityKeyRevokeResponse,
+} from "../../types/api";
+import { API_PREFIX, withQuery, type ApiClientCore } from "./core";
+
+export async function listIdentityKeys(
+  core: ApiClientCore,
+  input: {
+    identityId: string;
+    limit?: number;
+    cursor?: string;
+  },
+) {
+  return core.requestCollection<IdentityKeyAttributes>(
+    withQuery(`${API_PREFIX}/identities/${input.identityId}/keys`, {
+      "page[limit]": input.limit,
+      "page[after]": input.cursor,
+    }),
+    {
+      token: requireOwnerReadToken(core.profile),
+    },
+  );
+}
+
+export async function issueIdentityKey(
+  core: ApiClientCore,
+  input: { identityId: string; name: string },
+) {
+  return core.requestAction<IdentityKeyIssueResponse>(
+    `${API_PREFIX}/identities/${input.identityId}/keys`,
+    {
+      method: "POST",
+      token: requireMasterToken(core.profile),
+      body: {
+        data: {
+          name: input.name,
+        },
+      },
+    },
+  );
+}
+
+export async function revokeIdentityKey(core: ApiClientCore, id: string) {
+  return core.requestAction<IdentityKeyRevokeResponse>(
+    `${API_PREFIX}/identity-keys/${id}`,
+    {
+      method: "DELETE",
+      token: requireMasterToken(core.profile),
+    },
+  );
+}