cojson 0.8.12 → 0.8.16

package/src/coValueState.ts

@@ -2,106 +2,116 @@ import { CoValueCore } from "./coValueCore.js";
 import { PeerID } from "./sync.js";
 
 function createResolvablePromise<T>() {
-    let resolve!: (value: T) => void;
+  let resolve!: (value: T) => void;
 
-    const promise = new Promise<T>((res) => {
-        resolve = res;
-    });
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
 
-    return { promise, resolve };
+  return { promise, resolve };
 }
 
 class CoValueUnknownState {
-    type = "unknown" as const;
-    private peers: Map<PeerID, ReturnType<typeof createResolvablePromise<"available" | "unavailable">>>;
-    private resolve: (value: "available" | "unavailable") => void;
-
-    ready: Promise<"available" | "unavailable">;
+  type = "unknown" as const;
+  private peers: Map<
+    PeerID,
+    ReturnType<typeof createResolvablePromise<"available" | "unavailable">>
+  >;
+  private resolve: (value: "available" | "unavailable") => void;
+
+  ready: Promise<"available" | "unavailable">;
+
+  constructor(peersIds: Iterable<PeerID>) {
+    this.peers = new Map();
+
+    for (const peerId of peersIds) {
+      this.peers.set(
+        peerId,
+        createResolvablePromise<"available" | "unavailable">(),
+      );
+    }
 
-    constructor(peersIds: Iterable<PeerID>) {
-        this.peers = new Map();
+    const { resolve, promise } = createResolvablePromise<
+      "available" | "unavailable"
+    >();
 
-        for (const peerId of peersIds) {
-            this.peers.set(peerId, createResolvablePromise<"available" | "unavailable">());
-        }
+    this.ready = promise;
+    this.resolve = resolve;
+  }
 
-        const { resolve, promise } = createResolvablePromise<"available" | "unavailable">();
+  update(peerId: PeerID, value: "available" | "unavailable") {
+    const entry = this.peers.get(peerId);
 
-        this.ready = promise;
-        this.resolve = resolve;
+    if (entry) {
+      entry.resolve(value);
     }
 
-    update(peerId: PeerID, value: "available" | "unavailable") {
-        const entry = this.peers.get(peerId);
-
-        if (entry) {
-            entry.resolve(value);
-        }
-
-        if (value === "available") {
-            this.resolve("available");
-            return;
-        }
+    if (value === "available") {
+      this.resolve("available");
+      return;
+    }
 
-        this.peers.delete(peerId);
+    this.peers.delete(peerId);
 
-        // If none of the peers have the coValue, we resolve to unavailable
-        if (this.peers.size === 0) {
-            this.resolve("unavailable");
-        }
+    // If none of the peers have the coValue, we resolve to unavailable
+    if (this.peers.size === 0) {
+      this.resolve("unavailable");
     }
+  }
 
-    // Wait for a specific peer to have a known state
-    waitForPeer(peerId: PeerID) {
-        const entry = this.peers.get(peerId);
+  // Wait for a specific peer to have a known state
+  waitForPeer(peerId: PeerID) {
+    const entry = this.peers.get(peerId);
 
-        if (!entry) {
-            return Promise.resolve();
-        }
-
-        return entry.promise;
+    if (!entry) {
+      return Promise.resolve();
     }
+
+    return entry.promise;
+  }
 }
 
 class CoValueAvailableState {
-    type = "available" as const;
+  type = "available" as const;
 
-    constructor(public coValue: CoValueCore) { }
+  constructor(public coValue: CoValueCore) {}
 }
 
-type CoValueStateAction = {
-    type: "not-found";
-    peerId: PeerID;
-} | {
-    type: "found";
-    peerId: PeerID;
-    coValue: CoValueCore;
-};
+type CoValueStateAction =
+  | {
+      type: "not-found";
+      peerId: PeerID;
+    }
+  | {
+      type: "found";
+      peerId: PeerID;
+      coValue: CoValueCore;
+    };
 
 export class CoValueState {
-    constructor(public state: CoValueUnknownState | CoValueAvailableState) { }
+  constructor(public state: CoValueUnknownState | CoValueAvailableState) {}
 
-    static Unknown(peersToWaitFor: Set<PeerID>) {
-        return new CoValueState(new CoValueUnknownState(peersToWaitFor));
-    }
+  static Unknown(peersToWaitFor: Set<PeerID>) {
+    return new CoValueState(new CoValueUnknownState(peersToWaitFor));
+  }
+
+  static Available(coValue: CoValueCore) {
+    return new CoValueState(new CoValueAvailableState(coValue));
+  }
 
-    static Available(coValue: CoValueCore) {
-        return new CoValueState(new CoValueAvailableState(coValue));
+  dispatch(action: CoValueStateAction) {
+    if (this.state.type === "available") {
+      return;
     }
 
-    dispatch(action: CoValueStateAction) {
-        if (this.state.type === "available") {
-            return;
-        }
-
-        switch (action.type) {
-            case "not-found":
-                this.state.update(action.peerId, "unavailable");
-                break;
-            case "found":
-                this.state.update(action.peerId, "available");
-                this.state = new CoValueAvailableState(action.coValue);
-                break;
-        }
+    switch (action.type) {
+      case "not-found":
+        this.state.update(action.peerId, "unavailable");
+        break;
+      case "found":
+        this.state.update(action.peerId, "available");
+        this.state = new CoValueAvailableState(action.coValue);
+        break;
     }
+  }
 }

package/src/coValues/account.ts

@@ -1,193 +1,186 @@
+import { Result, err, ok } from "neverthrow";
+import { CoID, RawCoValue } from "../coValue.js";
 import {
-    CoValueCore,
-    CoValueHeader,
-    CoValueUniqueness,
+  CoValueCore,
+  CoValueHeader,
+  CoValueUniqueness,
 } from "../coValueCore.js";
-import { CoID, RawCoValue } from "../coValue.js";
 import {
-    AgentSecret,
-    CryptoProvider,
-    SealerID,
-    SealerSecret,
-    SignerID,
-    SignerSecret,
+  AgentSecret,
+  CryptoProvider,
+  SealerID,
+  SealerSecret,
+  SignerID,
+  SignerSecret,
 } from "../crypto/crypto.js";
 import { AgentID } from "../ids.js";
-import { RawCoMap } from "./coMap.js";
-import { RawGroup, InviteSecret } from "./group.js";
 import { JsonObject } from "../jsonValue.js";
-import { err, ok, Result } from "neverthrow";
 import { LocalNode } from "../localNode.js";
+import { RawCoMap } from "./coMap.js";
+import { InviteSecret, RawGroup } from "./group.js";
 
 export function accountHeaderForInitialAgentSecret(
-    agentSecret: AgentSecret,
-    crypto: CryptoProvider,
+  agentSecret: AgentSecret,
+  crypto: CryptoProvider,
 ): CoValueHeader {
-    const agent = crypto.getAgentID(agentSecret);
-    return {
-        type: "comap",
-        ruleset: { type: "group", initialAdmin: agent },
-        meta: {
-            type: "account",
-        },
-        createdAt: null,
-        uniqueness: null,
-    };
+  const agent = crypto.getAgentID(agentSecret);
+  return {
+    type: "comap",
+    ruleset: { type: "group", initialAdmin: agent },
+    meta: {
+      type: "account",
+    },
+    createdAt: null,
+    uniqueness: null,
+  };
 }
 
 export type InvalidAccountAgentIDError = {
-    type: "InvalidAccountAgentID";
-    reason: string;
+  type: "InvalidAccountAgentID";
+  reason: string;
 };
 
 export class RawAccount<
-    Meta extends AccountMeta = AccountMeta,
+  Meta extends AccountMeta = AccountMeta,
 > extends RawGroup<Meta> {
-    _cachedCurrentAgentID: AgentID | undefined;
-
-    currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
-        if (this._cachedCurrentAgentID) {
-            return ok(this._cachedCurrentAgentID);
-        }
-        const agents = this.keys().filter((k): k is AgentID =>
-            k.startsWith("sealer_"),
-        );
-
-        if (agents.length !== 1) {
-            return err({
-                type: "InvalidAccountAgentID",
-                reason: "Account has " + agents.length + " agents",
-            });
-        }
-
-        this._cachedCurrentAgentID = agents[0];
-
-        return ok(agents[0]!);
+  _cachedCurrentAgentID: AgentID | undefined;
+
+  currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
+    if (this._cachedCurrentAgentID) {
+      return ok(this._cachedCurrentAgentID);
     }
+    const agents = this.keys()
+      .filter((k): k is AgentID => k.startsWith("sealer_"))
+      .sort(
+        (a, b) =>
+          (this.lastEditAt(a)?.at.getTime() || 0) -
+          (this.lastEditAt(b)?.at.getTime() || 0),
+      );
+
+    if (agents.length !== 1) {
+      console.warn("Account has " + agents.length + " agents", this.id);
+    }
+
+    this._cachedCurrentAgentID = agents[0];
+
+    return ok(agents[0]!);
+  }
 }
 
 export interface ControlledAccountOrAgent {
-    id: RawAccountID | AgentID;
-    agentSecret: AgentSecret;
-
-    currentAgentID: () => Result<AgentID, InvalidAccountAgentIDError>;
-    currentSignerID: () => Result<SignerID, InvalidAccountAgentIDError>;
-    currentSignerSecret: () => SignerSecret;
-    currentSealerID: () => Result<SealerID, InvalidAccountAgentIDError>;
-    currentSealerSecret: () => SealerSecret;
+  id: RawAccountID | AgentID;
+  agentSecret: AgentSecret;
+
+  currentAgentID: () => Result<AgentID, InvalidAccountAgentIDError>;
+  currentSignerID: () => Result<SignerID, InvalidAccountAgentIDError>;
+  currentSignerSecret: () => SignerSecret;
+  currentSealerID: () => Result<SealerID, InvalidAccountAgentIDError>;
+  currentSealerSecret: () => SealerSecret;
 }
 
 /** @hidden */
 export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
-    extends RawAccount<Meta>
-    implements ControlledAccountOrAgent
+  extends RawAccount<Meta>
+  implements ControlledAccountOrAgent
 {
-    agentSecret: AgentSecret;
-    crypto: CryptoProvider;
-
-    constructor(core: CoValueCore, agentSecret: AgentSecret) {
-        super(core);
-
-        this.agentSecret = agentSecret;
-        this.crypto = core.node.crypto;
-    }
-
-    /**
-     * Creates a new group (with the current account as the group's first admin).
-     * @category 1. High-level
-     */
-    createGroup(
-        uniqueness: CoValueUniqueness = this.core.crypto.createdNowUnique(),
-    ) {
-        return this.core.node.createGroup(uniqueness);
-    }
-
-    async acceptInvite<T extends RawCoValue>(
-        groupOrOwnedValueID: CoID<T>,
-        inviteSecret: InviteSecret,
-    ): Promise<void> {
-        return this.core.node.acceptInvite(groupOrOwnedValueID, inviteSecret);
-    }
-
-    currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
-        if (this._cachedCurrentAgentID) {
-            return ok(this._cachedCurrentAgentID);
-        }
-        const agentID = this.crypto.getAgentID(this.agentSecret);
-        this._cachedCurrentAgentID = agentID;
-        return ok(agentID);
-    }
-
-    currentSignerID() {
-        return this.currentAgentID().map((id) =>
-            this.crypto.getAgentSignerID(id),
-        );
-    }
-
-    currentSignerSecret(): SignerSecret {
-        return this.crypto.getAgentSignerSecret(this.agentSecret);
-    }
-
-    currentSealerID() {
-        return this.currentAgentID().map((id) =>
-            this.crypto.getAgentSealerID(id),
-        );
-    }
-
-    currentSealerSecret(): SealerSecret {
-        return this.crypto.getAgentSealerSecret(this.agentSecret);
+  agentSecret: AgentSecret;
+  crypto: CryptoProvider;
+
+  constructor(core: CoValueCore, agentSecret: AgentSecret) {
+    super(core);
+
+    this.agentSecret = agentSecret;
+    this.crypto = core.node.crypto;
+  }
+
+  /**
+   * Creates a new group (with the current account as the group's first admin).
+   * @category 1. High-level
+   */
+  createGroup(
+    uniqueness: CoValueUniqueness = this.core.crypto.createdNowUnique(),
+  ) {
+    return this.core.node.createGroup(uniqueness);
+  }
+
+  async acceptInvite<T extends RawCoValue>(
+    groupOrOwnedValueID: CoID<T>,
+    inviteSecret: InviteSecret,
+  ): Promise<void> {
+    return this.core.node.acceptInvite(groupOrOwnedValueID, inviteSecret);
+  }
+
+  currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
+    if (this._cachedCurrentAgentID) {
+      return ok(this._cachedCurrentAgentID);
     }
+    const agentID = this.crypto.getAgentID(this.agentSecret);
+    this._cachedCurrentAgentID = agentID;
+    return ok(agentID);
+  }
+
+  currentSignerID() {
+    return this.currentAgentID().map((id) => this.crypto.getAgentSignerID(id));
+  }
+
+  currentSignerSecret(): SignerSecret {
+    return this.crypto.getAgentSignerSecret(this.agentSecret);
+  }
+
+  currentSealerID() {
+    return this.currentAgentID().map((id) => this.crypto.getAgentSealerID(id));
+  }
+
+  currentSealerSecret(): SealerSecret {
+    return this.crypto.getAgentSealerSecret(this.agentSecret);
+  }
 }
 
 export class ControlledAgent implements ControlledAccountOrAgent {
-    constructor(
-        public agentSecret: AgentSecret,
-        public crypto: CryptoProvider,
-    ) {}
-
-    get id(): AgentID {
-        return this.crypto.getAgentID(this.agentSecret);
-    }
-
-    currentAgentID() {
-        return ok(this.crypto.getAgentID(this.agentSecret));
-    }
-
-    currentSignerID() {
-        return this.currentAgentID().map((id) =>
-            this.crypto.getAgentSignerID(id),
-        );
-    }
-
-    currentSignerSecret(): SignerSecret {
-        return this.crypto.getAgentSignerSecret(this.agentSecret);
-    }
-
-    currentSealerID() {
-        return this.currentAgentID().map((id) =>
-            this.crypto.getAgentSealerID(id),
-        );
-    }
-
-    currentSealerSecret(): SealerSecret {
-        return this.crypto.getAgentSealerSecret(this.agentSecret);
-    }
+  constructor(
+    public agentSecret: AgentSecret,
+    public crypto: CryptoProvider,
+  ) {}
+
+  get id(): AgentID {
+    return this.crypto.getAgentID(this.agentSecret);
+  }
+
+  currentAgentID() {
+    return ok(this.crypto.getAgentID(this.agentSecret));
+  }
+
+  currentSignerID() {
+    return this.currentAgentID().map((id) => this.crypto.getAgentSignerID(id));
+  }
+
+  currentSignerSecret(): SignerSecret {
+    return this.crypto.getAgentSignerSecret(this.agentSecret);
+  }
+
+  currentSealerID() {
+    return this.currentAgentID().map((id) => this.crypto.getAgentSealerID(id));
+  }
+
+  currentSealerSecret(): SealerSecret {
+    return this.crypto.getAgentSealerSecret(this.agentSecret);
+  }
 }
 
 export type AccountMeta = { type: "account" };
 export type RawAccountID = CoID<RawAccount>;
 
 export type ProfileShape = {
-    name: string;
+  name: string;
 };
 
 export class RawProfile<
-    Shape extends ProfileShape = ProfileShape,
-    Meta extends JsonObject | null = JsonObject | null,
+  Shape extends ProfileShape = ProfileShape,
+  Meta extends JsonObject | null = JsonObject | null,
 > extends RawCoMap<Shape, Meta> {}
 
 export type RawAccountMigration<Meta extends AccountMeta = AccountMeta> = (
-    account: RawControlledAccount<Meta>,
-    localNode: LocalNode,
-    creationProps?: { name: string },
+  account: RawControlledAccount<Meta>,
+  localNode: LocalNode,
+  creationProps?: { name: string },
 ) => void | Promise<void>;