jazz-tools 0.19.14 → 0.19.16

package/src/tools/auth/clerk/tests/isClerkAuthStateEqual.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { isClerkAuthStateEqual } from "../types";
+
+describe("isClerkAuthStateEqual", () => {
+  const validCredentials = {
+    jazzAccountID: "account-123",
+    jazzAccountSecret: "secret-123",
+    jazzAccountSeed: [1, 2, 3],
+  };
+
+  const differentCredentials = {
+    jazzAccountID: "account-456",
+    jazzAccountSecret: "secret-456",
+    jazzAccountSeed: [4, 5, 6],
+  };
+
+  describe("both users null/undefined", () => {
+    it.each([
+      { previous: null, next: null, description: "both null" },
+      { previous: undefined, next: undefined, description: "both undefined" },
+      { previous: null, next: undefined, description: "null and undefined" },
+      { previous: undefined, next: null, description: "undefined and null" },
+    ])("returns true when $description", ({ previous, next }) => {
+      expect(isClerkAuthStateEqual(previous, next)).toBe(true);
+    });
+  });
+
+  describe("one user null, other exists", () => {
+    it.each([
+      {
+        previous: null,
+        next: { unsafeMetadata: validCredentials },
+        description: "previous null, next exists",
+      },
+      {
+        previous: { unsafeMetadata: validCredentials },
+        next: null,
+        description: "previous exists, next null",
+      },
+      {
+        previous: undefined,
+        next: { unsafeMetadata: validCredentials },
+        description: "previous undefined, next exists",
+      },
+      {
+        previous: { unsafeMetadata: validCredentials },
+        next: undefined,
+        description: "previous exists, next undefined",
+      },
+    ])("returns false when $description", ({ previous, next }) => {
+      expect(isClerkAuthStateEqual(previous, next)).toBe(false);
+    });
+  });
+
+  describe("same jazzAccountID", () => {
+    it("returns true when both users have the same jazzAccountID", () => {
+      const previous = { unsafeMetadata: validCredentials };
+      const next = {
+        unsafeMetadata: {
+          ...validCredentials,
+          jazzAccountSecret: "different-secret",
+        },
+      };
+      expect(isClerkAuthStateEqual(previous, next)).toBe(true);
+    });
+  });
+
+  describe("different jazzAccountID", () => {
+    it("returns false when users have different jazzAccountID", () => {
+      const previous = { unsafeMetadata: validCredentials };
+      const next = { unsafeMetadata: differentCredentials };
+      expect(isClerkAuthStateEqual(previous, next)).toBe(false);
+    });
+  });
+
+  describe("neither user has valid credentials", () => {
+    it.each([
+      {
+        previous: { unsafeMetadata: {} },
+        next: { unsafeMetadata: {} },
+        description: "both have empty metadata",
+      },
+      {
+        previous: { unsafeMetadata: { someOtherField: "value" } },
+        next: { unsafeMetadata: { anotherField: "value" } },
+        description: "both have non-credential metadata",
+      },
+      {
+        previous: { unsafeMetadata: { jazzAccountID: "123" } },
+        next: { unsafeMetadata: { jazzAccountSecret: "456" } },
+        description: "both have incomplete credentials",
+      },
+    ])("returns true when $description", ({ previous, next }) => {
+      expect(isClerkAuthStateEqual(previous, next)).toBe(true);
+    });
+  });
+
+  describe("one has credentials, other doesn't", () => {
+    it.each([
+      {
+        previous: { unsafeMetadata: validCredentials },
+        next: { unsafeMetadata: {} },
+        description: "previous has credentials, next empty",
+      },
+      {
+        previous: { unsafeMetadata: {} },
+        next: { unsafeMetadata: validCredentials },
+        description: "previous empty, next has credentials",
+      },
+      {
+        previous: { unsafeMetadata: validCredentials },
+        next: { unsafeMetadata: { jazzAccountID: "123" } },
+        description: "previous has credentials, next has incomplete",
+      },
+      {
+        previous: { unsafeMetadata: { jazzAccountSecret: "456" } },
+        next: { unsafeMetadata: validCredentials },
+        description: "previous has incomplete, next has credentials",
+      },
+    ])("returns false when $description", ({ previous, next }) => {
+      expect(isClerkAuthStateEqual(previous, next)).toBe(false);
+    });
+  });
+});

package/src/tools/auth/clerk/types.ts

@@ -36,21 +36,38 @@ export type ClerkCredentials = {
  * **Note**: It does not validate the credentials, only checks if the necessary fields are present in the metadata object.
  */
 export function isClerkCredentials(
-  data: NonNullable<MinimalClerkClient["user"]>["unsafeMetadata"] | undefined,
+  data:
+    | NonNullable<MinimalClerkClient["user"]>["unsafeMetadata"]
+    | null
+    | undefined,
 ): data is ClerkCredentials {
   return !!data && "jazzAccountID" in data && "jazzAccountSecret" in data;
 }
 
 export function isClerkAuthStateEqual(
-  previousUser: MinimalClerkClient["user"] | null | undefined,
-  newUser: MinimalClerkClient["user"] | null | undefined,
+  previousUser:
+    | Pick<NonNullable<MinimalClerkClient["user"]>, "unsafeMetadata">
+    | null
+    | undefined,
+  newUser:
+    | Pick<NonNullable<MinimalClerkClient["user"]>, "unsafeMetadata">
+    | null
+    | undefined,
 ) {
   if (Boolean(previousUser) !== Boolean(newUser)) {
     return false;
   }
 
-  const previousCredentials = isClerkCredentials(previousUser?.unsafeMetadata);
-  const newCredentials = isClerkCredentials(newUser?.unsafeMetadata);
+  const previousCredentials = isClerkCredentials(previousUser?.unsafeMetadata)
+    ? previousUser?.unsafeMetadata
+    : null;
+  const newCredentials = isClerkCredentials(newUser?.unsafeMetadata)
+    ? newUser?.unsafeMetadata
+    : null;
+
+  if (!previousCredentials || !newCredentials) {
+    return previousCredentials === newCredentials;
+  }
 
-  return previousCredentials === newCredentials;
+  return previousCredentials.jazzAccountID === newCredentials.jazzAccountID;
 }

package/src/tools/coValues/CoValueBase.ts

@@ -112,6 +112,30 @@ export abstract class CoValueJazzApi<V extends CoValue> {
     return this.raw.core.earliestTxMadeAt;
   }
 
+  /**
+   * Returns the account ID of the user who created this CoValue.
+   *
+   * Creation is determined by inspecting the earliest valid transaction,
+   * Note: Where the author is a sealer/signer identifiers (e.g. accounts)
+   * nothing is returned intentionally
+   *
+   * @returns {string | undefined} The creating user's account ID, or
+   * `undefined` if no author can be determined
+   *
+   * @category Content
+   */
+  get createdBy(): string | undefined {
+    const createdBy = this.raw.core.getValidSortedTransactions({
+      ignorePrivateTransactions: false,
+    })[0]?.author;
+
+    // Only return accounts, not sealer/signer strings
+    if (typeof createdBy === "string" && createdBy.startsWith("co_z"))
+      return createdBy;
+
+    return undefined;
+  }
+
   /**
    * The timestamp of the last updated time of the CoValue
    *

package/src/tools/coValues/coMap.ts

@@ -825,7 +825,7 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
           };
         },
         ownKeys(_target) {
-          return map.$jazz.raw.keys();
+          return Object.keys(map.$jazz.raw.ops);
         },
         getOwnPropertyDescriptor(target, key) {
           return {

package/src/tools/implementation/createContext.ts

@@ -274,8 +274,8 @@ export async function createJazzContext<
       crypto,
       AccountSchema: options.AccountSchema,
       sessionProvider: options.sessionProvider,
-      onLogOut: () => {
-        authSecretStorage.clearWithoutNotify();
+      onLogOut: async () => {
+        await authSecretStorage.clearWithoutNotify();
       },
       storage: options.storage,
       asActiveAccount: true,

package/src/tools/subscribe/SubscriptionScope.ts

@@ -29,7 +29,6 @@ import {
 } from "./errorReporting.js";
 import {
   createCoValue,
-  isEqualRefsToResolve,
   myRoleForRawValue,
   PromiseWithStatus,
   rejectedPromise,
@@ -49,25 +48,25 @@ export class SubscriptionScope<D extends CoValue> {
   /**
    * Autoloaded child ids that are unloaded
    */
-  pendingAutoloadedChildren: Set<string> = new Set();
+  private pendingAutoloadedChildren: Set<string> = new Set();
   value: SubscriptionValue<D, any> | SubscriptionValueLoading;
-  childErrors: Map<string, JazzError> = new Map();
-  validationErrors: Map<string, JazzError> = new Map();
+  private childErrors: Map<string, JazzError> = new Map();
+  private validationErrors: Map<string, JazzError> = new Map();
   errorFromChildren: JazzError | undefined;
-  subscription: CoValueCoreSubscription;
-  dirty = false;
-  resolve: RefsToResolve<any>;
-  idsSubscribed = new Set<string>();
-  autoloaded = new Set<string>();
-  autoloadedKeys = new Set<string>();
-  skipInvalidKeys = new Set<string>();
-  totalValidTransactions = 0;
-  version = 0;
-  migrated = false;
-  migrating = false;
+  private subscription: CoValueCoreSubscription;
+  private dirty = false;
+  private resolve: RefsToResolve<any>;
+  private idsSubscribed = new Set<string>();
+  private autoloaded = new Set<string>();
+  private autoloadedKeys = new Set<string>();
+  private skipInvalidKeys = new Set<string>();
+  private totalValidTransactions = 0;
+  private version = 0;
+  private migrated = false;
+  private migrating = false;
   closed = false;
 
-  silenceUpdates = false;
+  private silenceUpdates = false;
 
   /**
    * Stack trace captured at subscription creation time.
@@ -145,7 +144,9 @@ export class SubscriptionScope<D extends CoValue> {
     this.dirty = true;
   }
 
-  handleUpdate(update: RawCoValue | typeof CoValueLoadingState.UNAVAILABLE) {
+  private handleUpdate(
+    update: RawCoValue | typeof CoValueLoadingState.UNAVAILABLE,
+  ) {
     if (update === CoValueLoadingState.UNAVAILABLE) {
       if (this.value.type === CoValueLoadingState.LOADING) {
         const error = new JazzError(this.id, CoValueLoadingState.UNAVAILABLE, [
@@ -213,7 +214,7 @@ export class SubscriptionScope<D extends CoValue> {
     this.triggerUpdate();
   }
 
-  computeChildErrors() {
+  private computeChildErrors() {
     let issues: JazzErrorIssue[] = [];
     let errorType: JazzError["type"] = CoValueLoadingState.UNAVAILABLE;
 
@@ -259,11 +260,11 @@ export class SubscriptionScope<D extends CoValue> {
     return undefined;
   }
 
-  handleChildUpdate = (
+  handleChildUpdate(
     id: string,
     value: SubscriptionValue<any, any> | SubscriptionValueLoading,
     key?: string,
-  ) => {
+  ) {
     if (value.type === CoValueLoadingState.LOADING) {
       return;
     }
@@ -296,9 +297,9 @@ export class SubscriptionScope<D extends CoValue> {
     }
 
     this.triggerUpdate();
-  };
+  }
 
-  shouldSendUpdates() {
+  private shouldSendUpdates() {
     if (this.value.type === CoValueLoadingState.LOADING) return false;
 
     // If the value is in error, we send the update regardless of the children statuses
@@ -309,9 +310,9 @@ export class SubscriptionScope<D extends CoValue> {
 
   unloadedValue: NotLoaded<D> | undefined;
 
-  lastPromise: PromiseWithStatus<D> | undefined;
+  private lastPromise: PromiseWithStatus<D> | undefined;
 
-  getPromise() {
+  private getPromise() {
     const currentValue = this.getCurrentValue();
 
     if (currentValue.$isLoaded) {
@@ -403,7 +404,7 @@ export class SubscriptionScope<D extends CoValue> {
     return unloadedValue;
   }
 
-  lastErrorLogged: JazzError | undefined;
+  private lastErrorLogged: JazzError | undefined;
 
   getCurrentValue(): MaybeLoaded<D> {
     const rawValue = this.getCurrentRawValue();
@@ -420,7 +421,7 @@ export class SubscriptionScope<D extends CoValue> {
     return rawValue;
   }
 
-  getCurrentRawValue(): D | NotLoadedCoValueState {
+  private getCurrentRawValue(): D | NotLoadedCoValueState {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
@@ -443,7 +444,7 @@ export class SubscriptionScope<D extends CoValue> {
     return CoValueLoadingState.LOADING;
   }
 
-  getCreationStackLines() {
+  private getCreationStackLines() {
     const stack = this.callerStack?.stack;
 
     if (!stack) {
@@ -474,7 +475,7 @@ export class SubscriptionScope<D extends CoValue> {
     return result;
   }
 
-  getError() {
+  private getError() {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
@@ -487,7 +488,7 @@ export class SubscriptionScope<D extends CoValue> {
     }
   }
 
-  logError() {
+  private logError() {
     const error = this.getError();
 
     if (!error || this.lastErrorLogged === error) {
@@ -510,7 +511,7 @@ export class SubscriptionScope<D extends CoValue> {
     }
   }
 
-  triggerUpdate() {
+  private triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
     if (!this.dirty) return;
     if (this.subscribers.size === 0) return;
@@ -700,7 +701,7 @@ export class SubscriptionScope<D extends CoValue> {
     this.silenceUpdates = false;
   }
 
-  loadChildren() {
+  private loadChildren() {
     const { resolve } = this;
 
     if (this.value.type !== CoValueLoadingState.LOADED) {
@@ -816,7 +817,11 @@ export class SubscriptionScope<D extends CoValue> {
     return hasChanged;
   }
 
-  loadCoMapKey(map: CoMap, key: string, depth: Record<string, any> | true) {
+  private loadCoMapKey(
+    map: CoMap,
+    key: string,
+    depth: Record<string, any> | true,
+  ) {
     if (key === "$onError") {
       return undefined;
     }
@@ -858,7 +863,11 @@ export class SubscriptionScope<D extends CoValue> {
     return undefined;
   }
 
-  loadCoListKey(list: CoList, key: string, depth: Record<string, any> | true) {
+  private loadCoListKey(
+    list: CoList,
+    key: string,
+    depth: Record<string, any> | true,
+  ) {
     const descriptor = list.$jazz.getItemsDescriptor();
 
     if (!descriptor || !isRefEncoded(descriptor)) {
@@ -896,7 +905,7 @@ export class SubscriptionScope<D extends CoValue> {
     return undefined;
   }
 
-  loadChildNode(
+  private loadChildNode(
     id: string,
     query: RefsToResolve<any>,
     descriptor: RefEncoded<any>,

package/src/tools/tests/account.test.ts

@@ -506,4 +506,23 @@ describe("createAs", () => {
     // Verify execution order
     expect(executionOrder).toEqual(["migration", "onCreate"]);
   });
+  test("createdBy returns undefined", async () => {
+    const CustomAccount = co.account({
+      profile: co.profile({
+        name: z.string(),
+      }),
+      root: co.map({}),
+    });
+
+    const worker = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const createdAccount = await CustomAccount.createAs(worker, {
+      creationProps: { name: "Test Account" },
+    });
+
+    assertLoaded(createdAccount.account);
+    expect(createdAccount.account.$jazz.createdBy).toBe(undefined);
+  });
 });

package/src/tools/tests/coMap.record.test.ts

@@ -194,6 +194,49 @@ describe("CoMap.Record", async () => {
         $jazz: expect.objectContaining({ id: me.$jazz.id }),
       });
     });
+
+    test("getEdits() keys should return deleted keys", () => {
+      const me = Account.getMe();
+
+      const Person = co.record(z.string(), z.string());
+      const person = Person.create({ name: "John" });
+      person.$jazz.set("name", "Jane");
+      person.$jazz.delete("name");
+
+      expect(Object.keys(person.$jazz.getEdits())).toEqual(["name"]);
+
+      const edits = person.$jazz.getEdits().name?.all;
+
+      expect(edits).toEqual([
+        expect.objectContaining({
+          value: "John",
+          key: "name",
+          ref: undefined,
+          madeAt: expect.any(Date),
+        }),
+        expect.objectContaining({
+          value: "Jane",
+          key: "name",
+          ref: undefined,
+          madeAt: expect.any(Date),
+        }),
+        expect.objectContaining({
+          value: undefined,
+          key: "name",
+          ref: undefined,
+          madeAt: expect.any(Date),
+        }),
+      ]);
+
+      expect(edits?.[0]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({ id: me.$jazz.id }),
+      });
+      expect(edits?.[1]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({ id: me.$jazz.id }),
+      });
+    });
   });
 
   describe("Record resolution", async () => {

package/src/tools/tests/coMap.test.ts

@@ -26,6 +26,7 @@ import {
   disableJazzTestSync,
   getPeerConnectedToTestSyncServer,
   runWithoutActiveAccount,
+  setActiveAccount,
   setupJazzTestSync,
 } from "../testing.js";
 import { assertLoaded, setupTwoNodes, waitFor } from "./utils.js";
@@ -2316,28 +2317,93 @@ describe("CoMap migration", () => {
   });
 });
 
-describe("createdAt & lastUpdatedAt", () => {
+describe("createdAt, lastUpdatedAt, createdBy", () => {
   test("empty map created time", () => {
     const emptyMap = co.map({}).create({});
 
     expect(emptyMap.$jazz.lastUpdatedAt).toEqual(emptyMap.$jazz.createdAt);
   });
 
+  test("empty map created by", () => {
+    const emptyMap = co.map({}).create({});
+    const me = Account.getMe();
+    expect(emptyMap.$jazz.createdBy).toEqual(me.$jazz.id);
+  });
+
   test("created time and last updated time", async () => {
     const Person = co.map({
       name: z.string(),
     });
+    const me = Account.getMe();
 
     const person = Person.create({ name: "John" });
 
     const createdAt = person.$jazz.createdAt;
     expect(person.$jazz.lastUpdatedAt).toEqual(createdAt);
 
+    const createdBy = person.$jazz.createdBy;
+    expect(createdBy).toEqual(me.$jazz.id);
+
     await new Promise((r) => setTimeout(r, 10));
     person.$jazz.set("name", "Jane");
 
     expect(person.$jazz.createdAt).toEqual(createdAt);
     expect(person.$jazz.lastUpdatedAt).not.toEqual(createdAt);
+
+    // Double check after update.
+    expect(createdBy).toEqual(me.$jazz.id);
+  });
+
+  test("createdBy does not change when updated", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const me = Account.getMe();
+
+    const person = Person.create({ name: "John" });
+
+    const createdBy = person.$jazz.createdBy;
+    expect(createdBy).toEqual(me.$jazz.id);
+
+    await new Promise((r) => setTimeout(r, 10));
+    person.$jazz.set("name", "Jane");
+
+    // Double check after update.
+    expect(createdBy).toEqual(me.$jazz.id);
+  });
+
+  test("createdBy is after key rotation", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const me = Account.getMe();
+
+    // Create person
+    const person = Person.create({ name: "John" });
+
+    // True created by
+    const createdBy = person.$jazz.createdBy;
+
+    // Create a user, grant access, then kick to trigger key rotation.
+    const newUser = await createJazzTestAccount();
+
+    person.$jazz.owner.addMember(newUser, "reader");
+
+    // This should trigger read key rotation
+    person.$jazz.owner.removeMember(newUser);
+
+    // Now create a new user and grant access
+    const newUser2 = await createJazzTestAccount();
+    person.$jazz.owner.addMember(newUser2, "reader");
+
+    // Load the CoValue as the new user:
+    setActiveAccount(newUser2);
+
+    const personLoadedAsUser2 = await Person.load(person.$jazz.id);
+    assertLoaded(personLoadedAsUser2);
+    const createdByPerUser2 = personLoadedAsUser2.$jazz.createdBy;
+    // Double check after update.
+    expect(createdBy).toEqual(createdByPerUser2);
   });
 });