@evolu/common 8.7.0 → 8.8.0

package/src/local-first/Evolu.ts

@@ -10,7 +10,11 @@ import {
   mapArray,
   type NonEmptyReadonlyArray,
 } from "../Array.ts";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.ts";
+import {
+  assert,
+  assertNonEmptyReadonlyArray,
+  assertNotUndefined,
+} from "../Assert.ts";
 import { createCallbacks } from "../Callbacks.ts";
 import type { ConsoleDep } from "../Console.ts";
 import { createConsole } from "../Console.ts";
@@ -371,11 +375,11 @@ export interface Evolu<
    *   ).id;
    *
    * assertType<
-   *   [TodoId, TodoId],
    *   [
    *     ReturnType<typeof insertTodo>,
    *     ReturnType<typeof insertTodoAndNotify>,
-   *   ]
+   *   ],
+   *   [TodoId, TodoId]
    * >();
    * ```
    *
@@ -415,8 +419,8 @@ export interface Evolu<
    *   evolu.update("todo", { id: todoId, isDeleted: sqliteTrue }).id;
    *
    * assertType<
-   *   [TodoId, TodoId],
-   *   [ReturnType<typeof renameTodo>, ReturnType<typeof softDeleteTodo>]
+   *   [ReturnType<typeof renameTodo>, ReturnType<typeof softDeleteTodo>],
+   *   [TodoId, TodoId]
    * >();
    * ```
    *
@@ -459,7 +463,7 @@ export interface Evolu<
    *     title: NonEmptyTrimmedString100.orThrow("Learn Evolu"),
    *   }).id;
    *
-   * assertType<TodoId, ReturnType<typeof upsertTodo>>();
+   * assertType<ReturnType<typeof upsertTodo>, TodoId>();
    * ```
    *
    * @see {@link Mutation}
@@ -506,8 +510,8 @@ export interface Evolu<
    * };
    *
    * assertType<
-   *   Promise<QueryRows<typeof allTodos.Row>>,
-   *   ReturnType<typeof loadTodos>
+   *   ReturnType<typeof loadTodos>,
+   *   Promise<QueryRows<typeof allTodos.Row>>
    * >();
    * ```
    */
@@ -553,11 +557,11 @@ export interface Evolu<
    *   evolu.loadQueries([allTodos, firstTodo]);
    *
    * assertType<
+   *   ReturnType<typeof loadTodoQueries>,
    *   [
    *     Promise<QueryRows<typeof allTodos.Row>>,
    *     Promise<QueryRows<typeof firstTodo.Row>>,
-   *   ],
-   *   ReturnType<typeof loadTodoQueries>
+   *   ]
    * >();
    * ```
    */
@@ -596,7 +600,7 @@ export interface Evolu<
    *     onRows(evolu.getQueryRows(allTodos));
    *   });
    *
-   * assertType<Unsubscribe, ReturnType<typeof subscribeToTodos>>();
+   * assertType<ReturnType<typeof subscribeToTodos>, Unsubscribe>();
    * ```
    */
   readonly subscribeQuery: (
@@ -629,8 +633,8 @@ export interface Evolu<
    *   evolu.getQueryRows(allTodos);
    *
    * assertType<
-   *   QueryRows<typeof allTodos.Row>,
-   *   ReturnType<typeof getTodos>
+   *   ReturnType<typeof getTodos>,
+   *   QueryRows<typeof allTodos.Row>
    * >();
    * ```
    */
@@ -1056,7 +1060,7 @@ export const createEvolu =
               if (!loadingPromise) continue;
 
               const rows = nextRowsByQueryMap.get(query);
-              assert(rows, "Expected patched query rows to exist.");
+              assertNotUndefined(rows);
 
               fulfillLoadingPromise(loadingPromise, rows);
 

package/src/local-first/Owner.test.ts

@@ -0,0 +1,83 @@
+import { eqData } from "../Eq.ts";
+import { test } from "node:test";
+import { assertEqual, assertFalse, assertNotUndefined } from "../Assert.ts";
+
+import {
+  createAppOwner,
+  createOwnerSecret,
+  deriveShardOwner,
+  mnemonicToOwnerSecret,
+  ownerIdBytesToOwnerId,
+  ownerIdToOwnerIdBytes,
+  ownerSecretToMnemonic,
+  testAppOwner,
+  testOwnerSecret,
+} from "./Owner.ts";
+import { testCreateDeps } from "../Task.ts";
+
+const testOwnerSecret2 = createOwnerSecret(testCreateDeps({ seed: "owner-2" }));
+
+test("ownerIdToOwnerIdBytes/ownerIdBytesToOwnerId", () => {
+  const id = testAppOwner.id;
+  assertEqual(ownerIdBytesToOwnerId(ownerIdToOwnerIdBytes(id)), id);
+});
+
+test("ownerSecretToMnemonic and mnemonicToOwnerSecret are inverses", () => {
+  const deps = testCreateDeps();
+  const secret = createOwnerSecret(deps);
+  const mnemonic = ownerSecretToMnemonic(secret);
+  const backToSecret = mnemonicToOwnerSecret(mnemonic);
+
+  assertEqual(backToSecret, secret);
+});
+
+test("createAppOwner is deterministic", () => {
+  const owner1 = createAppOwner(testOwnerSecret);
+  const owner2 = createAppOwner(testOwnerSecret);
+
+  assertEqual(owner1, owner2);
+  assertEqual(owner1.type, "AppOwner");
+  assertNotUndefined(owner1.mnemonic);
+});
+
+test("deriveShardOwner is deterministic", () => {
+  const appOwner = createAppOwner(testOwnerSecret);
+
+  const shard1 = deriveShardOwner(appOwner, ["contacts"]);
+  const shard2 = deriveShardOwner(appOwner, ["contacts"]);
+
+  assertEqual(shard1, shard2);
+  assertEqual(shard1.type, "ShardOwner");
+});
+
+test("deriveShardOwner with different paths produces different owners", () => {
+  const appOwner = createAppOwner(testOwnerSecret);
+
+  const contacts = deriveShardOwner(appOwner, ["contacts"]);
+  const photos = deriveShardOwner(appOwner, ["photos"]);
+
+  assertFalse(Object.is(contacts.id, photos.id));
+  assertFalse(eqData(contacts.encryptionKey, photos.encryptionKey));
+  assertFalse(eqData(contacts.writeKey, photos.writeKey));
+});
+
+test("deriveShardOwner with nested paths", () => {
+  const appOwner = createAppOwner(testOwnerSecret);
+
+  const project1 = deriveShardOwner(appOwner, ["projects", "project-1"]);
+  const project2 = deriveShardOwner(appOwner, ["projects", "project-2"]);
+
+  assertFalse(Object.is(project1.id, project2.id));
+  assertEqual(project1.type, "ShardOwner");
+  assertEqual(project2.type, "ShardOwner");
+});
+
+test("different app owners produce different shard owners", () => {
+  const appOwner1 = createAppOwner(testOwnerSecret);
+  const appOwner2 = createAppOwner(testOwnerSecret2);
+
+  const shard1 = deriveShardOwner(appOwner1, ["contacts"]);
+  const shard2 = deriveShardOwner(appOwner2, ["contacts"]);
+
+  assertFalse(Object.is(shard1.id, shard2.id));
+});