@hypercerts-org/sdk-core 0.4.0-beta.0 → 0.6.0-beta.0

package/tests/repository/LexiconRegistry.test.ts

@@ -1,192 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { LexiconRegistry } from "../../src/repository/LexiconRegistry.js";
-import { ValidationError } from "../../src/core/errors.js";
-import { createMockLexicon } from "../utils/repository-fixtures.js";
-import type { Agent } from "@atproto/api";
-import type { LexiconDoc } from "@atproto/lexicon";
-
-describe("LexiconRegistry", () => {
-  let registry: LexiconRegistry;
-
-  beforeEach(() => {
-    registry = new LexiconRegistry();
-  });
-
-  describe("register", () => {
-    it("should register a lexicon", () => {
-      const lexicon = createMockLexicon("com.example.test");
-      expect(() => registry.register(lexicon as LexiconDoc)).not.toThrow();
-      expect(registry.has("com.example.test")).toBe(true);
-    });
-
-    it("should throw ValidationError for lexicon without id", () => {
-      const lexicon = { lexicon: 1 } as unknown as LexiconDoc;
-      expect(() => registry.register(lexicon)).toThrow(ValidationError);
-      expect(() => registry.register(lexicon)).toThrow("Lexicon must have an 'id' field");
-    });
-
-    it("should overwrite existing lexicon with same id", () => {
-      const lexicon1 = createMockLexicon("com.example.test");
-      const lexicon2 = {
-        ...lexicon1,
-        defs: {
-          record: {
-            type: "record" as const,
-            record: {
-              type: "object" as const,
-              properties: {},
-            },
-          },
-        },
-      } as LexiconDoc;
-
-      registry.register(lexicon1);
-      // Overwriting lexicons is allowed (creates new Lexicons collection)
-      expect(() => registry.register(lexicon2)).not.toThrow();
-      expect(registry.get("com.example.test")).toEqual(lexicon2);
-    });
-  });
-
-  describe("registerMany", () => {
-    it("should register multiple lexicons", () => {
-      const lexicons = [
-        createMockLexicon("com.example.one"),
-        createMockLexicon("com.example.two"),
-        createMockLexicon("com.example.three"),
-      ] as LexiconDoc[];
-
-      registry.registerMany(lexicons);
-
-      expect(registry.has("com.example.one")).toBe(true);
-      expect(registry.has("com.example.two")).toBe(true);
-      expect(registry.has("com.example.three")).toBe(true);
-    });
-
-    it("should throw ValidationError if any lexicon is invalid", () => {
-      const lexicons = [createMockLexicon("com.example.one"), { lexicon: 1 } as unknown as LexiconDoc];
-
-      expect(() => registry.registerMany(lexicons)).toThrow(ValidationError);
-    });
-  });
-
-  describe("get", () => {
-    it("should return registered lexicon", () => {
-      const lexicon = createMockLexicon("com.example.test");
-      registry.register(lexicon);
-
-      const retrieved = registry.get("com.example.test");
-      expect(retrieved).toEqual(lexicon);
-    });
-
-    it("should return undefined for unregistered lexicon", () => {
-      expect(registry.get("com.example.nonexistent")).toBeUndefined();
-    });
-  });
-
-  describe("validate", () => {
-    it("should validate a valid record", () => {
-      const lexicon = createMockLexicon("com.example.test");
-      registry.register(lexicon);
-
-      // The mock lexicon has a record def, so we need to validate against the record type
-      // Note: Validation may fail if the schema doesn't match exactly
-      const result = registry.validate("com.example.test", {
-        $type: "com.example.test",
-        text: "Hello",
-      });
-
-      // Validation result depends on lexicon schema - just check it doesn't throw
-      expect(result).toHaveProperty("valid");
-      // Error property is optional and only present when validation fails
-      if (!result.valid) {
-        expect(result).toHaveProperty("error");
-      }
-    });
-
-    it("should return invalid result for invalid record", () => {
-      const lexicon = createMockLexicon("com.example.test");
-      registry.register(lexicon);
-
-      const result = registry.validate("com.example.test", {
-        $type: "com.example.test",
-        invalidField: "value",
-      });
-
-      // Validation may pass or fail depending on lexicon schema
-      // The important thing is that validate() doesn't throw
-      expect(result).toHaveProperty("valid");
-    });
-
-    it("should return valid result for unknown collection (no lexicon registered)", () => {
-      // When no lexicon is registered for a collection, validation passes
-      // because we can't validate against unknown schemas
-      const result = registry.validate("com.example.unknown", {
-        $type: "com.example.unknown",
-      });
-
-      expect(result.valid).toBe(true);
-      // No error when lexicon isn't registered
-    });
-  });
-
-  describe("addToAgent", () => {
-    it("should add lexicons to agent", () => {
-      const lexicon = createMockLexicon("com.example.test");
-      registry.register(lexicon);
-
-      const mockAgent = {
-        lex: {
-          add: vi.fn(),
-        },
-      } as unknown as Agent;
-
-      registry.addToAgent(mockAgent);
-
-      expect(mockAgent.lex.add).toHaveBeenCalledWith(lexicon);
-    });
-
-    it("should add all registered lexicons to agent", () => {
-      const lexicons = [createMockLexicon("com.example.one"), createMockLexicon("com.example.two")];
-      registry.registerMany(lexicons);
-
-      const mockAgent = {
-        lex: {
-          add: vi.fn(),
-        },
-      } as unknown as Agent;
-
-      registry.addToAgent(mockAgent);
-
-      expect(mockAgent.lex.add).toHaveBeenCalledTimes(2);
-      expect(mockAgent.lex.add).toHaveBeenCalledWith(lexicons[0]);
-      expect(mockAgent.lex.add).toHaveBeenCalledWith(lexicons[1]);
-    });
-  });
-
-  describe("getRegisteredIds", () => {
-    it("should return empty array for empty registry", () => {
-      expect(registry.getRegisteredIds()).toEqual([]);
-    });
-
-    it("should return all registered lexicon IDs", () => {
-      registry.register(createMockLexicon("com.example.one"));
-      registry.register(createMockLexicon("com.example.two"));
-
-      const ids = registry.getRegisteredIds();
-      expect(ids).toContain("com.example.one");
-      expect(ids).toContain("com.example.two");
-      expect(ids.length).toBe(2);
-    });
-  });
-
-  describe("has", () => {
-    it("should return true for registered lexicon", () => {
-      registry.register(createMockLexicon("com.example.test"));
-      expect(registry.has("com.example.test")).toBe(true);
-    });
-
-    it("should return false for unregistered lexicon", () => {
-      expect(registry.has("com.example.nonexistent")).toBe(false);
-    });
-  });
-});

package/tests/repository/OrganizationOperationsImpl.test.ts

@@ -1,242 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { OrganizationOperationsImpl } from "../../src/repository/OrganizationOperationsImpl.js";
-import { NetworkError } from "../../src/core/errors.js";
-
-describe("OrganizationOperationsImpl", () => {
-  let mockSession: any;
-  let orgOps: OrganizationOperationsImpl;
-  const repoDid = "did:plc:testdid123";
-  const serverUrl = "https://sds.example.com";
-
-  beforeEach(() => {
-    mockSession = {
-      did: "did:plc:user123",
-      sub: "did:plc:user123",
-      fetchHandler: vi.fn(),
-    };
-
-    orgOps = new OrganizationOperationsImpl(mockSession, repoDid, serverUrl);
-  });
-
-  describe("create", () => {
-    it("should create an organization successfully", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          did: "did:plc:neworg123",
-          handle: "myorg.example.com",
-          name: "My Organization",
-          description: "A test organization",
-          createdAt: "2024-01-01T00:00:00Z",
-        }),
-      });
-
-      const result = await orgOps.create({
-        name: "My Organization",
-        description: "A test organization",
-        handle: "myorg",
-      });
-
-      expect(result.did).toBe("did:plc:neworg123");
-      expect(result.handle).toBe("myorg.example.com");
-      expect(result.name).toBe("My Organization");
-      expect(result.accessType).toBe("owner");
-      expect(result.permissions.owner).toBe(true);
-
-      expect(mockSession.fetchHandler).toHaveBeenCalledWith(
-        `${serverUrl}/xrpc/com.sds.organization.create`,
-        expect.objectContaining({
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-        }),
-      );
-    });
-
-    it("should create organization with minimal params", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          did: "did:plc:org",
-          handle: "org.example.com",
-          name: "Org",
-        }),
-      });
-
-      const result = await orgOps.create({ name: "Org" });
-
-      expect(result.name).toBe("Org");
-      expect(result.createdAt).toBeDefined(); // Should default to current time
-    });
-
-    it("should throw NetworkError on failure", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: false,
-        statusText: "Conflict",
-      });
-
-      await expect(
-        orgOps.create({ name: "Test Org" }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe("get", () => {
-    it("should get an organization by DID", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          repositories: [
-            {
-              did: "did:plc:org1",
-              handle: "org1.example.com",
-              name: "Organization 1",
-              description: "First org",
-              accessType: "owner",
-              permissions: { read: true, create: true, update: true, delete: true, admin: true, owner: true },
-            },
-            {
-              did: "did:plc:org2",
-              handle: "org2.example.com",
-              name: "Organization 2",
-              accessType: "collaborator",
-              permissions: { read: true, create: true, update: true, delete: false, admin: false, owner: false },
-            },
-          ],
-        }),
-      });
-
-      const result = await orgOps.get("did:plc:org1");
-
-      expect(result).not.toBeNull();
-      expect(result!.did).toBe("did:plc:org1");
-      expect(result!.name).toBe("Organization 1");
-    });
-
-    it("should return null for non-existent organization", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          repositories: [],
-        }),
-      });
-
-      const result = await orgOps.get("did:plc:nonexistent");
-
-      expect(result).toBeNull();
-    });
-
-    it("should return null on error", async () => {
-      mockSession.fetchHandler.mockRejectedValue(new Error("Network error"));
-
-      const result = await orgOps.get("did:plc:org");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("list", () => {
-    it("should list all accessible organizations", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          repositories: [
-            {
-              did: "did:plc:org1",
-              handle: "org1.example.com",
-              name: "Organization 1",
-              accessType: "owner",
-              permissions: { read: true, create: true, update: true, delete: true, admin: true, owner: true },
-            },
-            {
-              did: "did:plc:org2",
-              handle: "org2.example.com",
-              name: "Organization 2",
-              description: "Second org",
-              accessType: "collaborator",
-              permissions: { read: true, create: true, update: false, delete: false, admin: false, owner: false },
-            },
-          ],
-        }),
-      });
-
-      const result = await orgOps.list();
-
-      expect(result).toHaveLength(2);
-      expect(result[0].did).toBe("did:plc:org1");
-      expect(result[0].accessType).toBe("owner");
-      expect(result[1].did).toBe("did:plc:org2");
-      expect(result[1].accessType).toBe("collaborator");
-    });
-
-    it("should handle empty repositories list", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({ repositories: [] }),
-      });
-
-      const result = await orgOps.list();
-
-      expect(result).toHaveLength(0);
-    });
-
-    it("should use session DID in query", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({ repositories: [] }),
-      });
-
-      await orgOps.list();
-
-      expect(mockSession.fetchHandler).toHaveBeenCalledWith(
-        expect.stringContaining(`userDid=${encodeURIComponent(mockSession.did)}`),
-        expect.any(Object),
-      );
-    });
-
-    it("should use session.sub if did is not available", async () => {
-      mockSession.did = undefined;
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({ repositories: [] }),
-      });
-
-      await orgOps.list();
-
-      expect(mockSession.fetchHandler).toHaveBeenCalledWith(
-        expect.stringContaining(`userDid=${encodeURIComponent(mockSession.sub)}`),
-        expect.any(Object),
-      );
-    });
-
-    it("should throw NetworkError on failure", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: false,
-        statusText: "Internal Server Error",
-      });
-
-      await expect(orgOps.list()).rejects.toThrow(NetworkError);
-    });
-
-    it("should add createdAt for organizations without it", async () => {
-      mockSession.fetchHandler.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          repositories: [
-            {
-              did: "did:plc:org",
-              handle: "org.example.com",
-              name: "Org",
-              accessType: "owner",
-              permissions: { read: true, create: true, update: true, delete: true, admin: true, owner: true },
-              // No createdAt field
-            },
-          ],
-        }),
-      });
-
-      const result = await orgOps.list();
-
-      expect(result[0].createdAt).toBeDefined();
-    });
-  });
-});

package/tests/repository/ProfileOperationsImpl.test.ts

@@ -1,254 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ProfileOperationsImpl } from "../../src/repository/ProfileOperationsImpl.js";
-import { NetworkError } from "../../src/core/errors.js";
-
-describe("ProfileOperationsImpl", () => {
-  let mockAgent: any;
-  let profileOps: ProfileOperationsImpl;
-  const repoDid = "did:plc:testdid123";
-  const serverUrl = "https://pds.example.com";
-
-  beforeEach(() => {
-    mockAgent = {
-      getProfile: vi.fn(),
-      com: {
-        atproto: {
-          repo: {
-            getRecord: vi.fn(),
-            putRecord: vi.fn(),
-            uploadBlob: vi.fn(),
-          },
-        },
-      },
-    };
-
-    profileOps = new ProfileOperationsImpl(mockAgent, repoDid, serverUrl);
-  });
-
-  describe("get", () => {
-    it("should get profile successfully", async () => {
-      mockAgent.getProfile.mockResolvedValue({
-        success: true,
-        data: {
-          handle: "test.bsky.social",
-          displayName: "Test User",
-          description: "A test user",
-          avatar: "https://example.com/avatar.jpg",
-          banner: "https://example.com/banner.jpg",
-        },
-      });
-
-      const result = await profileOps.get();
-
-      expect(result.handle).toBe("test.bsky.social");
-      expect(result.displayName).toBe("Test User");
-      expect(result.description).toBe("A test user");
-      expect(result.avatar).toBe("https://example.com/avatar.jpg");
-      expect(result.banner).toBe("https://example.com/banner.jpg");
-      expect(mockAgent.getProfile).toHaveBeenCalledWith({ actor: repoDid });
-    });
-
-    it("should handle profile without optional fields", async () => {
-      mockAgent.getProfile.mockResolvedValue({
-        success: true,
-        data: {
-          handle: "minimal.bsky.social",
-        },
-      });
-
-      const result = await profileOps.get();
-
-      expect(result.handle).toBe("minimal.bsky.social");
-      expect(result.displayName).toBeUndefined();
-      expect(result.description).toBeUndefined();
-    });
-
-    it("should throw NetworkError when API returns success: false", async () => {
-      mockAgent.getProfile.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(profileOps.get()).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.getProfile.mockRejectedValue(new Error("Profile not found"));
-
-      await expect(profileOps.get()).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe("update", () => {
-    beforeEach(() => {
-      // Default mock for getting existing profile
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: true,
-        data: {
-          value: {
-            displayName: "Old Name",
-            description: "Old description",
-          },
-        },
-      });
-
-      mockAgent.com.atproto.repo.putRecord.mockResolvedValue({
-        success: true,
-        data: {
-          uri: "at://did:plc:test/app.bsky.actor.profile/self",
-          cid: "bafyrei123",
-        },
-      });
-    });
-
-    it("should update displayName", async () => {
-      const result = await profileOps.update({
-        displayName: "New Name",
-      });
-
-      expect(result.uri).toBe("at://did:plc:test/app.bsky.actor.profile/self");
-      expect(mockAgent.com.atproto.repo.putRecord).toHaveBeenCalledWith(
-        expect.objectContaining({
-          record: expect.objectContaining({
-            displayName: "New Name",
-            description: "Old description",
-          }),
-        }),
-      );
-    });
-
-    it("should update description", async () => {
-      await profileOps.update({
-        description: "New description",
-      });
-
-      expect(mockAgent.com.atproto.repo.putRecord).toHaveBeenCalledWith(
-        expect.objectContaining({
-          record: expect.objectContaining({
-            displayName: "Old Name",
-            description: "New description",
-          }),
-        }),
-      );
-    });
-
-    it("should remove displayName when set to null", async () => {
-      await profileOps.update({
-        displayName: null,
-      });
-
-      const putCall = mockAgent.com.atproto.repo.putRecord.mock.calls[0][0];
-      expect(putCall.record.displayName).toBeUndefined();
-    });
-
-    it("should remove description when set to null", async () => {
-      await profileOps.update({
-        description: null,
-      });
-
-      const putCall = mockAgent.com.atproto.repo.putRecord.mock.calls[0][0];
-      expect(putCall.record.description).toBeUndefined();
-    });
-
-    it("should upload and set avatar", async () => {
-      const avatarBlob = new Blob(["avatar data"], { type: "image/jpeg" });
-      mockAgent.com.atproto.repo.uploadBlob.mockResolvedValue({
-        success: true,
-        data: {
-          blob: { ref: { $link: "avatar-cid" }, mimeType: "image/jpeg", size: 100 },
-        },
-      });
-
-      await profileOps.update({
-        avatar: avatarBlob,
-      });
-
-      expect(mockAgent.com.atproto.repo.uploadBlob).toHaveBeenCalled();
-      expect(mockAgent.com.atproto.repo.putRecord).toHaveBeenCalledWith(
-        expect.objectContaining({
-          record: expect.objectContaining({
-            avatar: expect.objectContaining({ ref: { $link: "avatar-cid" } }),
-          }),
-        }),
-      );
-    });
-
-    it("should remove avatar when set to null", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: true,
-        data: {
-          value: {
-            displayName: "Name",
-            avatar: { ref: { $link: "old-avatar" } },
-          },
-        },
-      });
-
-      await profileOps.update({
-        avatar: null,
-      });
-
-      const putCall = mockAgent.com.atproto.repo.putRecord.mock.calls[0][0];
-      expect(putCall.record.avatar).toBeUndefined();
-    });
-
-    it("should upload and set banner", async () => {
-      const bannerBlob = new Blob(["banner data"], { type: "image/jpeg" });
-      mockAgent.com.atproto.repo.uploadBlob.mockResolvedValue({
-        success: true,
-        data: {
-          blob: { ref: { $link: "banner-cid" }, mimeType: "image/jpeg", size: 200 },
-        },
-      });
-
-      await profileOps.update({
-        banner: bannerBlob,
-      });
-
-      expect(mockAgent.com.atproto.repo.uploadBlob).toHaveBeenCalled();
-      expect(mockAgent.com.atproto.repo.putRecord).toHaveBeenCalledWith(
-        expect.objectContaining({
-          record: expect.objectContaining({
-            banner: expect.objectContaining({ ref: { $link: "banner-cid" } }),
-          }),
-        }),
-      );
-    });
-
-    it("should remove banner when set to null", async () => {
-      mockAgent.com.atproto.repo.getRecord.mockResolvedValue({
-        success: true,
-        data: {
-          value: {
-            displayName: "Name",
-            banner: { ref: { $link: "old-banner" } },
-          },
-        },
-      });
-
-      await profileOps.update({
-        banner: null,
-      });
-
-      const putCall = mockAgent.com.atproto.repo.putRecord.mock.calls[0][0];
-      expect(putCall.record.banner).toBeUndefined();
-    });
-
-    it("should throw NetworkError when putRecord returns success: false", async () => {
-      mockAgent.com.atproto.repo.putRecord.mockResolvedValue({
-        success: false,
-      });
-
-      await expect(
-        profileOps.update({ displayName: "New Name" }),
-      ).rejects.toThrow(NetworkError);
-    });
-
-    it("should throw NetworkError when API throws", async () => {
-      mockAgent.com.atproto.repo.putRecord.mockRejectedValue(new Error("Update failed"));
-
-      await expect(
-        profileOps.update({ displayName: "New Name" }),
-      ).rejects.toThrow(NetworkError);
-    });
-  });
-});