fix(sdk-core): fix SDS blob uploads and DRY blob/profile operations

Without this patch, blob uploads always use the PDS endpoint
(com.atproto.repo.uploadBlob) regardless of server type, and profile
operations incorrectly route through non-existent com.sds.repo.*
endpoints. This causes blob uploads to fail on SDS servers because the
repository DID is never passed.

This patch solves the problem by:

1. Using com.sds.repo.uploadBlob with the repo query parameter for SDS
   servers, and com.atproto.repo.uploadBlob for PDS servers
2. Removing incorrect SDS routing from profile operations — SDS servers
   override standard ATProto endpoints rather than exposing separate ones
3. Extracting a shared BlobOperations interface with dependency injection,
   eliminating duplicate blob upload code across HypercertOperationsImpl,
   ProfileOperationsImpl, and BlobOperationsImpl
4. Adding a ProfileOperationsImpl.create() method for creating new
   profiles without the read-modify-write pattern
5. Refactoring applyParamsToProfile with helper methods to reduce
   duplication

Co-authored-by: Claude <noreply@anthropic.com>

Author: aspiers

.changeset/fix-sds-endpoint-routing.md

@@ -0,0 +1,15 @@
+---
+"@hypercerts-org/sdk-core": patch
+---
+
+Fix SDS blob uploads, add profile creation, and refactor blob operations
+
+- Route SDS blob uploads to `com.sds.repo.uploadBlob` with repo query parameter, and PDS blob uploads to standard
+  `com.atproto.repo.uploadBlob`
+- Remove incorrect SDS routing logic from profile operations (profiles use standard ATProto endpoints on both PDS and
+  SDS)
+- DRY blob uploads: extract shared `BlobOperations` interface and use dependency injection in both
+  `ProfileOperationsImpl` and `HypercertOperationsImpl`
+- Refactor `applyParamsToProfile` to eliminate code duplication with helper methods
+- Add `create()` method to `ProfileOperationsImpl` for creating new profiles
+- Fix collection blob upload tests to mock `BlobOperations.upload` instead of `agent.uploadBlob`

packages/sdk-core/src/repository/BlobOperationsImpl.ts

@@ -57,13 +57,17 @@ export class BlobOperationsImpl implements BlobOperations {
    * @param agent - AT Protocol Agent for making API calls
    * @param repoDid - DID of the repository (used for blob retrieval)
    * @param _serverUrl - Server URL (reserved for future use)
+   * @param isSDS - Whether this is a Shared Data Server
+   * @param repo - Optional repository instance for referencing back to repository
    *
    * @internal
    */
   constructor(
     private agent: Agent,
     private repoDid: string,
     private _serverUrl: string,
+    private isSDS: boolean,
+    private repo?: unknown,
   ) {}
 
   /**
@@ -112,9 +116,16 @@ export class BlobOperationsImpl implements BlobOperations {
     try {
       const arrayBuffer = await blob.arrayBuffer();
       const uint8Array = new Uint8Array(arrayBuffer);
+      const encoding = blob.type || "application/octet-stream";
+
+      // Use SDS endpoint if available, otherwise use standard PDS endpoint
+      // SDS has a dedicated uploadBlob endpoint that accepts the repo param
+      if (this.isSDS) {
+        return await this.uploadViaSDS(uint8Array, encoding);
+      }
 
       const result = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
-        encoding: blob.type || "application/octet-stream",
+        encoding,
       });
 
       if (!result.success) {
@@ -135,6 +146,54 @@ export class BlobOperationsImpl implements BlobOperations {
     }
   }
 
+  /**
+   * Uploads a blob via the SDS-specific XRPC endpoint.
+   *
+   * Uses the agent's fetch handler directly since `com.sds.repo.uploadBlob`
+   * is not a registered XRPC namespace on the standard AT Protocol Agent.
+   * This follows the same pattern used by CollaboratorOperationsImpl and
+   * OrganizationOperationsImpl for SDS-specific endpoints.
+   *
+   * @param data - Binary data to upload
+   * @param encoding - MIME type of the data
+   * @returns Promise resolving to blob reference and metadata
+   * @throws {@link NetworkError} if the upload fails
+   * @internal
+   */
+  private async uploadViaSDS(
+    data: Uint8Array,
+    encoding: string,
+  ): Promise<{ ref: { $link: string }; mimeType: string; size: number }> {
+    const url = `/xrpc/com.sds.repo.uploadBlob?repo=${encodeURIComponent(this.repoDid)}`;
+    const response = await this.agent.fetchHandler(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": encoding,
+      },
+      body: data as unknown as BodyInit,
+    });
+
+    if (!response.ok) {
+      throw new NetworkError(`SDS blob upload failed: ${response.statusText}`);
+    }
+
+    const result = (await response.json()) as {
+      blob: {
+        ref: { $link: string } | string;
+        mimeType: string;
+        size: number;
+      };
+    };
+
+    const ref = typeof result.blob.ref === "string" ? result.blob.ref : result.blob.ref.$link;
+
+    return {
+      ref: { $link: ref },
+      mimeType: result.blob.mimeType,
+      size: result.blob.size,
+    };
+  }
+
   /**
    * Retrieves a blob by its CID.
    *

packages/sdk-core/src/repository/HypercertOperationsImpl.ts

@@ -39,6 +39,7 @@ import {
   type CreateAttachmentParams,
 } from "../services/hypercerts/types.js";
 import type {
+  BlobOperations,
   LocationParams,
   CreateHypercertParams,
   CreateHypercertResult,
@@ -106,15 +107,15 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
    *
    * @param agent - AT Protocol Agent for making API calls
    * @param repoDid - DID of the repository to operate on
-   * @param _serverUrl - Server URL (reserved for future use)
+   * @param blobs - Blob operations for uploading images and files
    * @param logger - Optional logger for debugging
    *
    * @internal
    */
   constructor(
     private agent: Agent,
     private repoDid: string,
-    private _serverUrl: string,
+    private blobs: BlobOperations,
     private logger?: LoggerInterface,
   ) {
     super();
@@ -138,25 +139,19 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
   }
 
   /**
-   * Helper function to upload a blob to the repository, returns a blob reference
+   * Converts a blob upload result to JsonBlobRef format.
    *
-   * @param content - Blob to upload
-   * @param fallbackContentType | if content.type is empty,we use this
-   * @returns BlobRef
-   * @throws {@link NetworkError} if upload fails
+   * @param uploadResult - Result from BlobOperations.upload()
+   * @returns JsonBlobRef formatted for records
    * @internal
    */
-
-  private async handleBlobUpload(content: Blob, fallbackContentType: string) {
-    const arrayBuffer = await content.arrayBuffer();
-    const uint8Array = new Uint8Array(arrayBuffer);
-    const uploadResult = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
-      encoding: content.type || fallbackContentType,
-    });
-    if (!uploadResult.success) {
-      throw new NetworkError("Failed to upload blob");
-    }
-    return uploadResult.data.blob;
+  private blobToJsonRef(uploadResult: { ref: { $link: string }; mimeType: string; size: number }): JsonBlobRef {
+    return {
+      $type: "blob",
+      ref: uploadResult.ref,
+      mimeType: uploadResult.mimeType,
+      size: uploadResult.size,
+    };
   }
 
   /**
@@ -174,26 +169,13 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
   ): Promise<JsonBlobRef | undefined> {
     this.emitProgress(onProgress, { name: "uploadImage", status: "start" });
     try {
-      const arrayBuffer = await image.arrayBuffer();
-      const uint8Array = new Uint8Array(arrayBuffer);
-      const uploadResult = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
-        encoding: image.type || "image/jpeg",
+      const uploadResult = await this.blobs.upload(image);
+      this.emitProgress(onProgress, {
+        name: "uploadImage",
+        status: "success",
+        data: { size: image.size },
       });
-      if (uploadResult.success) {
-        const blobRef: JsonBlobRef = {
-          $type: "blob",
-          ref: { $link: uploadResult.data.blob.ref.toString() },
-          mimeType: uploadResult.data.blob.mimeType,
-          size: uploadResult.data.blob.size,
-        };
-        this.emitProgress(onProgress, {
-          name: "uploadImage",
-          status: "success",
-          data: { size: image.size },
-        });
-        return blobRef;
-      }
-      throw new NetworkError("Image upload succeeded but returned no blob reference");
+      return this.blobToJsonRef(uploadResult);
     } catch (error) {
       this.emitProgress(onProgress, { name: "uploadImage", status: "error", error: error as Error });
       throw new NetworkError(`Failed to upload image: ${error instanceof Error ? error.message : "Unknown"}`, error);
@@ -723,19 +705,8 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
         if (params.image === null) {
           // Remove image
         } else {
-          const arrayBuffer = await params.image.arrayBuffer();
-          const uint8Array = new Uint8Array(arrayBuffer);
-          const uploadResult = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
-            encoding: params.image.type || "image/jpeg",
-          });
-          if (uploadResult.success) {
-            recordForUpdate.image = {
-              $type: "blob",
-              ref: uploadResult.data.blob.ref,
-              mimeType: uploadResult.data.blob.mimeType,
-              size: uploadResult.data.blob.size,
-            };
-          }
+          const uploadResult = await this.blobs.upload(params.image);
+          recordForUpdate.image = this.blobToJsonRef(uploadResult);
         }
       } else if (existingRecord.image) {
         // Preserve existing image
@@ -980,7 +951,7 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
    * @returns Promise resolving to either a URI ref or blob ref
    * @internal
    */
-  private async resolveUriOrBlob(content: string | Blob, fallbackMimeType: string) {
+  private async resolveUriOrBlob(content: string | Blob, _fallbackMimeType: string) {
     if (typeof content === "string") {
       const uriRef = {
         $type: "org.hypercerts.defs#uri",
@@ -989,12 +960,11 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
       return uriRef;
     }
 
-    const uploadedBlob = await this.handleBlobUpload(content, fallbackMimeType);
-    const blobRef = {
-      $type: "org.hypercerts.defs#smallBlob",
-      blob: uploadedBlob,
-    } satisfies $Typed<OrgHypercertsDefs.SmallBlob>;
-    return blobRef;
+    const uploadResult = await this.blobs.upload(content);
+    return {
+      $type: "org.hypercerts.defs#smallBlob" as const,
+      blob: uploadResult,
+    };
   }
 
   private async resolveCollectionImageInput(input: string | Blob): Promise<NonNullable<HypercertCollection["avatar"]>>;
@@ -1007,12 +977,12 @@ export class HypercertOperationsImpl extends EventEmitter<HypercertEvents> imple
       return { $type: "org.hypercerts.defs#uri" as const, uri: input };
     }
 
-    const blob = await this.handleBlobUpload(input, "image/jpeg");
+    const uploadResult = await this.blobs.upload(input);
     if (isBanner) {
-      return { $type: "org.hypercerts.defs#largeImage" as const, image: blob };
+      return { $type: "org.hypercerts.defs#largeImage" as const, image: uploadResult };
     }
 
-    return { $type: "org.hypercerts.defs#smallImage" as const, image: blob };
+    return { $type: "org.hypercerts.defs#smallImage" as const, image: uploadResult };
   }
 
   private async resolveLocationValue(location: string | Blob | HypercertLocation["location"]) {