jazz-tools 0.9.16 → 0.9.18

package/dist/index.native.js

@@ -17,16 +17,19 @@ import {
   Profile,
   SchemaUnion,
   co,
+  consumeInviteLink,
   createAnonymousJazzContext,
   createCoValueObservable,
+  createInviteLink,
   createJazzContext,
   ephemeralCredentialsAuth,
   fixedCredentialsAuth,
   isControlledAccount,
   loadCoValue,
+  parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-7OI3SFBS.js";
+} from "./chunk-LRDIS2Q2.js";
 
 // src/index.native.ts
 import {
@@ -56,13 +59,16 @@ export {
   SchemaUnion,
   co,
   cojsonInternals,
+  consumeInviteLink,
   createAnonymousJazzContext,
   createCoValueObservable,
+  createInviteLink,
   createJazzContext,
   ephemeralCredentialsAuth,
   fixedCredentialsAuth,
   isControlledAccount,
   loadCoValue,
+  parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
 };

package/dist/index.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.native.ts"],"sourcesContent":["export * from \"./exports.js\";\n\nexport {\n  MAX_RECOMMENDED_TX_SIZE,\n  cojsonInternals,\n} from \"cojson/native\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AAAA,EACE;AAAA,EACA;AAAA,OACK;","names":[]}
+{"version":3,"sources":["../src/index.native.ts"],"sourcesContent":["export * from \"./exports.js\";\n\nexport {\n  MAX_RECOMMENDED_TX_SIZE,\n  cojsonInternals,\n} from \"cojson/native\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AAAA,EACE;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/index.web.js

@@ -17,16 +17,19 @@ import {
   Profile,
   SchemaUnion,
   co,
+  consumeInviteLink,
   createAnonymousJazzContext,
   createCoValueObservable,
+  createInviteLink,
   createJazzContext,
   ephemeralCredentialsAuth,
   fixedCredentialsAuth,
   isControlledAccount,
   loadCoValue,
+  parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-7OI3SFBS.js";
+} from "./chunk-LRDIS2Q2.js";
 
 // src/index.web.ts
 import { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "cojson";
@@ -54,13 +57,16 @@ export {
   WasmCrypto,
   co,
   cojsonInternals,
+  consumeInviteLink,
   createAnonymousJazzContext,
   createCoValueObservable,
+  createInviteLink,
   createJazzContext,
   ephemeralCredentialsAuth,
   fixedCredentialsAuth,
   isControlledAccount,
   loadCoValue,
+  parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
 };

package/dist/index.web.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.web.ts"],"sourcesContent":["export * from \"./exports.js\";\n\nexport { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from \"cojson\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAS,iBAAiB,yBAAyB,kBAAkB;","names":[]}
+{"version":3,"sources":["../src/index.web.ts"],"sourcesContent":["export * from \"./exports.js\";\n\nexport { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from \"cojson\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAS,iBAAiB,yBAAyB,kBAAkB;","names":[]}

package/dist/testing.js

@@ -2,7 +2,7 @@ import {
   Account,
   activeAccountContext,
   createAnonymousJazzContext
-} from "./chunk-7OI3SFBS.js";
+} from "./chunk-LRDIS2Q2.js";
 
 // src/testing.ts
 import { LocalNode } from "cojson";

package/package.json

@@ -23,9 +23,9 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.9.16",
+  "version": "0.9.18",
   "dependencies": {
-    "cojson": "0.9.13"
+    "cojson": "0.9.18"
   },
   "devDependencies": {
     "tsup": "8.3.5",

package/src/coValues/group.ts

@@ -1,4 +1,10 @@
-import type { Everyone, RawAccountID, RawGroup, Role } from "cojson";
+import type {
+  AccountRole,
+  Everyone,
+  RawAccountID,
+  RawGroup,
+  Role,
+} from "cojson";
 import type {
   CoValue,
   CoValueClass,
@@ -133,7 +139,9 @@ export class Group extends CoValueBase implements CoValue {
     return this._raw.myRole();
   }
 
-  addMember(member: Everyone | Account, role: Role) {
+  addMember(member: Everyone, role: "writer" | "reader"): Group;
+  addMember(member: Account, role: AccountRole): Group;
+  addMember(member: Everyone | Account, role: AccountRole) {
     this._raw.addMember(member === "everyone" ? member : member._raw, role);
     return this;
   }

package/src/exports.ts

@@ -49,6 +49,12 @@ export {
   subscribeToCoValue,
 } from "./internal.js";
 
+export {
+  createInviteLink,
+  parseInviteLink,
+  consumeInviteLink,
+} from "./implementation/invites.js";
+
 export {
   AnonymousJazzAgent,
   createAnonymousJazzContext,

package/src/implementation/invites.ts

@@ -0,0 +1,99 @@
+import { type InviteSecret, cojsonInternals } from "cojson";
+import { Account } from "../coValues/account.js";
+import type { CoValue, CoValueClass, ID } from "../internal.js";
+
+/** @category Invite Links */
+export function createInviteLink<C extends CoValue>(
+  value: C,
+  role: "reader" | "writer" | "admin" | "writeOnly",
+  baseURL: string,
+  valueHint?: string,
+): string {
+  const coValueCore = value._raw.core;
+  let currentCoValue = coValueCore;
+
+  while (currentCoValue.header.ruleset.type === "ownedByGroup") {
+    currentCoValue = currentCoValue.getGroup().core;
+  }
+
+  const { ruleset, meta } = currentCoValue.header;
+
+  if (ruleset.type !== "group" || meta?.type === "account") {
+    throw new Error("Can't create invite link for object without group");
+  }
+
+  const group = cojsonInternals.expectGroup(currentCoValue.getCurrentContent());
+  const inviteSecret = group.createInvite(role);
+
+  return `${baseURL}#/invite/${valueHint ? valueHint + "/" : ""}${
+    value.id
+  }/${inviteSecret}`;
+}
+
+/** @category Invite Links */
+export function parseInviteLink<C extends CoValue>(
+  inviteURL: string,
+):
+  | {
+      valueID: ID<C>;
+      valueHint?: string;
+      inviteSecret: InviteSecret;
+    }
+  | undefined {
+  const url = new URL(inviteURL);
+  const parts = url.hash.split("/");
+
+  let valueHint: string | undefined;
+  let valueID: ID<C> | undefined;
+  let inviteSecret: InviteSecret | undefined;
+
+  if (parts[0] === "#" && parts[1] === "invite") {
+    if (parts.length === 5) {
+      valueHint = parts[2];
+      valueID = parts[3] as ID<C>;
+      inviteSecret = parts[4] as InviteSecret;
+    } else if (parts.length === 4) {
+      valueID = parts[2] as ID<C>;
+      inviteSecret = parts[3] as InviteSecret;
+    }
+
+    if (!valueID || !inviteSecret) {
+      return undefined;
+    }
+    return { valueID, inviteSecret, valueHint };
+  }
+}
+
+/** @category Invite Links */
+export function consumeInviteLink<V extends CoValue>({
+  inviteURL,
+  as = Account.getMe(),
+  forValueHint,
+  invitedObjectSchema,
+}: {
+  inviteURL: string;
+  as?: Account;
+  forValueHint?: string;
+  invitedObjectSchema: CoValueClass<V>;
+}): Promise<
+  | {
+      valueID: ID<V>;
+      valueHint?: string;
+      inviteSecret: InviteSecret;
+    }
+  | undefined
+> {
+  return new Promise((resolve, reject) => {
+    const result = parseInviteLink<V>(inviteURL);
+
+    if (result && result.valueHint === forValueHint) {
+      as.acceptInvite(result.valueID, result.inviteSecret, invitedObjectSchema)
+        .then(() => {
+          resolve(result);
+        })
+        .catch(reject);
+    } else {
+      resolve(undefined);
+    }
+  });
+}

package/src/tests/groupsAndAccounts.test.ts

@@ -1,10 +1,17 @@
 import { WasmCrypto } from "cojson";
-import { describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 import { Account, CoMap, Group, Profile, co } from "../exports.js";
+import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
+beforeEach(async () => {
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
 describe("Custom accounts and groups", async () => {
   class CustomProfile extends Profile {
     name = co.string;
@@ -180,4 +187,61 @@ describe("Group inheritance", () => {
 
     expect(loadedGroup).not.toBe("unavailable");
   });
+
+  test("everyone is valid only for reader and writer roles", () => {
+    const group = Group.create();
+    group.addMember("everyone", "reader");
+
+    expect(group.members).toContainEqual({
+      id: "everyone",
+      role: "reader",
+      account: undefined,
+      ref: undefined,
+    });
+
+    group.addMember("everyone", "writer");
+
+    expect(group.members).toContainEqual({
+      id: "everyone",
+      role: "writer",
+      account: undefined,
+      ref: undefined,
+    });
+
+    // @ts-expect-error - admin is not a valid role for everyone
+    expect(() => group.addMember("everyone", "admin")).toThrow();
+
+    expect(group.members).toContainEqual({
+      id: "everyone",
+      role: "writer",
+      account: undefined,
+      ref: undefined,
+    });
+
+    // @ts-expect-error - writeOnly is not a valid role for everyone
+    expect(() => group.addMember("everyone", "writeOnly")).toThrow();
+
+    expect(group.members).toContainEqual({
+      id: "everyone",
+      role: "writer",
+      account: undefined,
+      ref: undefined,
+    });
+  });
+
+  test("typescript should show an error when adding a member with a non-account role", async () => {
+    const account = await createJazzTestAccount({});
+
+    const group = Group.create();
+
+    // @ts-expect-error - Even though readerInvite is a valid role for an account, we don't allow it to not create confusion when using the intellisense
+    group.addMember(account, "readerInvite");
+
+    expect(group.members).toContainEqual(
+      expect.objectContaining({
+        id: account.id,
+        role: "readerInvite",
+      }),
+    );
+  });
 });

package/src/tests/invites.test.ts

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { Account, Group } from "../exports";
+import {
+  consumeInviteLink,
+  createInviteLink,
+  parseInviteLink,
+} from "../implementation/invites";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing";
+
+describe("Invite Links", () => {
+  let account: Account;
+  let group: Group;
+  const baseURL = "https://example.com";
+
+  beforeEach(async () => {
+    await setupJazzTestSync(); // Required to sync the invite between accounts
+    account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+    group = Group.create({ owner: account });
+  });
+
+  test("createInviteLink generates correct format", () => {
+    const inviteLink = createInviteLink(group, "writer", baseURL);
+
+    expect(inviteLink).toMatch(
+      new RegExp(`^${baseURL}#/invite/${group.id}/[A-Za-z0-9_-]+$`),
+    );
+  });
+
+  test("createInviteLink with valueHint", () => {
+    const inviteLink = createInviteLink(group, "writer", baseURL, "myGroup");
+
+    expect(inviteLink).toMatch(
+      new RegExp(`^${baseURL}#/invite/myGroup/${group.id}/[A-Za-z0-9_-]+$`),
+    );
+  });
+
+  test("parseInviteLink correctly parses valid link", () => {
+    const inviteLink = createInviteLink(group, "writer", baseURL, "myGroup");
+    const result = parseInviteLink(inviteLink);
+
+    expect(result).toBeDefined();
+    expect(result?.valueID).toBe(group.id);
+    expect(result?.valueHint).toBe("myGroup");
+    expect(result?.inviteSecret).toBeDefined();
+  });
+
+  test("parseInviteLink returns undefined for invalid link", () => {
+    const invalidLink = "https://example.com/not-an-invite";
+    const result = parseInviteLink(invalidLink);
+
+    expect(result).toBeUndefined();
+  });
+
+  test("consumeInviteLink accepts valid invite", async () => {
+    const inviteLink = createInviteLink(group, "writer", baseURL, "myGroup");
+    const newAccount = await createJazzTestAccount();
+
+    const result = await consumeInviteLink({
+      inviteURL: inviteLink,
+      as: newAccount,
+      forValueHint: "myGroup",
+      invitedObjectSchema: Group,
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.valueID).toBe(group.id);
+    expect(result?.valueHint).toBe("myGroup");
+  });
+
+  test("consumeInviteLink returns undefined for mismatched valueHint", async () => {
+    const inviteLink = createInviteLink(group, "writer", baseURL, "myGroup");
+    const newAccount = await createJazzTestAccount();
+
+    const result = await consumeInviteLink({
+      inviteURL: inviteLink,
+      as: newAccount,
+      forValueHint: "wrongHint",
+      invitedObjectSchema: Group,
+    });
+
+    expect(result).toBeUndefined();
+  });
+});