jazz-tools 0.8.44 → 0.8.45

package/src/coValues/interfaces.ts

@@ -1,17 +1,18 @@
 import type { CojsonInternalTypes, RawCoValue } from "cojson";
 import { RawAccount } from "cojson";
+import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
 import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
-  Account,
-  AnonymousJazzAgent,
-  Group,
   Ref,
   SubscriptionScope,
   inspect,
   subscriptionsScopes,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
+import { type Account } from "./account.js";
 import { fulfillsDepth } from "./deepLoading.js";
+import { type Group } from "./group.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -85,8 +86,8 @@ export class CoValueBase implements CoValue {
   get _owner(): Account | Group {
     const owner =
       this._raw.group instanceof RawAccount
-        ? Account.fromRaw(this._raw.group)
-        : Group.fromRaw(this._raw.group);
+        ? RegisteredSchemas["Account"].fromRaw(this._raw.group)
+        : RegisteredSchemas["Group"].fromRaw(this._raw.group);
 
     const subScope = subscriptionsScopes.get(this);
     if (subScope) {
@@ -102,7 +103,9 @@ export class CoValueBase implements CoValue {
     const rawAccount = this._raw.core.node.account;
 
     if (rawAccount instanceof RawAccount) {
-      return coValuesCache.get(rawAccount, () => Account.fromRaw(rawAccount));
+      return coValuesCache.get(rawAccount, () =>
+        RegisteredSchemas["Account"].fromRaw(rawAccount),
+      );
     }
 
     return new AnonymousJazzAgent(this._raw.core.node);

package/src/coValues/profile.ts

@@ -0,0 +1,11 @@
+import { CoID } from "cojson";
+import { co } from "../internal.js";
+import { CoMap } from "./coMap.js";
+import { InboxInvite, InboxRoot } from "./inbox.js";
+
+/** @category Identity & Permissions */
+export class Profile extends CoMap {
+  name = co.string;
+  inbox = co.optional.json<CoID<InboxRoot>>();
+  inboxInvite = co.optional.json<InboxInvite>();
+}

package/src/coValues/registeredSchemas.ts

@@ -0,0 +1,12 @@
+import type { Account } from "./account.js";
+import type { CoMap } from "./coMap.js";
+import type { Group } from "./group.js";
+
+/**
+ * Regisering schemas into this Record to avoid circular dependencies.
+ */
+export const RegisteredSchemas = {} as {
+  Account: typeof Account;
+  Group: typeof Group;
+  CoMap: typeof CoMap;
+};

package/src/exports.ts

@@ -12,25 +12,31 @@ export type { CoValue, ID } from "./internal.js";
 
 export { Encoders, co } from "./internal.js";
 
+export {
+  Inbox,
+  InboxSender,
+} from "./coValues/inbox.js";
+
 export {
   Account,
-  FileStream,
-  BinaryCoStream,
-  CoList,
-  CoMap,
-  CoFeed,
-  CoStream,
-  CoValueBase,
-  Group,
-  ImageDefinition,
-  Profile,
   isControlledAccount,
-  SchemaUnion,
   type AccountClass,
-  type CoMapInit,
-  type CoValueClass,
-} from "./internal.js";
-export type { DeeplyLoaded, DepthsIn } from "./internal.js";
+} from "./coValues/account.js";
+export { Group } from "./coValues/group.js";
+export {
+  CoStream,
+  CoFeed,
+  FileStream,
+  BinaryCoStream,
+} from "./coValues/coFeed.js";
+export { CoList } from "./coValues/coList.js";
+export { CoMap, type CoMapInit } from "./coValues/coMap.js";
+export { CoValueBase } from "./coValues/interfaces.js";
+export { ImageDefinition } from "./coValues/extensions/imageDef.js";
+export { Profile } from "./coValues/profile.js";
+export { SchemaUnion } from "./coValues/schemaUnion.js";
+
+export type { CoValueClass, DeeplyLoaded, DepthsIn } from "./internal.js";
 
 export {
   createCoValueObservable,

package/src/implementation/anonymousJazzAgent.ts

@@ -0,0 +1,6 @@
+import { LocalNode } from "cojson";
+
+export class AnonymousJazzAgent {
+  _type = "Anonymous" as const;
+  constructor(public node: LocalNode) {}
+}

package/src/implementation/createContext.ts

@@ -9,7 +9,10 @@ import {
   RawAccountID,
   SessionID,
 } from "cojson";
-import { Account, AccountClass, ID } from "../internal.js";
+import { type Account, type AccountClass } from "../coValues/account.js";
+import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
+import type { ID } from "../internal.js";
+import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 
 export type Credentials = {
   accountID: ID<Account>;
@@ -136,7 +139,8 @@ export async function createJazzContext<Acc extends Account>(
 
     const { auth, sessionProvider, peersToLoadFrom, crypto } = options;
     const AccountSchema =
-      options.AccountSchema ?? (Account as unknown as AccountClass<Acc>);
+      options.AccountSchema ??
+      (RegisteredSchemas["Account"] as unknown as AccountClass<Acc>);
     let authResult: AuthResult;
     try {
       authResult = await auth.start(crypto);
@@ -243,11 +247,6 @@ export async function createJazzContext<Acc extends Account>(
   }
 }
 
-export class AnonymousJazzAgent {
-  _type = "Anonymous" as const;
-  constructor(public node: LocalNode) {}
-}
-
 export async function createAnonymousJazzContext({
   peersToLoadFrom,
   crypto,

package/src/implementation/refs.ts

@@ -1,6 +1,6 @@
 import type { CoID, RawCoValue } from "cojson";
+import { type Account } from "../coValues/account.js";
 import type {
-  Account,
   AnonymousJazzAgent,
   CoValue,
   ID,

package/src/implementation/subscriptionScope.ts

@@ -1,6 +1,6 @@
 import type { RawCoValue } from "cojson";
+import { type Account } from "../coValues/account.js";
 import type {
-  Account,
   AnonymousJazzAgent,
   CoValue,
   CoValueClass,

package/src/index.native.ts

@@ -2,6 +2,5 @@ export * from "./exports.js";
 
 export {
   MAX_RECOMMENDED_TX_SIZE,
-  PureJSCrypto,
   cojsonInternals,
 } from "cojson/native";

package/src/internal.ts

@@ -2,21 +2,13 @@ export * from "./implementation/symbols.js";
 export * from "./implementation/inspect.js";
 export * from "./coValues/interfaces.js";
 
-export * from "./coValues/coMap.js";
-export * from "./coValues/account.js";
-export * from "./coValues/coList.js";
-export * from "./coValues/coFeed.js";
-export * from "./coValues/schemaUnion.js";
-export * from "./coValues/group.js";
-
 export * from "./implementation/errors.js";
+export * from "./implementation/anonymousJazzAgent.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
 export * from "./coValues/deepLoading.js";
 
-export * from "./coValues/extensions/imageDef.js";
-
 export * from "./implementation/createContext.js";
 
 import "./implementation/devtoolsFormatters.js";

package/src/tests/account.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "vitest";
-import { CoMap, co } from "../internal";
-import { setupTwoNodes } from "./utils";
+import { CoMap, co } from "../exports.js";
+import { setupTwoNodes } from "./utils.js";
 
 test("waitForAllCoValuesSync should resolve when all the values are synced", async () => {
   class TestMap extends CoMap {

package/src/tests/coFeed.test.ts

@@ -192,15 +192,6 @@ describe("CoFeed resolution", async () => {
     const queue = new cojsonInternals.Channel();
 
     TestStream.subscribe(stream.id, meOnSecondPeer, [], (subscribedStream) => {
-      console.log("subscribedStream[me.id]", subscribedStream[me.id]);
-      console.log(
-        "subscribedStream[me.id]?.value?.[me.id]?.value",
-        subscribedStream[me.id]?.value?.[me.id]?.value,
-      );
-      console.log(
-        "subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value",
-        subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value,
-      );
       void queue.push(subscribedStream);
     });
 

package/src/tests/coMap.test.ts

@@ -1,5 +1,6 @@
 import { connectedPeers } from "cojson/src/streamUtils.ts";
 import { describe, expect, expectTypeOf, test } from "vitest";
+import { Group, randomSessionProvider } from "../exports.js";
 import {
   Account,
   CoMap,
@@ -11,8 +12,7 @@ import {
   fixedCredentialsAuth,
   isControlledAccount,
 } from "../index.web.js";
-import { Group, randomSessionProvider } from "../internal.js";
-import { loadCoValueOrFail, setupTwoNodes } from "./utils.js";
+import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 

package/src/tests/groupsAndAccounts.test.ts

@@ -1,7 +1,7 @@
 import { RawGroup } from "cojson";
 import { describe, expect, test } from "vitest";
 import { Account, CoMap, Group, WasmCrypto, co } from "../index.web.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 

package/src/tests/inbox.test.ts

@@ -0,0 +1,256 @@
+import { describe, expect, it } from "vitest";
+import { CoMap } from "../coValues/coMap";
+import { Group } from "../coValues/group";
+import { Inbox, InboxSender } from "../coValues/inbox";
+import { co } from "../internal";
+import { setupTwoNodes, waitFor } from "./utils";
+
+class Message extends CoMap {
+  text = co.string;
+}
+
+describe("Inbox", () => {
+  it("should create inbox and allow message exchange between accounts", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load(receiver.id, sender);
+    inboxSender.sendMessage(message);
+
+    // Track received messages
+    const receivedMessages: Message[] = [];
+    let senderAccountID: unknown = undefined;
+
+    // Subscribe to inbox messages
+    const unsubscribe = receiverInbox.subscribe(
+      Message,
+      async (message, id) => {
+        senderAccountID = id;
+        receivedMessages.push(message);
+      },
+    );
+
+    // Wait for message to be received
+    await waitFor(() => receivedMessages.length === 1);
+
+    expect(receivedMessages.length).toBe(1);
+    expect(receivedMessages[0]?.text).toBe("Hello");
+    expect(senderAccountID).toBe(sender.id);
+
+    unsubscribe();
+  });
+
+  it("should return the result of the message", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
+      return Message.create(
+        { text: "Responded from the inbox" },
+        { owner: message._owner },
+      );
+    });
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load<Message, Message>(
+      receiver.id,
+      sender,
+    );
+    const resultId = await inboxSender.sendMessage(message);
+
+    const result = await Message.load(resultId, receiver, {});
+    expect(result?.text).toBe("Responded from the inbox");
+
+    unsubscribe();
+  });
+
+  it("should return the undefined if the subscription returns undefined", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    const unsubscribe = receiverInbox.subscribe(Message, async (message) => {});
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load<Message>(receiver.id, sender);
+    const result = await inboxSender.sendMessage(message);
+
+    expect(result).toBeUndefined();
+
+    unsubscribe();
+  });
+
+  it("should reject if the subscription throws an error", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    const unsubscribe = receiverInbox.subscribe(Message, async () => {
+      return Promise.reject(new Error("Failed"));
+    });
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load<Message>(receiver.id, sender);
+
+    await expect(inboxSender.sendMessage(message)).rejects.toThrow(
+      "Error: Failed",
+    );
+
+    unsubscribe();
+  });
+
+  it("should mark messages as processed", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load(receiver.id, sender);
+    inboxSender.sendMessage(message);
+
+    // Track received messages
+    const receivedMessages: Message[] = [];
+
+    // Subscribe to inbox messages
+    const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
+      receivedMessages.push(message);
+    });
+
+    // Wait for message to be received
+    await waitFor(() => receivedMessages.length === 1);
+
+    inboxSender.sendMessage(message);
+
+    await waitFor(() => receivedMessages.length === 2);
+
+    expect(receivedMessages.length).toBe(2);
+    expect(receivedMessages[0]?.text).toBe("Hello");
+    expect(receivedMessages[1]?.text).toBe("Hello");
+
+    unsubscribe();
+  });
+
+  it("should unsubscribe correctly", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load(receiver.id, sender);
+    inboxSender.sendMessage(message);
+
+    // Track received messages
+    const receivedMessages: Message[] = [];
+
+    // Subscribe to inbox messages
+    const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
+      receivedMessages.push(message);
+    });
+
+    // Wait for message to be received
+    await waitFor(() => receivedMessages.length === 1);
+
+    unsubscribe();
+
+    inboxSender.sendMessage(message);
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    expect(receivedMessages.length).toBe(1);
+    expect(receivedMessages[0]?.text).toBe("Hello");
+  });
+
+  it("should retry failed messages", async () => {
+    const { clientAccount: sender, serverAccount: receiver } =
+      await setupTwoNodes();
+
+    const receiverInbox = await Inbox.load(receiver);
+
+    // Create a message from sender
+    const message = Message.create(
+      { text: "Hello" },
+      {
+        owner: Group.create({ owner: sender }),
+      },
+    );
+
+    // Setup inbox sender
+    const inboxSender = await InboxSender.load(receiver.id, sender);
+    const promise = inboxSender.sendMessage(message);
+
+    let failures = 0;
+
+    // Subscribe to inbox messages
+    const unsubscribe = receiverInbox.subscribe(
+      Message,
+      async () => {
+        failures++;
+        throw new Error("Failed");
+      },
+      { retries: 2 },
+    );
+
+    await expect(promise).rejects.toThrow();
+    expect(failures).toBe(3);
+    const [failed] = Object.values(receiverInbox.failed.items).flat();
+    expect(failed?.value.errors.length).toBe(3);
+    unsubscribe();
+  });
+});

package/src/tests/schemaUnion.test.ts

@@ -7,7 +7,7 @@ import {
   co,
   loadCoValue,
   subscribeToCoValue,
-} from "../internal.js";
+} from "../exports.js";
 
 class BaseWidget extends CoMap {
   type = co.string;

package/src/tests/utils.ts

@@ -54,12 +54,26 @@ export async function setupTwoNodes() {
     peersToLoadFrom: [serverAsPeer],
     crypto: Crypto,
     creationProps: { name: "Client" },
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new Account({
+        fromRaw: rawAccount,
+      });
+
+      await account.migrate?.(creationProps);
+    },
   });
 
   const server = await LocalNode.withNewlyCreatedAccount({
     peersToLoadFrom: [clientAsPeer],
     crypto: Crypto,
     creationProps: { name: "Server" },
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new Account({
+        fromRaw: rawAccount,
+      });
+
+      await account.migrate?.(creationProps);
+    },
   });
 
   return {

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: {
+    "index.web": "src/index.web.ts",
+    "index.native": "src/index.native.ts",
+  },
+  format: ["esm"],
+  dts: false,
+  sourcemap: true,
+  clean: true,
+  minify: false,
+});