@atproto/common-web 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atproto/common-web
 
+## 0.2.2
+
+### Patch Changes
+
+- [`35d108ce`](https://github.com/bluesky-social/atproto/commit/35d108ce94866ce1b3d147cd0620a0ba1c4ebcd7) Thanks [@devinivy](https://github.com/devinivy)! - Allow pds to serve did doc with credentials, API client to respect PDS listed in the did doc.
+
 ## 0.2.1
 
 ### Patch Changes

package/dist/async.d.ts

@@ -22,3 +22,4 @@ export declare class AsyncBuffer<T> {
 export declare class AsyncBufferFullError extends Error {
     constructor(maxSize: number);
 }
+export declare const handleAllSettledErrors: (results: PromiseSettledResult<unknown>[]) => void;

package/dist/did-doc.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const isValidDidDoc: (doc: unknown) => doc is {
+    id: string;
+    alsoKnownAs?: string[] | undefined;
+    verificationMethod?: {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+    }[] | undefined;
+    service?: {
+        id: string;
+        type: string;
+        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
+    }[] | undefined;
+};
+export declare const getDid: (doc: DidDocument) => string;
+export declare const getHandle: (doc: DidDocument) => string | undefined;
+export declare const getSigningKey: (doc: DidDocument) => {
+    type: string;
+    publicKeyMultibase: string;
+} | undefined;
+export declare const getPdsEndpoint: (doc: DidDocument) => string | undefined;
+export declare const getFeedGenEndpoint: (doc: DidDocument) => string | undefined;
+export declare const getNotifEndpoint: (doc: DidDocument) => string | undefined;
+export declare const getServiceEndpoint: (doc: DidDocument, opts: {
+    id: string;
+    type: string;
+}) => string | undefined;
+export declare const didDocument: z.ZodObject<{
+    id: z.ZodString;
+    alsoKnownAs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    verificationMethod: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        controller: z.ZodString;
+        publicKeyMultibase: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+    }, {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+    }>, "many">>;
+    service: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        serviceEndpoint: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
+    }, {
+        id: string;
+        type: string;
+        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    alsoKnownAs?: string[] | undefined;
+    verificationMethod?: {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+    }[] | undefined;
+    service?: {
+        id: string;
+        type: string;
+        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
+    }[] | undefined;
+}, {
+    id: string;
+    alsoKnownAs?: string[] | undefined;
+    verificationMethod?: {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+    }[] | undefined;
+    service?: {
+        id: string;
+        type: string;
+        serviceEndpoint: (string | Record<string, unknown>) & (string | Record<string, unknown> | undefined);
+    }[] | undefined;
+}>;
+export declare type DidDocument = z.infer<typeof didDocument>;

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from './ipld';
 export * from './types';
 export * from './times';
 export * from './strings';
+export * from './did-doc';

package/dist/index.js

@@ -8837,12 +8837,22 @@ __export(src_exports2, {
   createDeferrables: () => createDeferrables,
   dedupeStrs: () => dedupeStrs,
   def: () => def,
+  didDocument: () => didDocument,
   errHasMsg: () => errHasMsg,
   flattenUint8Arrays: () => flattenUint8Arrays,
+  getDid: () => getDid,
+  getFeedGenEndpoint: () => getFeedGenEndpoint,
+  getHandle: () => getHandle,
+  getNotifEndpoint: () => getNotifEndpoint,
+  getPdsEndpoint: () => getPdsEndpoint,
+  getServiceEndpoint: () => getServiceEndpoint,
+  getSigningKey: () => getSigningKey,
   graphemeLen: () => graphemeLen,
+  handleAllSettledErrors: () => handleAllSettledErrors,
   ipldEquals: () => ipldEquals,
   ipldToJson: () => ipldToJson,
   isErrnoException: () => isErrnoException,
+  isValidDidDoc: () => isValidDidDoc,
   jitter: () => jitter,
   jsonToIpld: () => jsonToIpld,
   lessThanAgoMs: () => lessThanAgoMs,
@@ -9108,6 +9118,19 @@ var AsyncBufferFullError = class extends Error {
     super(`ReachedMaxBufferSize: ${maxSize}`);
   }
 };
+var handleAllSettledErrors = (results) => {
+  const errors = results.filter(isRejected).map((res) => res.reason);
+  if (errors.length === 0) {
+    return;
+  }
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  throw new AggregateError(errors, "Multiple errors: " + errors.map((err) => err?.message).join("\n"));
+};
+var isRejected = (result) => {
+  return result.status === "rejected";
+};
 
 // src/tid.ts
 var TID_LEN = 13;
@@ -14055,4 +14078,114 @@ var validateLanguage = (langTag) => {
   return bcp47Regexp.test(langTag);
 };
 var bcp47Regexp = /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/;
+
+// src/did-doc.ts
+var isValidDidDoc = (doc) => {
+  return didDocument.safeParse(doc).success;
+};
+var getDid = (doc) => {
+  const id = doc.id;
+  if (typeof id !== "string") {
+    throw new Error("No `id` on document");
+  }
+  return id;
+};
+var getHandle = (doc) => {
+  const aka = doc.alsoKnownAs;
+  if (!aka)
+    return void 0;
+  const found = aka.find((name2) => name2.startsWith("at://"));
+  if (!found)
+    return void 0;
+  return found.slice(5);
+};
+var getSigningKey = (doc) => {
+  const did = getDid(doc);
+  let keys = doc.verificationMethod;
+  if (!keys)
+    return void 0;
+  if (typeof keys !== "object")
+    return void 0;
+  if (!Array.isArray(keys)) {
+    keys = [keys];
+  }
+  const found = keys.find((key) => key.id === "#atproto" || key.id === `${did}#atproto`);
+  if (!found?.publicKeyMultibase)
+    return void 0;
+  return {
+    type: found.type,
+    publicKeyMultibase: found.publicKeyMultibase
+  };
+};
+var getPdsEndpoint = (doc) => {
+  return getServiceEndpoint(doc, {
+    id: "#atproto_pds",
+    type: "AtprotoPersonalDataServer"
+  });
+};
+var getFeedGenEndpoint = (doc) => {
+  return getServiceEndpoint(doc, {
+    id: "#bsky_fg",
+    type: "BskyFeedGenerator"
+  });
+};
+var getNotifEndpoint = (doc) => {
+  return getServiceEndpoint(doc, {
+    id: "#bsky_notif",
+    type: "BskyNotificationService"
+  });
+};
+var getServiceEndpoint = (doc, opts) => {
+  const did = getDid(doc);
+  let services = doc.service;
+  if (!services)
+    return void 0;
+  if (typeof services !== "object")
+    return void 0;
+  if (!Array.isArray(services)) {
+    services = [services];
+  }
+  const found = services.find((service2) => service2.id === opts.id || service2.id === `${did}${opts.id}`);
+  if (!found)
+    return void 0;
+  if (found.type !== opts.type) {
+    return void 0;
+  }
+  if (typeof found.serviceEndpoint !== "string") {
+    return void 0;
+  }
+  return validateUrl(found.serviceEndpoint);
+};
+var validateUrl = (urlStr) => {
+  let url;
+  try {
+    url = new URL(urlStr);
+  } catch {
+    return void 0;
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    return void 0;
+  } else if (!url.hostname) {
+    return void 0;
+  } else {
+    return urlStr;
+  }
+};
+var verificationMethod = z.object({
+  id: z.string(),
+  type: z.string(),
+  controller: z.string(),
+  publicKeyMultibase: z.string().optional()
+});
+var service = z.object({
+  id: z.string(),
+  type: z.string(),
+  serviceEndpoint: z.union([z.string(), z.record(z.unknown())])
+});
+var didDocument = z.object({
+  id: z.string(),
+  alsoKnownAs: z.array(z.string()).optional(),
+  verificationMethod: z.array(verificationMethod).optional(),
+  service: z.array(service).optional()
+});
 //# sourceMappingURL=index.js.map