jazz-tools 0.7.0-alpha.9 → 0.7.3

package/src/implementation/refs.ts

@@ -4,35 +4,44 @@ import type {
     Account,
     CoValue,
     ID,
-    Me,
     RefEncoded,
+    UnCo,
     UnavailableError,
 } from "../internal.js";
-import { subscriptionsScopes } from "../internal.js";
+import {
+    instantiateRefEncoded,
+    isRefEncoded,
+    subscriptionsScopes,
+} from "../internal.js";
+
+const refCache = new WeakMap<RawCoValue, CoValue>();
 
-export class Ref<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 encoding: RefEncoded<V>
+        readonly controlledAccount: Account,
+        readonly schema: RefEncoded<V>,
     ) {
-        if (!("ref" in encoding)) {
-            throw new Error("Ref must be constructed with a ref encoding");
+        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 = this.encoding.ref(raw).fromRaw(raw);
-            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;
         }
@@ -59,16 +68,12 @@ export class Ref<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 Ref(
-                this.id,
-                this.controlledAccount,
-                this.encoding
-            ).value!;
+            return new Ref(this.id, this.controlledAccount, this.schema).value!;
         }
     }
 
@@ -83,24 +88,55 @@ export class Ref<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>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
-    controlledAccount: Account & Me,
-    refEncodingForKey: (key: Keys) => RefEncoded<CoValue>
+    controlledAccount: Account,
+    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>,
 ): { [K in Keys]: Ref<CoValue> } & {
     [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
     length: number;
@@ -110,14 +146,14 @@ export function makeRefs<Keys extends string | number>(
         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 Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            refEncodingForKey(key)
+                            refSchemaForKey(key),
                         );
                     }
                 };
@@ -131,11 +167,27 @@ export function makeRefs<Keys extends string | number>(
             return new Ref(
                 id as ID<CoValue>,
                 controlledAccount,
-                refEncodingForKey(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

@@ -0,0 +1,141 @@
+import type { JsonValue, RawCoValue } from "cojson";
+import {
+    type CoValue,
+    type CoValueClass,
+    isCoValueClass,
+    CoValueFromRaw,
+} from "../internal.js";
+import type { Schema as EffectSchema, TypeId } from "@effect/schema/Schema";
+
+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,
+    items: ItemsSym as ItemsSym,
+    members: MembersSym as MembersSym,
+};
+
+function ref<C extends CoValueClass>(
+    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+): co<InstanceType<C> | null>;
+function ref<C extends CoValueClass>(
+    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+    options: { optional: true },
+): co<InstanceType<C> | null | undefined>;
+function ref<
+    C extends CoValueClass,
+    Options extends { optional?: boolean } | undefined,
+>(
+    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+    options?: Options,
+): Options extends { optional: true }
+    ? co<InstanceType<C> | null | undefined>
+    : co<InstanceType<C> | null> {
+    return {
+        [SchemaInit]: {
+            ref: arg,
+            optional: options?.optional || false,
+        } satisfies Schema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+}
+
+export type JsonEncoded = "json";
+export type EncodedAs<V> = { encoded: Encoder<V> };
+export type RefEncoded<V extends CoValue> = {
+    ref: CoValueClass<V> | ((raw: RawCoValue) => CoValueClass<V>);
+    optional: boolean;
+};
+
+export function isRefEncoded<V extends CoValue>(
+    schema: Schema,
+): schema is RefEncoded<V> {
+    return (
+        typeof schema === "object" &&
+        "ref" in schema &&
+        "optional" in schema &&
+        typeof schema.ref === "function"
+    );
+}
+
+export function instantiateRefEncoded<V extends CoValue>(
+    schema: RefEncoded<V>,
+    raw: RawCoValue,
+): V {
+    return isCoValueClass<V>(schema.ref)
+        ? schema.ref.fromRaw(raw)
+        : (
+              schema.ref as (
+                  raw: RawCoValue,
+              ) => CoValueClass<V> & CoValueFromRaw<V>
+          )(raw).fromRaw(raw);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
+
+export type SchemaFor<Field> = NonNullable<Field> extends CoValue
+    ? RefEncoded<NonNullable<Field>>
+    : NonNullable<Field> extends JsonValue
+      ? JsonEncoded
+      : EncodedAs<NonNullable<Field>>;
+
+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;
+    };
+};
+
+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,
+};

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,
+    ID,
+    CoValueClass,
+    CoValueFromRaw,
+} 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: CoValueClass<Root> & CoValueFromRaw<Root>,
+        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,27 @@ 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,34 @@
 export {
-    /** @category Internal types */
-    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, val } from "./internal.js";
+export { Encoders, co } 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";
+
+export {
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+} 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";
@@ -9,7 +10,10 @@ export * from "./coValues/group.js";
 
 export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
-export * from "./implementation/encoding.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";