@hypercerts-org/sdk-core 0.5.0-beta.0 → 0.7.0-beta.0

package/tests/repository/RecordOperationsImpl.test.ts

@@ -1,375 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { RecordOperationsImpl } from "../../src/repository/RecordOperationsImpl.js";
-import { LexiconRegistry } from "../../src/repository/LexiconRegistry.js";
-import { NetworkError, ValidationError } from "../../src/core/errors.js";
-
-describe("RecordOperationsImpl", () => {
-  let mockAgent: any;
-  let lexiconRegistry: LexiconRegistry;
-  let recordOps: RecordOperationsImpl;
-  const repoDid = "did:plc:testdid123";
-
-  beforeEach(() => {
-    mockAgent = {
-      com: {
-        atproto: {
-          repo: {
-            createRecord: vi.fn(),
-            putRecord: vi.fn(),
-            getRecord: vi.fn(),
-            listRecords: vi.fn(),
-            deleteRecord: vi.fn(),
-          },
-        },
-      },
-    };
-
-    lexiconRegistry = new LexiconRegistry();
-    recordOps = new RecordOperationsImpl(mockAgent, repoDid, lexiconRegistry);
-  });
-
-  describe("create", () => {
-    it("should create a record successfully", async () => {
-      mockAgent.com.atproto.repo.createRecord.mockResolvedValue({
-        success: true,
-        data: { uri: "at://did:plc:test/collection/rkey", cid: "bafyrei123" },
-      });
-
-      const result = await recordOps.create({
-        collection: "app.bsky.feed.post",
-        record: { text: "Hello world" },
-      });
-
-      expect(result.uri).toBe("at://did:plc:test/collection/rkey");
-      expect(result.cid).toBe("bafyrei123");
-      expect(mockAgent.com.atproto.repo.createRecord).toHaveBeenCalledWith({
-        repo: repoDid,
-        collection: "app.bsky.feed.post",
-        record: { text: "Hello world" },
-        rkey: undefined,
-      });
-    });
-
-    it("should create a record with custom rkey", async () => {
-      mockAgent.com.atproto.repo.createRecord.mockResolvedValue({
-        success: true,
-        data: { uri: "at://did:plc:test/collection/custom-rkey", cid: "bafyrei123" },
-      });
-
-      await recordOps.create({
-        collection: "app.bsky.feed.post",
-        record: { text: "Hello" },
-        rkey: "custom-rkey",
-      });
-
-      expect(mockAgent.com.atproto.repo.createRecord).toHaveBeenCalledWith(
-        expect.objectContaining({ rkey: "custom-rkey" }),
-      );
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.com.atproto.repo.createRecord.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        recordOps.create({
-          collection: "app.bsky.feed.post",
-          record: { text: "Hello" },
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.createRecord.mockRejectedValue(new Error("Network failure"));
-
-      await expect(
-        recordOps.create({
-          collection: "app.bsky.feed.post",
-          record: { text: "Hello" },
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should validate record against lexicon and throw ValidationError", async () => {
-      // Register a lexicon that requires specific fields
-      lexiconRegistry.register({
-        lexicon: 1,
-        id: "test.validated.record",
-        defs: {
-          main: {
-            type: "record",
-            record: {
-              type: "object",
-              required: ["requiredField"],
-              properties: {
-                requiredField: { type: "string" },
-              },
-            },
-          },
-        },
-      });
-
-      await expect(
-        recordOps.create({
-          collection: "test.validated.record",
-          record: { wrongField: "value" }, // Missing requiredField
-        }),
-      ).rejects.toThrow(ValidationError);
-    });
-  });
-
-  describe("update", () => {
-    it("should update a record successfully", async () => {
-      mockAgent.com.atproto.repo.putRecord.mockResolvedValue({
-        success: true,
-        data: { uri: "at://did:plc:test/collection/rkey", cid: "bafyrei456" },
-      });
-
-      const result = await recordOps.update({
-        collection: "app.bsky.feed.post",
-        rkey: "test-rkey",
-        record: { text: "Updated text" },
-      });
-
-      expect(result.uri).toBe("at://did:plc:test/collection/rkey");
-      expect(result.cid).toBe("bafyrei456");
-      expect(mockAgent.com.atproto.repo.putRecord).toHaveBeenCalledWith({
-        repo: repoDid,
-        collection: "app.bsky.feed.post",
-        rkey: "test-rkey",
-        record: { text: "Updated text" },
-      });
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.com.atproto.repo.putRecord.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        recordOps.update({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-          record: { text: "Hello" },
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.putRecord.mockRejectedValue(new Error("Network failure"));
-
-      await expect(
-        recordOps.update({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-          record: { text: "Hello" },
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe("get", () => {
-    it("should get a record successfully", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: true,
-        data: {
-          uri: "at://did:plc:test/collection/rkey",
-          cid: "bafyrei123",
-          value: { text: "Hello world" },
-        },
-      });
-
-      const result = await recordOps.get({
-        collection: "app.bsky.feed.post",
-        rkey: "test-rkey",
-      });
-
-      expect(result.uri).toBe("at://did:plc:test/collection/rkey");
-      expect(result.cid).toBe("bafyrei123");
-      expect(result.value).toEqual({ text: "Hello world" });
-    });
-
-    it("should handle missing cid", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: true,
-        data: {
-          uri: "at://did:plc:test/collection/rkey",
-          cid: undefined,
-          value: { text: "Hello" },
-        },
-      });
-
-      const result = await recordOps.get({
-        collection: "app.bsky.feed.post",
-        rkey: "test-rkey",
-      });
-
-      expect(result.cid).toBe("");
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        recordOps.get({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockRejectedValue(new Error("Not found"));
-
-      await expect(
-        recordOps.get({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe("list", () => {
-    it("should list records successfully", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockResolvedValue({
-        success: true,
-        data: {
-          records: [
-            { uri: "at://did:plc:test/collection/1", cid: "bafyrei1", value: { text: "First" } },
-            { uri: "at://did:plc:test/collection/2", cid: "bafyrei2", value: { text: "Second" } },
-          ],
-          cursor: "next-cursor",
-        },
-      });
-
-      const result = await recordOps.list({
-        collection: "app.bsky.feed.post",
-        limit: 10,
-      });
-
-      expect(result.records).toHaveLength(2);
-      expect(result.cursor).toBe("next-cursor");
-    });
-
-    it("should handle empty results", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockResolvedValue({
-        success: true,
-        data: {
-          records: [],
-          cursor: undefined,
-        },
-      });
-
-      const result = await recordOps.list({
-        collection: "app.bsky.feed.post",
-      });
-
-      expect(result.records).toHaveLength(0);
-      expect(result.cursor).toBeUndefined();
-    });
-
-    it("should handle null records", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockResolvedValue({
-        success: true,
-        data: {
-          records: null,
-          cursor: null,
-        },
-      });
-
-      const result = await recordOps.list({
-        collection: "app.bsky.feed.post",
-      });
-
-      expect(result.records).toHaveLength(0);
-      expect(result.cursor).toBeUndefined();
-    });
-
-    it("should pass pagination parameters", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockResolvedValue({
-        success: true,
-        data: { records: [], cursor: undefined },
-      });
-
-      await recordOps.list({
-        collection: "app.bsky.feed.post",
-        limit: 50,
-        cursor: "prev-cursor",
-      });
-
-      expect(mockAgent.com.atproto.repo.listRecords).toHaveBeenCalledWith({
-        repo: repoDid,
-        collection: "app.bsky.feed.post",
-        limit: 50,
-        cursor: "prev-cursor",
-      });
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        recordOps.list({ collection: "app.bsky.feed.post" }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.listRecords.mockRejectedValue(new Error("Network failure"));
-
-      await expect(
-        recordOps.list({ collection: "app.bsky.feed.post" }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete a record successfully", async () => {
-      mockAgent.com.atproto.repo.deleteRecord.mockResolvedValue({
-        success: true,
-      });
-
-      await expect(
-        recordOps.delete({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-        }),
-      ).resolves.toBeUndefined();
-
-      expect(mockAgent.com.atproto.repo.deleteRecord).toHaveBeenCalledWith({
-        repo: repoDid,
-        collection: "app.bsky.feed.post",
-        rkey: "test-rkey",
-      });
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.com.atproto.repo.deleteRecord.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        recordOps.delete({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.deleteRecord.mockRejectedValue(new Error("Network failure"));
-
-      await expect(
-        recordOps.delete({
-          collection: "app.bsky.feed.post",
-          rkey: "test-rkey",
-        }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-});

package/tests/repository/Repository.test.ts

@@ -1,149 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { SDSRequiredError } from "../../src/core/errors.js";
-import { LexiconRegistry } from "../../src/repository/LexiconRegistry.js";
-import { Repository } from "../../src/repository/Repository.js";
-import { createMockSession } from "../utils/repository-fixtures.js";
-
-describe("Repository", () => {
-  let mockSession: ReturnType<typeof createMockSession>;
-  let lexiconRegistry: LexiconRegistry;
-  let repository: Repository;
-
-  beforeEach(() => {
-    mockSession = createMockSession();
-    lexiconRegistry = new LexiconRegistry();
-    repository = new Repository(
-      mockSession,
-      "https://pds.example.com",
-      mockSession.did,
-      lexiconRegistry,
-      false, // Not SDS
-    );
-  });
-
-  describe("constructor", () => {
-    it("should create a repository with correct properties", () => {
-      expect(repository.did).toBe(mockSession.did);
-      expect(repository.isSDS).toBe(false);
-      expect(repository.getServerUrl()).toBe("https://pds.example.com");
-    });
-
-    it("should create an SDS repository", () => {
-      const sdsRepo = new Repository(
-        mockSession,
-        "https://sds.example.com",
-        mockSession.did,
-        lexiconRegistry,
-        true, // SDS
-      );
-
-      expect(sdsRepo.isSDS).toBe(true);
-    });
-  });
-
-  describe("repo()", () => {
-    it("should create a new repository for a different DID", () => {
-      const otherDid = "did:plc:otherdid123456789";
-      const otherRepo = repository.repo(otherDid);
-
-      expect(otherRepo.did).toBe(otherDid);
-      expect(otherRepo.getServerUrl()).toBe(repository.getServerUrl());
-      expect(otherRepo.isSDS).toBe(repository.isSDS);
-    });
-  });
-
-  describe("records", () => {
-    it("should return a RecordOperations instance", () => {
-      const records = repository.records;
-      expect(records).toBeDefined();
-      expect(typeof records.create).toBe("function");
-      expect(typeof records.update).toBe("function");
-      expect(typeof records.get).toBe("function");
-      expect(typeof records.list).toBe("function");
-      expect(typeof records.delete).toBe("function");
-    });
-
-    it("should return the same instance on subsequent calls", () => {
-      const records1 = repository.records;
-      const records2 = repository.records;
-      expect(records1).toBe(records2);
-    });
-  });
-
-  describe("blobs", () => {
-    it("should return a BlobOperations instance", () => {
-      const blobs = repository.blobs;
-      expect(blobs).toBeDefined();
-      expect(typeof blobs.upload).toBe("function");
-      expect(typeof blobs.get).toBe("function");
-    });
-  });
-
-  describe("profile", () => {
-    it("should return a ProfileOperations instance", () => {
-      const profile = repository.profile;
-      expect(profile).toBeDefined();
-      expect(typeof profile.get).toBe("function");
-      expect(typeof profile.update).toBe("function");
-    });
-  });
-
-  describe("hypercerts", () => {
-    it("should return a HypercertOperations instance", () => {
-      const hypercerts = repository.hypercerts;
-      expect(hypercerts).toBeDefined();
-      expect(typeof hypercerts.create).toBe("function");
-      expect(typeof hypercerts.update).toBe("function");
-      expect(typeof hypercerts.get).toBe("function");
-      expect(typeof hypercerts.list).toBe("function");
-      expect(typeof hypercerts.delete).toBe("function");
-      expect(typeof hypercerts.attachLocation).toBe("function");
-      expect(typeof hypercerts.addEvidence).toBe("function");
-      expect(typeof hypercerts.addContribution).toBe("function");
-    });
-  });
-
-  describe("collaborators (SDS only)", () => {
-    it("should throw SDSRequiredError on PDS repository", () => {
-      expect(() => repository.collaborators).toThrow(SDSRequiredError);
-    });
-
-    it("should return CollaboratorOperations on SDS repository", () => {
-      const sdsRepo = new Repository(
-        mockSession,
-        "https://sds.example.com",
-        mockSession.did,
-        lexiconRegistry,
-        true,
-      );
-
-      const collaborators = sdsRepo.collaborators;
-      expect(collaborators).toBeDefined();
-      expect(typeof collaborators.grant).toBe("function");
-      expect(typeof collaborators.revoke).toBe("function");
-      expect(typeof collaborators.list).toBe("function");
-    });
-  });
-
-  describe("organizations (SDS only)", () => {
-    it("should throw SDSRequiredError on PDS repository", () => {
-      expect(() => repository.organizations).toThrow(SDSRequiredError);
-    });
-
-    it("should return OrganizationOperations on SDS repository", () => {
-      const sdsRepo = new Repository(
-        mockSession,
-        "https://sds.example.com",
-        mockSession.did,
-        lexiconRegistry,
-        true,
-      );
-
-      const organizations = sdsRepo.organizations;
-      expect(organizations).toBeDefined();
-      expect(typeof organizations.create).toBe("function");
-      expect(typeof organizations.get).toBe("function");
-      expect(typeof organizations.list).toBe("function");
-    });
-  });
-});

package/tests/utils/fixtures.ts

@@ -1,117 +0,0 @@
-import { generateKeyPair, exportJWK } from "jose";
-import { randomUUID } from "crypto";
-import type { ATProtoSDKConfig } from "../../src/core/config.js";
-
-/**
- * Generate a valid test JWK private key using jose
- * Creates a real ES256 keypair for testing
- */
-let cachedTestJWK: string | null = null;
-
-export async function createTestJWK(): Promise<string> {
-  if (cachedTestJWK) {
-    return cachedTestJWK;
-  }
-
-  // Generate ES256 keypair
-  const { privateKey } = await generateKeyPair("ES256", {
-    extractable: true,
-  });
-
-  // Generate a unique key ID
-  const kid = randomUUID();
-
-  // Export private key to JWK format
-  const privateJWK = await exportJWK(privateKey);
-  privateJWK.kid = kid;
-  privateJWK.alg = "ES256";
-  // Use key_ops instead of 'use' (deprecated)
-  privateJWK.key_ops = ["sign"];
-
-  // Create keyset
-  const privateKeyset = {
-    keys: [privateJWK],
-  };
-
-  cachedTestJWK = JSON.stringify(privateKeyset);
-  return cachedTestJWK;
-}
-
-/**
- * Synchronous version that uses a pre-generated JWK
- * For tests that don't need async setup
- */
-export function createTestJWKSync(): string {
-  // Return a minimal valid structure - tests will need to handle async JWK generation
-  // For most tests, we can use a cached version
-  if (cachedTestJWK) {
-    return cachedTestJWK;
-  }
-  // Fallback - will fail in actual OAuth client but allows SDK construction tests
-  return JSON.stringify({
-    keys: [
-      {
-        kid: "test-key-1",
-        kty: "EC",
-        crv: "P-256",
-        x: "test-x",
-        y: "test-y",
-        d: "test-d",
-      },
-    ],
-  });
-}
-
-/**
- * Create a minimal valid SDK configuration for testing
- * Note: Storage is now optional - will use in-memory defaults if not provided
- */
-export function createTestConfig(overrides?: Partial<ATProtoSDKConfig>): ATProtoSDKConfig {
-  return {
-    oauth: {
-      clientId: "https://example.com/atproto-client-metadata.json",
-      redirectUri: "https://example.com/api/auth/atproto/callback",
-      scope: "atproto",
-      jwksUri: "https://example.com/jwks.json",
-      jwkPrivate: createTestJWKSync(),
-      ...overrides?.oauth,
-    },
-    servers: {
-      pds: "https://bsky.social",
-      ...overrides?.servers,
-    },
-    storage: overrides?.storage,
-    cache: overrides?.cache,
-    logger: overrides?.logger,
-    fetch: overrides?.fetch,
-    timeouts: overrides?.timeouts,
-  };
-}
-
-/**
- * Create a test config with a real JWK (async)
- * Use this for tests that need actual OAuth client functionality
- */
-export async function createTestConfigAsync(overrides?: Partial<ATProtoSDKConfig>): Promise<ATProtoSDKConfig> {
-  const jwkPrivate = await createTestJWK();
-
-  return {
-    oauth: {
-      clientId: "https://example.com/atproto-client-metadata.json",
-      redirectUri: "https://example.com/api/auth/atproto/callback",
-      scope: "atproto",
-      jwksUri: "https://example.com/jwks.json",
-      jwkPrivate,
-      ...overrides?.oauth,
-    },
-    servers: {
-      pds: "https://bsky.social",
-      ...overrides?.servers,
-    },
-    storage: overrides?.storage,
-    cache: overrides?.cache,
-    logger: overrides?.logger,
-    fetch: overrides?.fetch,
-    timeouts: overrides?.timeouts,
-  };
-}