jazz-vue 0.9.22 → 0.10.0

package/src/tests/testUtils.ts

@@ -4,7 +4,13 @@ import { JazzTestProvider } from "../testing";
 
 export const withJazzTestSetup = <C extends (...args: any[]) => any>(
   composable: C,
-  { account }: { account: Account | { guest: AnonymousJazzAgent } },
+  {
+    account,
+    isAuthenticated,
+  }: {
+    account?: Account | { guest: AnonymousJazzAgent };
+    isAuthenticated?: boolean;
+  } = {},
 ) => {
   let result;
 
@@ -23,6 +29,7 @@ export const withJazzTestSetup = <C extends (...args: any[]) => any>(
           JazzTestProvider,
           {
             account,
+            isAuthenticated,
           },
           {
             default: () => h(wrapper),

package/src/tests/useCoState.test.ts

@@ -1,10 +1,19 @@
 // @vitest-environment happy-dom
 
-import { CoMap, co } from "jazz-tools";
-import { createJazzTestAccount } from "jazz-tools/testing";
-import { describe, expect, it } from "vitest";
+import { CoMap, ID, co, cojsonInternals } from "jazz-tools";
+import { createJazzTestAccount, setupJazzTestSync } from "jazz-tools/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { useCoState } from "../index.js";
-import { withJazzTestSetup } from "./testUtils.js";
+import { waitFor, withJazzTestSetup } from "./testUtils.js";
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+});
+
+beforeEach(() => {
+  cojsonInternals.CO_VALUE_LOADING_CONFIG.MAX_RETRIES = 1;
+  cojsonInternals.CO_VALUE_LOADING_CONFIG.TIMEOUT = 1;
+});
 
 describe("useCoState", () => {
   it("should return the correct value", async () => {
@@ -124,4 +133,24 @@ describe("useCoState", () => {
     expect(result.value?.content).toBe("123");
     expect(result.value?.nested?.content).toBe("456");
   });
+
+  it("should return null if the coValue is not found", async () => {
+    class TestMap extends CoMap {
+      content = co.string;
+    }
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const [result] = withJazzTestSetup(() =>
+      useCoState(TestMap, "co_z123" as ID<TestMap>, {}),
+    );
+
+    expect(result.value).toBeUndefined();
+
+    await waitFor(() => {
+      expect(result.value).toBeNull();
+    });
+  });
 });

package/src/tests/usePassphraseAuth.test.ts

@@ -0,0 +1,95 @@
+// @vitest-environment happy-dom
+
+import { mnemonicToEntropy } from "@scure/bip39";
+import { AuthSecretStorage, KvStoreContext } from "jazz-tools";
+import { createJazzTestAccount, setupJazzTestSync } from "jazz-tools/testing";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { usePassphraseAuth } from "../index.js";
+import { testWordlist } from "./fixtures.js";
+import { waitFor, withJazzTestSetup } from "./testUtils.js";
+
+describe("usePassphraseAuth", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  afterEach(() => {
+    KvStoreContext.getInstance().getStorage().clearAll();
+  });
+
+  it("should show anonymous in state with non-authenticated account", async () => {
+    const [result] = withJazzTestSetup(
+      () => usePassphraseAuth({ wordlist: testWordlist }),
+      {
+        isAuthenticated: false,
+      },
+    );
+
+    expect(result.value.state).toBe("anonymous");
+  });
+
+  it("should show signed in state with authenticated account", async () => {
+    const [result] = withJazzTestSetup(
+      () => usePassphraseAuth({ wordlist: testWordlist }),
+      {
+        isAuthenticated: true,
+      },
+    );
+
+    expect(result.value.state).toBe("signedIn");
+  });
+
+  it("should sign up with the current credentials", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    const authSecretStorage = new AuthSecretStorage();
+    const credentialsBefore = await authSecretStorage.get();
+
+    const passphrase = await result.value.signUp();
+
+    expect(result.value.state).toBe("signedIn");
+    expect(await authSecretStorage.get()).toEqual({
+      ...credentialsBefore,
+      provider: "passphrase",
+    });
+    expect(mnemonicToEntropy(passphrase, testWordlist)).toEqual(
+      credentialsBefore?.secretSeed,
+    );
+  });
+
+  it("should log in with the previous passphrase", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    const authSecretStorage = new AuthSecretStorage();
+    const credentialsBefore = await authSecretStorage.get();
+
+    const passphrase = await result.value.signUp();
+
+    await result.value.logIn(passphrase);
+
+    expect(result.value.state).toBe("signedIn");
+    expect(await authSecretStorage.get()).toMatchObject({
+      ...credentialsBefore,
+      provider: "passphrase",
+    });
+  });
+
+  it("should return the current account passphrase", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    await waitFor(() => result.value.passphrase !== "");
+
+    const passphrase = result.value.passphrase;
+
+    expect(await result.value.signUp()).toBe(passphrase);
+  });
+});

package/vite.config.ts

@@ -23,5 +23,7 @@ export default defineConfig({
     rollupOptions: {
       external: ["vue"],
     },
+    sourcemap: true,
+    minify: false,
   },
 });

package/dist/provider-BZnz6FpX.js

@@ -1,69 +0,0 @@
-import { createJazzBrowserContext as l } from "jazz-browser";
-import { ref as c, defineComponent as z, provide as m, onMounted as g, watch as s, onUnmounted as y } from "vue";
-const u = c(), f = Symbol("JazzContext"), S = z({
-  name: "JazzProvider",
-  props: {
-    auth: {
-      type: [String, Object],
-      required: !0
-    },
-    AccountSchema: {
-      type: Object,
-      required: !1
-    },
-    peer: {
-      type: String,
-      required: !0
-    },
-    storage: {
-      type: String,
-      default: void 0
-    }
-  },
-  setup(a, { slots: o }) {
-    const e = c(void 0), i = c(0);
-    m(f, e);
-    const v = async () => {
-      var t, r;
-      e.value && ((r = (t = e.value).done) == null || r.call(t), e.value = void 0);
-      try {
-        const n = await l(
-          a.auth === "guest" ? { peer: a.peer, storage: a.storage } : {
-            AccountSchema: a.AccountSchema,
-            auth: a.auth,
-            peer: a.peer,
-            storage: a.storage
-          }
-        );
-        e.value = {
-          ...n,
-          logOut: () => {
-            var d;
-            (d = u.value) == null || d.call(u), i.value += 1;
-          }
-        };
-      } catch (n) {
-        console.error("Error creating Jazz browser context:", n);
-      }
-    };
-    return g(() => {
-      v();
-    }), s(
-      () => i.value,
-      async () => {
-        await v();
-      }
-    ), y(() => {
-      var t, r;
-      e.value && ((r = (t = e.value).done) == null || r.call(t));
-    }), () => {
-      var t;
-      return e.value ? (t = o.default) == null ? void 0 : t.call(o) : null;
-    };
-  }
-});
-export {
-  f as J,
-  S as a,
-  u as l
-};