jazz-tools 0.8.44 → 0.8.48

package/src/coValues/inbox.ts

@@ -0,0 +1,377 @@
+import {
+  CoID,
+  InviteSecret,
+  RawAccount,
+  RawCoMap,
+  RawControlledAccount,
+  SessionID,
+} from "cojson";
+import { CoStreamItem, RawCoStream } from "cojson";
+import { type Account } from "./account.js";
+import { CoValue, CoValueClass, ID, loadCoValue } from "./interfaces.js";
+
+export type InboxInvite = `${CoID<MessagesStream>}/${InviteSecret}`;
+type TxKey = `${SessionID}/${number}`;
+
+type MessagesStream = RawCoStream<CoID<InboxMessage<CoValue, any>>>;
+type FailedMessagesStream = RawCoStream<{
+  errors: string[];
+  value: CoID<InboxMessage<CoValue, any>>;
+}>;
+type TxKeyStream = RawCoStream<TxKey>;
+export type InboxRoot = RawCoMap<{
+  messages: CoID<MessagesStream>;
+  processed: CoID<TxKeyStream>;
+  failed: CoID<FailedMessagesStream>;
+  inviteLink: InboxInvite;
+}>;
+
+export function createInboxRoot(account: Account) {
+  if (!account.isMe) {
+    throw new Error("Account is not controlled");
+  }
+
+  const rawAccount = account._raw as RawControlledAccount;
+
+  const group = rawAccount.createGroup();
+  const messagesFeed = group.createStream<MessagesStream>();
+
+  const inboxRoot = rawAccount.createMap<InboxRoot>();
+  const processedFeed = rawAccount.createStream<TxKeyStream>();
+  const failedFeed = rawAccount.createStream<FailedMessagesStream>();
+
+  const inviteLink =
+    `${messagesFeed.id}/${group.createInvite("writeOnly")}` as const;
+
+  inboxRoot.set("messages", messagesFeed.id);
+  inboxRoot.set("processed", processedFeed.id);
+  inboxRoot.set("failed", failedFeed.id);
+
+  return {
+    id: inboxRoot.id,
+    inviteLink,
+  };
+}
+
+type InboxMessage<I extends CoValue, O extends CoValue | undefined> = RawCoMap<{
+  payload: ID<I>;
+  result: ID<O> | undefined;
+  processed: boolean;
+  error: string | undefined;
+}>;
+
+function createInboxMessage<I extends CoValue, O extends CoValue | undefined>(
+  payload: I,
+  inboxOwner: RawAccount,
+) {
+  const group = payload._raw.group;
+
+  if (group instanceof RawAccount) {
+    throw new Error("Inbox messages should be owned by a group");
+  }
+
+  group.addMember(inboxOwner, "writer");
+
+  const message = group.createMap<InboxMessage<I, O>>({
+    payload: payload.id,
+    result: undefined,
+    processed: false,
+    error: undefined,
+  });
+
+  return message;
+}
+
+export class Inbox {
+  account: Account;
+  messages: MessagesStream;
+  processed: TxKeyStream;
+  failed: FailedMessagesStream;
+  root: InboxRoot;
+  processing = new Set<`${SessionID}/${number}`>();
+
+  private constructor(
+    account: Account,
+    root: InboxRoot,
+    messages: MessagesStream,
+    processed: TxKeyStream,
+    failed: FailedMessagesStream,
+  ) {
+    this.account = account;
+    this.root = root;
+    this.messages = messages;
+    this.processed = processed;
+    this.failed = failed;
+  }
+
+  subscribe<I extends CoValue, O extends CoValue | undefined>(
+    Schema: CoValueClass<I>,
+    callback: (
+      message: I,
+      senderAccountID: ID<Account>,
+    ) => Promise<O | undefined | void>,
+    options: { retries?: number } = {},
+  ) {
+    const processed = new Set<`${SessionID}/${number}`>();
+    const failed = new Map<`${SessionID}/${number}`, string[]>();
+    const node = this.account._raw.core.node;
+
+    this.processed.subscribe((stream) => {
+      for (const items of Object.values(stream.items)) {
+        for (const item of items) {
+          processed.add(item.value as TxKey);
+        }
+      }
+    });
+
+    const { account } = this;
+    const { retries = 3 } = options;
+
+    let failTimer: ReturnType<typeof setTimeout> | number | undefined =
+      undefined;
+
+    const clearFailTimer = () => {
+      clearTimeout(failTimer);
+      failTimer = undefined;
+    };
+
+    const handleNewMessages = (stream: MessagesStream) => {
+      clearFailTimer(); // Stop the failure timers, we're going to process the failed entries anyway
+
+      for (const [sessionID, items] of Object.entries(stream.items) as [
+        SessionID,
+        CoStreamItem<CoID<InboxMessage<I, O>>>[],
+      ][]) {
+        const accountID = getAccountIDfromSessionID(sessionID);
+
+        if (!accountID) {
+          console.warn("Received message from unknown account", sessionID);
+          continue;
+        }
+
+        for (const item of items) {
+          const txKey = `${sessionID}/${item.tx.txIndex}` as const;
+
+          if (!processed.has(txKey) && !this.processing.has(txKey)) {
+            this.processing.add(txKey);
+
+            const id = item.value;
+
+            node
+              .load(id)
+              .then((message) => {
+                if (message === "unavailable") {
+                  return Promise.reject(
+                    new Error("Unable to load inbox message " + id),
+                  );
+                }
+
+                return loadCoValue(
+                  Schema,
+                  message.get("payload") as ID<I>,
+                  account,
+                  [],
+                );
+              })
+              .then((value) => {
+                if (!value) {
+                  return Promise.reject(
+                    new Error("Unable to load inbox message " + id),
+                  );
+                }
+
+                return callback(value, accountID);
+              })
+              .then((result) => {
+                const inboxMessage = node
+                  .expectCoValueLoaded(item.value)
+                  .getCurrentContent() as RawCoMap;
+
+                if (result) {
+                  inboxMessage.set("result", result.id);
+                }
+
+                inboxMessage.set("processed", true);
+
+                this.processed.push(txKey);
+                this.processing.delete(txKey);
+              })
+              .catch((error) => {
+                console.error("Error processing inbox message", error);
+                this.processing.delete(txKey);
+                const errors = failed.get(txKey) ?? [];
+
+                const stringifiedError = String(error);
+                errors.push(stringifiedError);
+
+                const inboxMessage = node
+                  .expectCoValueLoaded(item.value)
+                  .getCurrentContent() as RawCoMap;
+
+                inboxMessage.set("error", stringifiedError);
+
+                if (errors.length > retries) {
+                  inboxMessage.set("processed", true);
+                  this.processed.push(txKey);
+                  this.failed.push({ errors, value: item.value });
+                } else {
+                  failed.set(txKey, errors);
+                  if (!failTimer) {
+                    failTimer = setTimeout(
+                      () => handleNewMessages(stream),
+                      100,
+                    );
+                  }
+                }
+              });
+          }
+        }
+      }
+    };
+
+    return this.messages.subscribe(handleNewMessages);
+  }
+
+  static async load(account: Account) {
+    const profile = account.profile;
+
+    if (!profile) {
+      throw new Error("Account profile should already be loaded");
+    }
+
+    if (!profile.inbox) {
+      throw new Error("The account has not set up their inbox");
+    }
+
+    const node = account._raw.core.node;
+
+    const root = await node.load(profile.inbox as CoID<InboxRoot>);
+
+    if (root === "unavailable") {
+      throw new Error("Inbox not found");
+    }
+
+    const [messages, processed, failed] = await Promise.all([
+      node.load(root.get("messages")!),
+      node.load(root.get("processed")!),
+      node.load(root.get("failed")!),
+    ]);
+
+    if (
+      messages === "unavailable" ||
+      processed === "unavailable" ||
+      failed === "unavailable"
+    ) {
+      throw new Error("Inbox not found");
+    }
+
+    return new Inbox(account, root, messages, processed, failed);
+  }
+}
+
+export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
+  currentAccount: Account;
+  owner: RawAccount;
+  messages: MessagesStream;
+
+  private constructor(
+    currentAccount: Account,
+    owner: RawAccount,
+    messages: MessagesStream,
+  ) {
+    this.currentAccount = currentAccount;
+    this.owner = owner;
+    this.messages = messages;
+  }
+
+  getOwnerAccount() {
+    return this.owner;
+  }
+
+  sendMessage(message: I): Promise<O extends CoValue ? ID<O> : undefined> {
+    const inboxMessage = createInboxMessage<I, O>(message, this.owner);
+
+    this.messages.push(inboxMessage.id);
+
+    return new Promise((resolve, reject) => {
+      inboxMessage.subscribe((message) => {
+        if (message.get("processed")) {
+          const error = message.get("error");
+          if (error) {
+            reject(new Error(error));
+          } else {
+            resolve(
+              message.get("result") as O extends CoValue ? ID<O> : undefined,
+            );
+          }
+        }
+      });
+    });
+  }
+
+  static async load<
+    I extends CoValue,
+    O extends CoValue | undefined = undefined,
+  >(inboxOwnerID: ID<Account>, currentAccount: Account) {
+    const node = currentAccount._raw.core.node;
+
+    const inboxOwnerRaw = await node.load(
+      inboxOwnerID as unknown as CoID<RawAccount>,
+    );
+
+    if (inboxOwnerRaw === "unavailable") {
+      throw new Error("Failed to load the inbox owner");
+    }
+
+    const inboxOwnerProfileRaw = await node.load(inboxOwnerRaw.get("profile")!);
+
+    if (inboxOwnerProfileRaw === "unavailable") {
+      throw new Error("Failed to load the inbox owner profile");
+    }
+
+    const inboxInvite = inboxOwnerProfileRaw.get("inboxInvite");
+
+    if (!inboxInvite) {
+      throw new Error("The user has not set up their inbox");
+    }
+
+    const id = await acceptInvite(inboxInvite as InboxInvite, currentAccount);
+
+    const messages = await node.load(id);
+
+    if (messages === "unavailable") {
+      throw new Error("Inbox not found");
+    }
+
+    return new InboxSender<I, O>(currentAccount, inboxOwnerRaw, messages);
+  }
+}
+
+async function acceptInvite(invite: string, account: Account) {
+  const id = invite.slice(0, invite.indexOf("/")) as CoID<MessagesStream>;
+
+  const inviteSecret = invite.slice(invite.indexOf("/") + 1) as InviteSecret;
+
+  if (!id?.startsWith("co_z") || !inviteSecret.startsWith("inviteSecret_")) {
+    throw new Error("Invalid inbox ticket");
+  }
+
+  if (!account.isMe) {
+    throw new Error("Account is not controlled");
+  }
+
+  await (account._raw as RawControlledAccount).acceptInvite(id, inviteSecret);
+
+  return id;
+}
+
+function getAccountIDfromSessionID(sessionID: SessionID) {
+  const until = sessionID.indexOf("_session");
+  const accountID = sessionID.slice(0, until);
+
+  if (accountID.startsWith("co_z")) {
+    return accountID as ID<Account>;
+  }
+
+  return;
+}

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);
@@ -165,7 +169,7 @@ export async function createJazzContext<Acc extends Account>(
                 fromRaw: rawAccount,
               }) as Acc;
 
-              await account.migrate?.(creationProps);
+              await account.applyMigration(creationProps);
             },
           });
 
@@ -214,7 +218,7 @@ export async function createJazzContext<Acc extends Account>(
               fromRaw: rawAccount,
             }) as Acc;
 
-            await account.migrate?.(creationProps);
+            await account.applyMigration(creationProps);
           },
         });
 
@@ -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();
 
@@ -38,8 +38,6 @@ describe("Simple CoMap operations", async () => {
     crypto: Crypto,
   });
 
-  console.log("TestMap schema", TestMap.prototype._schema);
-
   const birthday = new Date();
 
   const map = TestMap.create(
@@ -82,6 +80,13 @@ describe("Simple CoMap operations", async () => {
     expect(mapWithExtra.color).toEqual("red");
   });
 
+  test("Empty schema", () => {
+    const emptyMap = CoMap.create({}, { owner: me });
+
+    // @ts-expect-error
+    expect(emptyMap.color).toEqual(undefined);
+  });
+
   describe("Mutation", () => {
     test("assignment & deletion", () => {
       map.color = "blue";
@@ -468,10 +473,8 @@ describe("CoMap resolution", async () => {
     const queue = new cojsonInternals.Channel<TestMap>();
 
     TestMap.subscribe(map.id, meOnSecondPeer, {}, (subscribedMap) => {
-      console.log(
-        "subscribedMap.nested?.twiceNested?.taste",
-        subscribedMap.nested?.twiceNested?.taste,
-      );
+      // Read to property to trigger loading
+      subscribedMap.nested?.twiceNested?.taste;
       void queue.push(subscribedMap);
     });