jazz-tools 0.7.0-alpha.4 → 0.7.0-alpha.42

package/src/implementation/refs.ts

@@ -4,34 +4,44 @@ import type {
     Account,
     CoValue,
     ID,
-    Me,
-    SubclassedConstructor,
+    RefEncoded,
+    UnCo,
     UnavailableError,
-    indexSignature,
 } from "../internal.js";
-import { subscriptionsScopes } from "../internal.js";
+import {
+    instantiateRefEncoded,
+    isRefEncoded,
+    subscriptionsScopes,
+} from "../internal.js";
+
+const refCache = new WeakMap<RawCoValue, CoValue>();
 
-export class ValueRef<V extends CoValue> {
-    private cachedValue: V | undefined;
+const TRACE_ACCESSES = false;
 
+export class Ref<out V extends CoValue> {
     constructor(
         readonly id: ID<V>,
-        readonly controlledAccount: Account & Me,
-        readonly valueConstructor: SubclassedConstructor<V>
-    ) {}
+        readonly controlledAccount: Account,
+        readonly schema: RefEncoded<V>,
+    ) {
+        if (!isRefEncoded(schema)) {
+            throw new Error("Ref must be constructed with a ref schema");
+        }
+    }
 
     get value() {
-        if (this.cachedValue) return this.cachedValue;
-        // TODO: cache it for object identity!!!
         const raw = this.controlledAccount._raw.core.node.getLoaded(
-            this.id as unknown as CoID<RawCoValue>
+            this.id as unknown as CoID<RawCoValue>,
         );
         if (raw) {
-            const value = new this.valueConstructor(undefined, {
-                fromRaw: raw,
-            }) as V;
-            this.cachedValue = value;
-            return value;
+            let value = refCache.get(raw);
+            if (value) {
+                // console.log("Using cached value for " + this.id);
+            } else {
+                value = instantiateRefEncoded(this.schema, raw);
+                refCache.set(raw, value);
+            }
+            return value as V;
         } else {
             return null;
         }
@@ -58,16 +68,12 @@ export class ValueRef<V extends CoValue> {
     }): Promise<V | "unavailable"> {
         const raw = await this.controlledAccount._raw.core.node.load(
             this.id as unknown as CoID<RawCoValue>,
-            options?.onProgress
+            options?.onProgress,
         );
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(
-                this.id,
-                this.controlledAccount,
-                this.valueConstructor
-            ).value!;
+            return new Ref(this.id, this.controlledAccount, this.schema).value!;
         }
     }
 
@@ -82,41 +88,72 @@ export class ValueRef<V extends CoValue> {
         }
     }
 
-    accessFrom(fromScopeValue: CoValue): V | null {
+    accessFrom(
+        fromScopeValue: CoValue,
+        key: string | number | symbol,
+    ): V | null {
         const subScope = subscriptionsScopes.get(fromScopeValue);
 
-        subScope?.onRefAccessedOrSet(this.id);
+        subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
+        TRACE_ACCESSES &&
+            console.log(
+                subScope?.scopeID,
+                "accessing",
+                fromScopeValue,
+                key,
+                this.id,
+            );
 
         if (this.value && subScope) {
             subscriptionsScopes.set(this.value, subScope);
         }
 
-        return this.value;
+        if (subScope) {
+            const cached = subScope.cachedValues[this.id];
+            if (cached) {
+                TRACE_ACCESSES && console.log("cached", cached);
+                return cached as V;
+            } else if (this.value !== null) {
+                const freshValueInstance = instantiateRefEncoded(
+                    this.schema,
+                    this.value?._raw,
+                );
+                TRACE_ACCESSES &&
+                    console.log("freshValueInstance", freshValueInstance);
+                subScope.cachedValues[this.id] = freshValueInstance;
+                subscriptionsScopes.set(freshValueInstance, subScope);
+                return freshValueInstance as V;
+            } else {
+                return null;
+            }
+        } else {
+            return this.value;
+        }
     }
 }
 
-export function makeRefs<Keys extends string | number | indexSignature>(
+export function makeRefs<Keys extends string | number>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
-    controlledAccount: Account & Me,
-    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>
-): { [K in Keys]: ValueRef<CoValue> } & {
-    [Symbol.iterator]: () => IterableIterator<ValueRef<CoValue>>;
+    controlledAccount: Account,
+    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>,
+): { [K in Keys]: Ref<CoValue> } & {
+    [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
     length: number;
 } {
-    const refs = {} as { [K in Keys]: ValueRef<CoValue> } & {
-        [Symbol.iterator]: () => IterableIterator<ValueRef<CoValue>>;
+    const refs = {} as { [K in Keys]: Ref<CoValue> } & {
+        [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
         length: number;
     };
     return new Proxy(refs, {
-        get(target, key) {
+        get(_target, key) {
             if (key === Symbol.iterator) {
                 return function* () {
                     for (const key of getKeysWithIds()) {
-                        yield new ValueRef(
+                        yield new Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            valueConstructorForKey(key)
+                            refSchemaForKey(key),
                         );
                     }
                 };
@@ -127,14 +164,30 @@ export function makeRefs<Keys extends string | number | indexSignature>(
             }
             const id = getIdForKey(key as Keys);
             if (!id) return undefined;
-            return new ValueRef(
+            return new Ref(
                 id as ID<CoValue>,
                 controlledAccount,
-                valueConstructorForKey(key as Keys)
+                refSchemaForKey(key as Keys),
             );
         },
         ownKeys() {
             return getKeysWithIds().map((key) => key.toString());
         },
+        getOwnPropertyDescriptor(target, key) {
+            const id = getIdForKey(key as Keys);
+            if (id) {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                };
+            } else {
+                return Reflect.getOwnPropertyDescriptor(target, key);
+            }
+        },
     });
 }
+
+export type RefIfCoValue<V> = NonNullable<V> extends CoValue
+    ? Ref<UnCo<NonNullable<V>>>
+    : never;

package/src/implementation/schema.ts

@@ -1,31 +1,100 @@
-import type { JsonValue } from "cojson";
-import type { CoValue, CoValueClass } from "../internal.js";
-import type { Schema, TypeId } from "@effect/schema/Schema";
+import type { JsonValue, RawCoValue } from "cojson";
+import {
+    type CoValue,
+    type CoValueClass,
+    isCoValueClass,
+} from "../internal.js";
+import type { Schema as EffectSchema, TypeId } from "@effect/schema/Schema";
 
-export type PrimitiveField = "json";
-export type EncodedField<V> = { encoded: Encoder<V> };
-export type RefField<V extends CoValue> = {
-    ref: () => CoValueClass<V>;
+export type CoMarker = { readonly __co: unique symbol };
+/** @category Schema definition */
+export type co<T> = T | (T & CoMarker);
+export type IfCo<C, R> = C extends infer _A | infer B
+    ? B extends CoMarker
+        ? R
+        : never
+    : never;
+export type UnCo<T> = T extends co<infer A> ? A : T;
+
+/** @category Schema definition */
+export const co = {
+    string: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<string>,
+    number: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<number>,
+    boolean: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<boolean>,
+    null: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<null>,
+    literal: <T extends (string | number | boolean)[]>(
+        ..._lit: T
+    ): co<T[number]> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    json: <T extends JsonValue>(): co<T> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    encoded: <T>(arg: Encoder<T>): co<T> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+    },
+    ref: <C extends CoValueClass>(
+        arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+    ): co<InstanceType<C> | null> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: arg satisfies Schema } as any;
+    },
+    items: ItemsSym as ItemsSym,
+    members: MembersSym as MembersSym,
 };
 
-export type FieldDescriptor =
-    | PrimitiveField
-    | RefField<CoValue>
-    | EncodedField<any>;
+export type JsonEncoded = "json";
+export type EncodedAs<V> = { encoded: Encoder<V> };
+export type RefEncoded<V extends CoValue> =
+    | CoValueClass<V>
+    | ((raw: RawCoValue) => CoValueClass<V>);
+
+export function isRefEncoded<V extends CoValue>(
+    schema: Schema,
+): schema is RefEncoded<V> {
+    return typeof schema === "function";
+}
+
+export function instantiateRefEncoded<V extends CoValue>(
+    schema: RefEncoded<V>,
+    raw: RawCoValue,
+): V {
+    return isCoValueClass(schema)
+        ? schema.fromRaw(raw)
+        : (schema as (raw: RawCoValue) => CoValueClass<V>)(raw).fromRaw(raw);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
 
-export type FieldDescriptorFor<Field> = NonNullable<Field> extends CoValue
-    ? RefField<NonNullable<Field>>
+export type SchemaFor<Field> = NonNullable<Field> extends CoValue
+    ? RefEncoded<NonNullable<Field>>
     : NonNullable<Field> extends JsonValue
-      ? PrimitiveField
-      : EncodedField<NonNullable<Field>>;
+      ? JsonEncoded
+      : EncodedAs<NonNullable<Field>>;
 
-export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
+export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
     never
 > & {
     [TypeId]: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         _A: (_: any) => A;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         _I: (_: any) => I;
     };
 };
@@ -33,37 +102,9 @@ export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
 export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
 
 import { Date } from "@effect/schema/Schema";
+import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";
 
+/** @category Schema definition */
 export const Encoders = {
     Date,
 };
-
-export const indexSignature = Symbol.for("indexSignature");
-export type indexSignature = typeof indexSignature;
-
-export type EnsureCoValueNullable<
-    V,
-    Key extends string | indexSignature,
-> = NonNullable<V> extends CoValue
-    ? null extends V
-        ? V
-        : Key extends string
-          ? [
-                `👋 CoMap fields that are CoValue references should be nullable, declare ${Key} as:`,
-                V | null,
-            ]
-          : [
-                `👋 CoMap fields that are CoValue references should be nullable, declare [indexSignature] as:`,
-                V | null,
-            ]
-    : V;
-
-export type EnsureItemNullable<Item, ContainerType extends string> =
-    NonNullable<Item> extends CoValue
-        ? null extends Item
-            ? any
-            : [
-                  `👋 CoList items that are CoValue references should be nullable, make sure the Item generic parameter of ${ContainerType} is:`,
-                  Item | null
-              ]
-        : any;

package/src/implementation/subscriptionScope.ts

@@ -1,16 +1,23 @@
 import type { RawCoValue } from "cojson";
-import type { Account, CoValue, CoValueBase, ID, Me, SubclassedConstructor } from "../internal.js";
+import type {
+    Account,
+    CoValue,
+    CoValueBase,
+    ID,
+    ClassOf,
+} from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
     CoValue,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     SubscriptionScope<any>
 >();
 
-export class SubscriptionScope<
-    Root extends CoValue
-> {
+const TRACE_INVALIDATIONS = false;
+
+export class SubscriptionScope<Root extends CoValue> {
     scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
-    subscriber: Account & Me;
+    subscriber: Account;
     entries = new Map<
         ID<CoValue>,
         | { state: "loading"; immediatelyUnsub?: boolean }
@@ -23,11 +30,13 @@ export class SubscriptionScope<
     };
     onUpdate: (newRoot: Root) => void;
     scheduledUpdate: boolean = false;
+    cachedValues: { [id: ID<CoValue>]: CoValue } = {};
+    parents: { [id: ID<CoValue>]: Set<ID<CoValue>> } = {};
 
     constructor(
         root: Root,
-        rootSchema: SubclassedConstructor<Root> & typeof CoValueBase,
-        onUpdate: (newRoot: Root) => void
+        rootSchema: ClassOf<Root> & typeof CoValueBase,
+        onUpdate: (newRoot: Root) => void,
     ) {
         this.rootEntry = {
             state: "loaded" as const,
@@ -43,13 +52,11 @@ export class SubscriptionScope<
         this.rootEntry.rawUnsub = root._raw.core.subscribe(
             (rawUpdate: RawCoValue | undefined) => {
                 if (!rawUpdate) return;
-                this.rootEntry.value = rootSchema.fromRaw(
-                    rawUpdate
-                ) as Root;
+                this.rootEntry.value = rootSchema.fromRaw(rawUpdate) as Root;
                 // console.log("root update", this.rootEntry.value.toJSON());
                 subscriptionsScopes.set(this.rootEntry.value, this);
                 this.scheduleUpdate();
-            }
+            },
         );
     }
 
@@ -63,12 +70,19 @@ export class SubscriptionScope<
         }
     }
 
-    onRefAccessedOrSet(accessedOrSetId: ID<CoValue> | undefined) {
+    onRefAccessedOrSet(
+        fromId: ID<CoValue>,
+        accessedOrSetId: ID<CoValue> | undefined,
+    ) {
         // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
         if (!accessedOrSetId) {
             return;
         }
 
+        this.parents[accessedOrSetId] =
+            this.parents[accessedOrSetId] || new Set();
+        this.parents[accessedOrSetId]!.add(fromId);
+
         if (!this.entries.has(accessedOrSetId)) {
             const loadingEntry = {
                 state: "loading",
@@ -94,6 +108,7 @@ export class SubscriptionScope<
                         const rawUnsub = core.subscribe((rawUpdate) => {
                             // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
                             if (!rawUpdate) return;
+                            this.invalidate(accessedOrSetId);
                             this.scheduleUpdate();
                         });
 
@@ -103,6 +118,23 @@ export class SubscriptionScope<
         }
     }
 
+    invalidate(id: ID<CoValue>, fromChild?: ID<CoValue>, seen: Set<ID<CoValue>> = new Set()) {
+        if (seen.has(id)) return;
+        TRACE_INVALIDATIONS &&
+            console.log(
+                "invalidating",
+                fromChild,
+                "->",
+                id,
+                this.cachedValues[id],
+            );
+        delete this.cachedValues[id];
+        seen.add(id);
+        for (const parent of this.parents[id] || []) {
+            this.invalidate(parent, id, seen);
+        }
+    }
+
     unsubscribeAll() {
         for (const entry of this.entries.values()) {
             if (entry.state === "loaded") {

package/src/implementation/symbols.ts

@@ -0,0 +1,11 @@
+export const SchemaInit = Symbol.for("SchemaInit");
+export type SchemaInit = typeof SchemaInit;
+
+export const InitValues = Symbol.for("InitValues");
+export type InitValues = typeof InitValues;
+
+export const ItemsSym = Symbol.for("items");
+export type ItemsSym = typeof ItemsSym;
+
+export const MembersSym = Symbol.for("members");
+export type MembersSym = typeof MembersSym;

package/src/index.ts

@@ -1,23 +1,27 @@
-/** @category Internal types */
 export {
-    cojsonReady as jazzReady,
+    cojsonInternals,
+    MAX_RECOMMENDED_TX_SIZE,
+    WasmCrypto,
+    PureJSCrypto,
+} from "cojson";
+export type {
     InviteSecret,
     Peer,
     SessionID,
     AgentID,
     SyncMessage,
-    cojsonInternals,
-    MAX_RECOMMENDED_TX_SIZE,
+    CryptoProvider,
 } from "cojson";
 
-export { ID, CoValue } from "./internal.js";
+export type { ID, CoValue } from "./internal.js";
 
-export { Encoders } from "./internal.js";
+export { Encoders, co } from "./internal.js";
 
-export { CoMap, indexSignature } from "./internal.js";
+export { CoMap } from "./internal.js";
 export { CoList } from "./internal.js";
 export { CoStream, BinaryCoStream } from "./internal.js";
 export { Group, Profile } from "./internal.js";
-export { Account, Me } from "./internal.js";
+export { Account, isControlledAccount } from "./internal.js";
 export { ImageDefinition } from "./internal.js";
-export { CoValueBase, CoValueClass } from "./internal.js";
+export { CoValueBase, type CoValueClass } from "./internal.js";
+export type { DepthsIn, DeeplyLoaded } from "./internal.js";

package/src/internal.ts

@@ -1,4 +1,5 @@
-export * from './implementation/inspect.js';
+export * from "./implementation/symbols.js";
+export * from "./implementation/inspect.js";
 export * from "./coValues/interfaces.js";
 
 export * from "./coValues/coMap.js";
@@ -11,5 +12,8 @@ export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
+export * from "./coValues/deepLoading.js";
 
-export * from "./coValues/extensions/imageDef.js";
+export * from "./coValues/extensions/imageDef.js";
+
+import "./implementation/devtoolsFormatters.js";