jazz-tools 0.8.44 → 0.8.45

package/package.json

@@ -6,25 +6,25 @@
   "react-native": "dist/native/index.native.js",
   "exports": {
     ".": {
-      "react-native": "./dist/native/index.native.js",
+      "react-native": "./dist/index.native.js",
       "types": "./src/index.web.ts",
-      "default": "./dist/web/index.web.js"
+      "default": "./dist/index.web.js"
     },
     "./native": {
-      "react-native": "./dist/native/index.native.js",
+      "react-native": "./dist/index.native.js",
       "types": "./src/index.native.ts",
-      "default": "./dist/native/index.native.js"
+      "default": "./dist/index.native.js"
     },
     "./src/*": "./src/*"
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.8.44",
+  "version": "0.8.45",
   "dependencies": {
-    "fast-check": "^3.17.2",
-    "cojson": "0.8.44"
+    "cojson": "0.8.45"
   },
   "devDependencies": {
+    "tsup": "8.3.5",
     "typescript": "~5.6.2",
     "vitest": "1.5.3"
   },
@@ -38,12 +38,9 @@
   "scripts": {
     "format-and-lint": "biome check .",
     "format-and-lint:fix": "biome check . --write",
-    "dev:web": "tsc --sourceMap --watch --outDir dist/web -p tsconfig.web.json",
-    "dev:native": "tsc --sourceMap --watch --outDir dist/native -p tsconfig.native.json",
+    "dev": "tsup --watch",
     "test": "vitest --run --root ../../ --project jazz-tools",
     "test:watch": "vitest --watch --root ../../ --project jazz-tools",
-    "build:web": "tsc --sourceMap --outDir dist/web -p tsconfig.web.json",
-    "build:native": "tsc --sourceMap --outDir dist/native -p tsconfig.native.json",
-    "build": "rm -rf ./dist && pnpm run build:web && pnpm run build:native"
+    "build": "tsup"
   }
 }

package/src/coValues/account.ts

@@ -14,16 +14,13 @@ import {
 } from "cojson";
 import {
   AnonymousJazzAgent,
-  CoMap,
   type CoValue,
   CoValueBase,
   CoValueClass,
   DeeplyLoaded,
   DepthsIn,
-  Group,
   ID,
   MembersSym,
-  Profile,
   Ref,
   type RefEncoded,
   RefIfCoValue,
@@ -37,6 +34,11 @@ import {
   subscriptionsScopes,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
+import { type CoMap } from "./coMap.js";
+import { type Group } from "./group.js";
+import { createInboxRoot } from "./inbox.js";
+import { Profile } from "./profile.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @category Identity & Permissions */
 export class Account extends CoValueBase implements CoValue {
@@ -59,7 +61,7 @@ export class Account extends CoValueBase implements CoValue {
         optional: false,
       } satisfies RefEncoded<Profile>,
       root: {
-        ref: () => CoMap,
+        ref: () => RegisteredSchemas["CoMap"],
         optional: true,
       } satisfies RefEncoded<CoMap>,
     };
@@ -234,18 +236,26 @@ export class Account extends CoValueBase implements CoValue {
     return this.toJSON();
   }
 
-  migrate(
-    this: Account,
-    creationProps?: { name: string },
-  ): void | Promise<void> {
+  migrate(this: Account, creationProps?: { name: string }) {
     if (creationProps) {
-      const profileGroup = Group.create({ owner: this });
+      const profileGroup = RegisteredSchemas["Group"].create({ owner: this });
       profileGroup.addMember("everyone", "reader");
       this.profile = Profile.create(
         { name: creationProps.name },
         { owner: profileGroup },
       );
     }
+
+    const node = this._raw.core.node;
+    const profile = node
+      .expectCoValueLoaded(this._raw.get("profile")!)
+      .getCurrentContent() as RawCoMap;
+
+    if (!profile.get("inbox")) {
+      const inboxRoot = createInboxRoot(this);
+      profile.set("inbox", inboxRoot.id);
+      profile.set("inboxInvite", inboxRoot.inviteLink);
+    }
   }
 
   /** @category Subscription & Loading */
@@ -388,3 +398,5 @@ export function isControlledAccount(account: Account): account is Account & {
 export type AccountClass<Acc extends Account> = CoValueClass<Acc> & {
   fromNode: (typeof Account)["fromNode"];
 };
+
+RegisteredSchemas["Account"] = Account;

package/src/coValues/coFeed.ts

@@ -16,7 +16,6 @@ import type {
   CoValueClass,
   DeeplyLoaded,
   DepthsIn,
-  Group,
   ID,
   IfCo,
   Schema,
@@ -24,7 +23,6 @@ import type {
   UnCo,
 } from "../internal.js";
 import {
-  Account,
   CoValueBase,
   ItemsSym,
   Ref,
@@ -37,6 +35,9 @@ import {
   subscribeToCoValue,
   subscribeToExistingCoValue,
 } from "../internal.js";
+import { type Account } from "./account.js";
+import { type Group } from "./group.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @deprecated Use CoFeedEntry instead */
 export type CoStreamEntry<Item> = CoFeedEntry<Item>;
@@ -436,7 +437,7 @@ function entryFromRawEntry<Item>(
       return (
         accountID &&
         new Ref<Account>(accountID as unknown as ID<Account>, loadedAs, {
-          ref: Account,
+          ref: RegisteredSchemas["Account"],
           optional: false,
         })?.accessFrom(
           accessFrom,

package/src/coValues/coList.ts

@@ -13,9 +13,7 @@ import type {
   UnCo,
 } from "../internal.js";
 import {
-  Account,
   AnonymousJazzAgent,
-  Group,
   ItemsSym,
   Ref,
   SchemaInit,
@@ -30,6 +28,9 @@ import {
   subscriptionsScopes,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
+import { type Account } from "./account.js";
+import { type Group } from "./group.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /**
  * CoLists are collaborative versions of plain arrays.
@@ -108,8 +109,8 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   /** @category Collaboration */
   get _owner(): Account | Group {
     return 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);
   }
 
   /**
@@ -162,7 +163,9 @@ export class CoList<Item = any> extends Array<Item> 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/coMap.ts

@@ -13,7 +13,6 @@ import type {
   CoValueClass,
   DeeplyLoaded,
   DepthsIn,
-  Group,
   ID,
   IfCo,
   RefEncoded,
@@ -22,7 +21,6 @@ import type {
   co,
 } from "../internal.js";
 import {
-  Account,
   CoValueBase,
   ItemsSym,
   Ref,
@@ -36,6 +34,9 @@ import {
   subscribeToExistingCoValue,
   subscriptionsScopes,
 } from "../internal.js";
+import { type Account } from "./account.js";
+import { type Group } from "./group.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 type CoMapEdit<V> = {
   value?: V;
@@ -178,7 +179,7 @@ export class CoMap extends CoValueBase implements CoValue {
       by:
         rawEdit.by &&
         new Ref<Account>(rawEdit.by as ID<Account>, target._loadedAs, {
-          ref: Account,
+          ref: RegisteredSchemas["Account"],
           optional: false,
         }).accessFrom(target, "_edits." + key + ".by"),
       madeAt: rawEdit.at,
@@ -742,3 +743,5 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
     }
   },
 };
+
+RegisteredSchemas["CoMap"] = CoMap;

package/src/coValues/deepLoading.ts

@@ -1,16 +1,10 @@
 import { SessionID } from "cojson";
-import {
-  Account,
-  CoFeed,
-  CoFeedEntry,
-  CoList,
-  ItemsSym,
-  Ref,
-  RefEncoded,
-  UnCo,
-} from "../internal.js";
-import { CoKeys, CoMap } from "./coMap.js";
-import { CoValue, ID } from "./interfaces.js";
+import { ItemsSym, type Ref, RefEncoded, UnCo } from "../internal.js";
+import { type Account } from "./account.js";
+import { type CoFeed, CoFeedEntry } from "./coFeed.js";
+import { type CoList } from "./coList.js";
+import { type CoKeys, type CoMap } from "./coMap.js";
+import { type CoValue, type ID } from "./interfaces.js";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fulfillsDepth(depth: any, value: CoValue): boolean {

package/src/coValues/extensions/imageDef.ts

@@ -1,4 +1,6 @@
-import { CoMap, FileStream, co, subscriptionsScopes } from "../../internal.js";
+import { co, subscriptionsScopes } from "../../internal.js";
+import { FileStream } from "../coFeed.js";
+import { CoMap } from "../coMap.js";
 
 /** @category Media */
 export class ImageDefinition extends CoMap {

package/src/coValues/group.ts

@@ -9,24 +9,19 @@ import type {
   Schema,
 } from "../internal.js";
 import {
-  Account,
-  AccountAndGroupProxyHandler,
-  CoMap,
   CoValueBase,
   MembersSym,
   Ref,
-  co,
   ensureCoValueLoaded,
-  isControlledAccount,
   loadCoValue,
   subscribeToCoValue,
   subscribeToExistingCoValue,
 } from "../internal.js";
-
-/** @category Identity & Permissions */
-export class Profile extends CoMap {
-  name = co.string;
-}
+import { AccountAndGroupProxyHandler, isControlledAccount } from "./account.js";
+import { type Account } from "./account.js";
+import { type CoMap } from "./coMap.js";
+import { type Profile } from "./profile.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @category Identity & Permissions */
 export class Group extends CoValueBase implements CoValue {
@@ -51,7 +46,7 @@ export class Group extends CoValueBase implements CoValue {
       profile: "json" satisfies Schema,
       root: "json" satisfies Schema,
       [MembersSym]: {
-        ref: () => Account,
+        ref: () => RegisteredSchemas["Account"],
         optional: false,
       } satisfies RefEncoded<Account>,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -229,3 +224,5 @@ export class Group extends CoValueBase implements CoValue {
     return this._raw.core.waitForSync(options);
   }
 }
+
+RegisteredSchemas["Group"] = Group;

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;
+}