jazz-tools 0.18.24 → 0.18.26

package/src/tools/implementation/zodSchema/schemaTypes/CoVectorSchema.ts

@@ -0,0 +1,105 @@
+import {
+  Account,
+  AnonymousJazzAgent,
+  CoVector,
+  Group,
+  InstanceOrPrimitiveOfSchema,
+  InstanceOrPrimitiveOfSchemaCoValuesNullable,
+  coOptionalDefiner,
+} from "../../../internal.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
+
+export interface CoreCoVectorSchema extends CoreCoValueSchema {
+  builtin: "CoVector";
+  dimensions: number;
+}
+
+export function createCoreCoVectorSchema(
+  dimensions: number,
+): CoreCoVectorSchema {
+  return {
+    collaborative: true as const,
+    builtin: "CoVector" as const,
+    dimensions,
+  };
+}
+
+export class CoVectorSchema implements CoreCoVectorSchema {
+  readonly collaborative = true as const;
+  readonly builtin = "CoVector" as const;
+
+  constructor(
+    public dimensions: number,
+    private coValueClass: typeof CoVector,
+  ) {}
+
+  /**
+   * Create a `CoVector` from a given vector.
+   */
+  create(
+    vector: number[] | Float32Array,
+    options?: { owner: Group } | Group,
+  ): CoVectorInstance;
+  /**
+   * Create a `CoVector` from a given vector.
+   *
+   * @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead.
+   */
+  create(
+    vector: number[] | Float32Array,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoVectorInstance;
+  create(
+    vector: number[] | Float32Array,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoVectorInstance {
+    return this.coValueClass.create(vector, options);
+  }
+
+  /**
+   * Load a `CoVector` with a given ID.
+   */
+  load(
+    id: string,
+    options?: { loadAs: Account | AnonymousJazzAgent },
+  ): Promise<CoVectorInstanceNullable> {
+    return this.coValueClass.load(id, options);
+  }
+
+  /**
+   * Subscribe to a `CoVector`, when you have an ID but don't have a `CoVector` instance yet
+   */
+  subscribe(
+    id: string,
+    options: { loadAs: Account | AnonymousJazzAgent },
+    listener: (
+      value: CoVectorInstanceNullable,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+  subscribe(
+    id: string,
+    listener: (
+      value: CoVectorInstanceNullable,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+  subscribe(...args: [any, ...any[]]) {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(...args);
+  }
+
+  getCoValueClass(): typeof CoVector {
+    return this.coValueClass;
+  }
+
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
+}
+
+export type CoVectorInstance = InstanceOrPrimitiveOfSchema<CoVectorSchema>;
+
+export type CoVectorInstanceNullable =
+  InstanceOrPrimitiveOfSchemaCoValuesNullable<CoVectorSchema>;

package/src/tools/implementation/zodSchema/schemaTypes/GroupSchema.ts

@@ -14,6 +14,7 @@ import {
 import { CoreCoValueSchema } from "./CoValueSchema.js";
 import { coOptionalDefiner } from "../zodCo.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import type { AccountRole, InviteSecret } from "cojson";
 
 export interface CoreGroupSchema extends CoreCoValueSchema {
   builtin: "Group";
@@ -51,7 +52,12 @@ export class GroupSchema implements CoreGroupSchema {
   ): Promise<Group | null> {
     return Group.load(id, options);
   }
-
+  createInvite<G extends Group>(
+    id: ID<G>,
+    options?: { role?: AccountRole; loadAs?: Account },
+  ): Promise<InviteSecret> {
+    return Group.createInvite(id, options);
+  }
   subscribe<G extends Group, const R extends RefsToResolve<G>>(
     id: ID<G>,
     listener: (value: Resolved<G, R>, unsubscribe: () => void) => void,

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchema.ts

@@ -7,9 +7,11 @@ import {
   CoMap,
   CoPlainText,
   CoRichText,
+  CoVector,
   CoValueClass,
   CoreAccountSchema,
   CoreCoRecordSchema,
+  CoreCoVectorSchema,
   FileStream,
   Group,
 } from "../../../internal.js";
@@ -63,11 +65,13 @@ export type InstanceOfSchema<S extends CoValueClass | AnyZodOrCoValueSchema> =
                     ? CoRichText
                     : S extends CoreFileStreamSchema
                       ? FileStream
-                      : S extends CoreCoOptionalSchema<infer T>
-                        ? InstanceOrPrimitiveOfSchema<T> | undefined
-                        : S extends CoDiscriminatedUnionSchema<infer Members>
-                          ? InstanceOrPrimitiveOfSchema<Members[number]>
-                          : never
+                      : S extends CoreCoVectorSchema
+                        ? Readonly<CoVector>
+                        : S extends CoreCoOptionalSchema<infer T>
+                          ? InstanceOrPrimitiveOfSchema<T> | undefined
+                          : S extends CoDiscriminatedUnionSchema<infer Members>
+                            ? InstanceOrPrimitiveOfSchema<Members[number]>
+                            : never
     : S extends CoValueClass
       ? InstanceType<S>
       : never;

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.ts

@@ -13,6 +13,8 @@ import {
   CoreCoListSchema,
   CoreCoMapSchema,
   CoreCoRecordSchema,
+  CoreCoVectorSchema,
+  CoVector,
   FileStream,
   Group,
 } from "../../../internal.js";
@@ -70,15 +72,19 @@ export type InstanceOfSchemaCoValuesNullable<
                   ? CoRichText | null
                   : S extends CoreFileStreamSchema
                     ? FileStream | null
-                    : S extends CoreCoOptionalSchema<infer Inner>
-                      ?
-                          | InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner>
-                          | undefined
-                      : S extends CoreCoDiscriminatedUnionSchema<infer Members>
-                        ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
-                            Members[number]
-                          >
-                        : never
+                    : S extends CoreCoVectorSchema
+                      ? Readonly<CoVector> | null
+                      : S extends CoreCoOptionalSchema<infer Inner>
+                        ?
+                            | InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner>
+                            | undefined
+                        : S extends CoreCoDiscriminatedUnionSchema<
+                              infer Members
+                            >
+                          ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
+                              Members[number]
+                            >
+                          : never
   : S extends CoValueClass
     ? InstanceType<S> | null
     : never;

package/src/tools/implementation/zodSchema/zodCo.ts

@@ -9,6 +9,7 @@ import {
   type CoRecordSchema,
   type DefaultProfileShape,
   type FileStreamSchema,
+  type CoVectorSchema,
   ImageDefinition,
   type PlainTextSchema,
   type Simplify,
@@ -18,6 +19,7 @@ import {
   createCoreCoMapSchema,
   createCoreCoPlainTextSchema,
   createCoreFileStreamSchema,
+  createCoreCoVectorSchema,
   hydrateCoreCoValueSchema,
   isAnyCoValueSchema,
   isCoValueClass,
@@ -193,6 +195,19 @@ export const coFileStreamDefiner = (): FileStreamSchema => {
   return hydrateCoreCoValueSchema(coreSchema);
 };
 
+export const coVectorDefiner = (dimensions: number): CoVectorSchema => {
+  const isPositiveInteger = Number.isInteger(dimensions) && dimensions > 0;
+
+  if (!isPositiveInteger) {
+    throw new Error(
+      "co.vector() expects the vector dimensions count to be a positive integer",
+    );
+  }
+
+  const coreSchema = createCoreCoVectorSchema(dimensions);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+
 export const coPlainTextDefiner = (): PlainTextSchema => {
   const coreSchema = createCoreCoPlainTextSchema();
   return hydrateCoreCoValueSchema(coreSchema);

package/src/tools/implementation/zodSchema/zodSchema.ts

@@ -33,6 +33,10 @@ import {
   CoreFileStreamSchema,
   FileStreamSchema,
 } from "./schemaTypes/FileStreamSchema.js";
+import {
+  CoreCoVectorSchema,
+  CoVectorSchema,
+} from "./schemaTypes/CoVectorSchema.js";
 import {
   CorePlainTextSchema,
   PlainTextSchema,
@@ -75,11 +79,15 @@ export type CoValueSchemaFromCoreSchema<S extends CoreCoValueSchema> =
                   ? RichTextSchema
                   : S extends CoreFileStreamSchema
                     ? FileStreamSchema
-                    : S extends CoreCoOptionalSchema<infer Inner>
-                      ? CoOptionalSchema<Inner>
-                      : S extends CoreCoDiscriminatedUnionSchema<infer Members>
-                        ? CoDiscriminatedUnionSchema<Members>
-                        : never;
+                    : S extends CoreCoVectorSchema
+                      ? CoVectorSchema
+                      : S extends CoreCoOptionalSchema<infer Inner>
+                        ? CoOptionalSchema<Inner>
+                        : S extends CoreCoDiscriminatedUnionSchema<
+                              infer Members
+                            >
+                          ? CoDiscriminatedUnionSchema<Members>
+                          : never;
 
 export type CoValueClassFromAnySchema<S extends CoValueClassOrSchema> =
   S extends CoValueClass<any>
@@ -104,7 +112,8 @@ export type AnyCoreCoValueSchema =
   | CoreCoOptionalSchema
   | CorePlainTextSchema
   | CoreRichTextSchema
-  | CoreFileStreamSchema;
+  | CoreFileStreamSchema
+  | CoreCoVectorSchema;
 
 export type AnyZodSchema = z.core.$ZodType;
 

package/src/tools/internal.ts

@@ -16,6 +16,7 @@ export * from "./coValues/inbox.js";
 export * from "./coValues/coPlainText.js";
 export * from "./coValues/coRichText.js";
 export * from "./coValues/schemaUnion.js";
+export * from "./coValues/coVector.js";
 
 export type * from "./subscribe/types.js";
 
@@ -43,6 +44,7 @@ export * from "./implementation/zodSchema/schemaTypes/CoListSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoFeedSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/AccountSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/FileStreamSchema.js";
+export * from "./implementation/zodSchema/schemaTypes/CoVectorSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/PlainTextSchema.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchema.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";

package/src/tools/ssr/ssr.ts

@@ -5,7 +5,7 @@ import { createAnonymousJazzContext } from "jazz-tools";
 export function createSSRJazzAgent(opts: { peer: string }) {
   const ssrNode = createAnonymousJazzContext({
     crypto: new PureJSCrypto(),
-    peersToLoadFrom: [],
+    peers: [],
   });
 
   const wsPeer = new WebSocketPeerWithReconnection({

package/src/tools/testing.ts

@@ -112,7 +112,7 @@ export async function createJazzTestAccount<
     },
     initialAgentSecret: crypto.agentSecretFromSecretSeed(secretSeed),
     crypto,
-    peersToLoadFrom: peers,
+    peers: peers,
     migration: async (rawAccount, _node, creationProps) => {
       if (isMigrationActive) {
         throw new Error(
@@ -185,7 +185,7 @@ export function runWithoutActiveAccount<Result>(
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
     crypto: await PureJSCrypto.create(),
-    peersToLoadFrom: [],
+    peers: [],
   });
 
   return {
@@ -318,7 +318,7 @@ export class TestJazzContextManager<
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,
-      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      peers: [getPeerConnectedToTestSyncServer()],
       crypto: await TestJSCrypto.create(),
       sessionProvider: randomSessionProvider,
       authSecretStorage: this.getAuthSecretStorage(),

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

@@ -1,6 +1,6 @@
 // @vitest-environment happy-dom
 
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { AuthSecretStorage } from "../auth/AuthSecretStorage";
 import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
 import KvStoreContext from "../auth/KvStoreContext";
@@ -428,4 +428,62 @@ describe("AuthSecretStorage", () => {
       });
     });
   });
+
+  describe("configurable secret storage key", () => {
+    const KEY = "test-auth-secret";
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage(KEY);
+    });
+
+    afterAll(() => {
+      // Restore the default storage key
+      authSecretStorage = new AuthSecretStorage();
+    });
+
+    it("should throw an error if the storage key is empty", () => {
+      expect(() => new AuthSecretStorage("")).toThrow(
+        "Too small: expected string to have >=1 characters",
+      );
+    });
+
+    it("should use the configured storage key on get", async () => {
+      const credentials = {
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "anonymous",
+      };
+      await kvStore.set(KEY, JSON.stringify(credentials));
+
+      const result = await authSecretStorage.get();
+
+      expect(result).toEqual({
+        accountID: "test123",
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "secret123",
+        provider: "anonymous",
+      });
+    });
+
+    it("should use the configured storage key on set", async () => {
+      const payload = {
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      };
+
+      await authSecretStorage.set(payload);
+
+      const stored = JSON.parse((await kvStore.get(KEY))!);
+      expect(stored).toEqual({
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "passphrase",
+      });
+    });
+  });
 });

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

@@ -56,7 +56,7 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,
-      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      peers: [getPeerConnectedToTestSyncServer()],
       crypto: Crypto,
       sessionProvider: randomSessionProvider,
       authSecretStorage: this.getAuthSecretStorage(),
@@ -541,6 +541,16 @@ describe("ContextManager", () => {
     ).rejects.toThrow("Props required");
   });
 
+  describe("configurable storage key", () => {
+    test("uses the configured storage key", async () => {
+      const KEY = "test-auth-secret";
+      const manager = new TestJazzContextManager<Account>({
+        authSecretStorageKey: KEY,
+      });
+      expect(manager.getAuthSecretStorage().getStorageKey()).toBe(KEY);
+    });
+  });
+
   describe("Race condition handling", () => {
     test("prevents concurrent authentication attempts", async () => {
       const account = await createJazzTestAccount();

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

@@ -409,3 +409,19 @@ describe("account.toJSON", () => {
     });
   });
 });
+
+describe("accepting invites", () => {
+  test("accepting an invite to a Group", async () => {
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+    const group = co.group().create();
+    const invite = group.$jazz.createInvite("reader");
+    const newAccount = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+    expect(group.getRoleOf(newAccount.$jazz.id)).toBeUndefined();
+    await newAccount.acceptInvite(group.$jazz.id, invite);
+    expect(group.getRoleOf(newAccount.$jazz.id)).toBe("reader");
+  });
+});

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

@@ -205,7 +205,7 @@ describe("CoPlainText", () => {
             secret: me.$jazz.localNode.getCurrentAgent().agentSecret,
           },
           sessionProvider: randomSessionProvider,
-          peersToLoadFrom: [initialAsPeer],
+          peers: [initialAsPeer],
           crypto: Crypto,
           asActiveAccount: true,
         });
@@ -237,7 +237,7 @@ describe("CoPlainText", () => {
           secret: me.$jazz.localNode.getCurrentAgent().agentSecret,
         },
         sessionProvider: randomSessionProvider,
-        peersToLoadFrom: [initialAsPeer],
+        peers: [initialAsPeer],
         crypto: Crypto,
         asActiveAccount: true,
       });

package/src/tools/tests/coVector.test-d.ts

@@ -0,0 +1,40 @@
+import { describe, expectTypeOf, test } from "vitest";
+import { Group, co } from "../exports.js";
+import { CoVectorSchema } from "../internal.js";
+
+describe("CoVector types", () => {
+  test("co.vector() • defines a correct CoVectorSchema", () => {
+    type ExpectedType = CoVectorSchema;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(co.vector(384));
+  });
+
+  test("co.vector().create() • creates a CoVector with Float32Array-like typing", () => {
+    const embedding = co.vector(3).create([1, 2, 3]);
+
+    type ExpectedType = Readonly<Float32Array>;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(embedding);
+  });
+
+  test("CoVector instance • has the owner property", () => {
+    const embedding = co.vector(3).create([1, 2, 3]);
+
+    expectTypeOf(embedding.$jazz.owner).toEqualTypeOf<Group>();
+  });
+
+  test("setting a value via index access • is a type error", () => {
+    const embedding = co.vector(3).create([1, 2, 3]);
+
+    // @ts-expect-error: assignment to index should be disallowed
+    embedding[0] = 6;
+  });
+});