@skipruntime/core 0.0.12 → 0.0.14

package/src/index.ts

@@ -13,8 +13,7 @@ import type {
   JsonObject,
 } from "../skiplang-json/index.js";
 import {
-  sk_freeze,
-  isSkManaged,
+  deepFreeze,
   SkManaged,
   checkOrCloneParam,
 } from "../skiplang-json/index.js";
@@ -54,13 +53,28 @@ import {
   type FromBinding,
 } from "./binding.js";
 
-export { sk_freeze, isSkManaged };
 export * from "./api.js";
 export * from "./errors.js";
 
 export type JSONMapper = Mapper<Json, Json, Json, Json>;
 export type JSONLazyCompute = LazyCompute<Json, Json>;
 
+function instantiateUserObject<Params extends DepSafe[], Result extends object>(
+  what: string,
+  ctor: new (...params: Params) => Result,
+  params: Params,
+): Result {
+  const checkedParams = params.map(checkOrCloneParam) as Params;
+  const obj = new ctor(...checkedParams);
+  Object.freeze(obj);
+  if (!obj.constructor.name) {
+    throw new SkipClassNameError(
+      `${what} classes must be defined at top-level.`,
+    );
+  }
+  return obj;
+}
+
 class Handles {
   private nextID: number = 1;
   private readonly objects: any[] = [];
@@ -138,15 +152,18 @@ class LazyCollectionImpl<K extends Json, V extends Json>
     ) as (V & DepSafe)[];
   }
 
-  getUnique(key: K): V & DepSafe {
-    const v = this.refs.skjson.importOptJSON(
-      this.refs.binding.SkipRuntime_LazyCollection__getUnique(
-        this.lazyCollection,
-        this.refs.skjson.exportJSON(key),
-      ),
-    ) as Nullable<V & DepSafe>;
-    if (v == null) throw new SkipNonUniqueValueError();
-    return v;
+  getUnique(key: K, _default?: { ifNone?: V; ifMany?: V }): V & DepSafe {
+    const values = this.getArray(key);
+    switch (values.length) {
+      case 1:
+        return values[0]!;
+      case 0:
+        if (_default?.ifNone !== undefined) return deepFreeze(_default.ifNone);
+        throw new SkipNonUniqueValueError();
+      default:
+        if (_default?.ifMany !== undefined) return deepFreeze(_default.ifMany);
+        throw new SkipNonUniqueValueError();
+    }
   }
 }
 
@@ -171,15 +188,18 @@ class EagerCollectionImpl<K extends Json, V extends Json>
     ) as (V & DepSafe)[];
   }
 
-  getUnique(key: K): V & DepSafe {
-    const v = this.refs.skjson.importOptJSON(
-      this.refs.binding.SkipRuntime_Collection__getUnique(
-        this.collection,
-        this.refs.skjson.exportJSON(key),
-      ),
-    ) as Nullable<V & DepSafe>;
-    if (v == null) throw new SkipNonUniqueValueError();
-    return v;
+  getUnique(key: K, _default?: { ifNone?: V; ifMany?: V }): V & DepSafe {
+    const values = this.getArray(key);
+    switch (values.length) {
+      case 1:
+        return values[0]!;
+      case 0:
+        if (_default?.ifNone !== undefined) return deepFreeze(_default.ifNone);
+        throw new SkipNonUniqueValueError();
+      default:
+        if (_default?.ifMany !== undefined) return deepFreeze(_default.ifMany);
+        throw new SkipNonUniqueValueError();
+    }
   }
 
   size = () => {
@@ -212,14 +232,7 @@ class EagerCollectionImpl<K extends Json, V extends Json>
     mapper: new (...params: Params) => Mapper<K, V, K2, V2>,
     ...params: Params
   ): EagerCollection<K2, V2> {
-    const mapperParams = params.map(checkOrCloneParam) as Params;
-    const mapperObj = new mapper(...mapperParams);
-    Object.freeze(mapperObj);
-    if (!mapperObj.constructor.name) {
-      throw new SkipClassNameError(
-        "Mapper classes must be defined at top-level.",
-      );
-    }
+    const mapperObj = instantiateUserObject("Mapper", mapper, params);
     const skmapper = this.refs.binding.SkipRuntime_createMapper(
       this.refs.handles.register(mapperObj),
     );
@@ -238,25 +251,12 @@ class EagerCollectionImpl<K extends Json, V extends Json>
       reducer: new (...params: ReducerParams) => Reducer<V2, Accum>,
       ...reducerParams: ReducerParams
     ) => {
-      const mParams = mapperParams.map(checkOrCloneParam) as MapperParams;
-      const rParams = reducerParams.map(checkOrCloneParam) as ReducerParams;
-
-      const mapperObj = new mapper(...mParams);
-      const reducerObj = new reducer(...rParams);
-
-      Object.freeze(mapperObj);
-      Object.freeze(reducerObj);
-
-      if (!mapperObj.constructor.name) {
-        throw new SkipClassNameError(
-          "Mapper classes must be defined at top-level.",
-        );
-      }
-      if (!reducerObj.constructor.name) {
-        throw new SkipClassNameError(
-          "Reducer classes must be defined at top-level.",
-        );
-      }
+      const mapperObj = instantiateUserObject("Mapper", mapper, mapperParams);
+      const reducerObj = instantiateUserObject(
+        "Reducer",
+        reducer,
+        reducerParams,
+      );
 
       const skmapper = this.refs.binding.SkipRuntime_createMapper(
         this.refs.handles.register(mapperObj),
@@ -290,14 +290,7 @@ class EagerCollectionImpl<K extends Json, V extends Json>
     reducer: new (...params: Params) => Reducer<V, Accum>,
     ...params: Params
   ): EagerCollection<K, Accum> {
-    const reducerParams = params.map(checkOrCloneParam) as Params;
-    const reducerObj = new reducer(...reducerParams);
-    Object.freeze(reducerObj);
-    if (!reducerObj.constructor.name) {
-      throw new SkipClassNameError(
-        "Reducer classes must be defined at top-level.",
-      );
-    }
+    const reducerObj = instantiateUserObject("Reducer", reducer, params);
     if (sknative in reducerObj && typeof reducerObj[sknative] == "string") {
       return this.derive<K, Accum>(
         this.refs.binding.SkipRuntime_Collection__nativeReduce(
@@ -320,8 +313,8 @@ class EagerCollectionImpl<K extends Json, V extends Json>
   }
 
   merge(...others: EagerCollection<K, V>[]): EagerCollection<K, V> {
-    const otherNames = others.map(
-      (other) => (other as EagerCollectionImpl<K, V>).collection,
+    const otherNames = others.map((other) =>
+      EagerCollectionImpl.getName(other),
     );
     const mapped = this.refs.binding.SkipRuntime_Collection__merge(
       this.collection,
@@ -335,6 +328,12 @@ class EagerCollectionImpl<K extends Json, V extends Json>
   ): EagerCollection<K2, V2> {
     return new EagerCollectionImpl<K2, V2>(collection, this.refs);
   }
+
+  static getName<K extends Json, V extends Json>(
+    coll: EagerCollection<K, V>,
+  ): string {
+    return (coll as EagerCollectionImpl<K, V>).collection;
+  }
 }
 
 class CollectionWriter<K extends Json, V extends Json> {
@@ -398,14 +397,7 @@ class ContextImpl extends SkManaged implements Context {
     compute: new (...params: Params) => LazyCompute<K, V>,
     ...params: Params
   ): LazyCollection<K, V> {
-    const mapperParams = params.map(checkOrCloneParam) as Params;
-    const computeObj = new compute(...mapperParams);
-    Object.freeze(computeObj);
-    if (!computeObj.constructor.name) {
-      throw new SkipClassNameError(
-        "LazyCompute classes must be defined at top-level.",
-      );
-    }
+    const computeObj = instantiateUserObject("LazyCompute", compute, params);
     const skcompute = this.refs.binding.SkipRuntime_createLazyCompute(
       this.refs.handles.register(computeObj),
     );
@@ -728,47 +720,74 @@ export class ServiceInstance {
 }
 
 class ValuesImpl<T> implements Values<T> {
+  /* Lazy Iterable/Sequence: values are generated from
+    the Iterator pointer and stored in materialized.
+    Once finished the pointer is nullified. */
+  private readonly materialized: (T & DepSafe)[] = [];
+
   constructor(
     private readonly skjson: JsonConverter,
     private readonly binding: FromBinding,
-    private readonly pointer: Pointer<Internal.NonEmptyIterator>,
+    private pointer: Pointer<Internal.NonEmptyIterator> | null,
   ) {
-    this.skjson = skjson;
-    this.binding = binding;
     this.pointer = pointer;
   }
 
-  next(): Nullable<T & DepSafe> {
-    return this.skjson.importOptJSON(
+  private next(): Nullable<T & DepSafe> {
+    if (this.pointer === null) {
+      return null;
+    }
+
+    const v = this.skjson.importOptJSON(
       this.binding.SkipRuntime_NonEmptyIterator__next(this.pointer),
     ) as Nullable<T & DepSafe>;
+
+    if (v === null) {
+      this.pointer = null;
+    } else {
+      this.materialized.push(v);
+    }
+    return v;
   }
 
-  getUnique(): T & DepSafe {
-    const value = this.skjson.importOptJSON(
-      this.binding.SkipRuntime_NonEmptyIterator__uniqueValue(this.pointer),
-    ) as Nullable<T & DepSafe>;
-    if (value == null) throw new SkipNonUniqueValueError();
-    return value;
+  getUnique(_default?: { ifMany?: T }): T & DepSafe {
+    if (this.materialized.length < 1) {
+      this.next();
+    }
+    const first = this.materialized[0];
+    if (
+      first === undefined /* i.e. this.materialized.length == 0 */ ||
+      this.materialized.length >= 2 ||
+      this.next() !== null
+    ) {
+      if (_default?.ifMany !== undefined) return deepFreeze(_default.ifMany);
+      throw new SkipNonUniqueValueError();
+    }
+    return first;
   }
 
-  toArray: () => (T & DepSafe)[] = () => {
-    return Array.from(this);
-  };
+  toArray(): (T & DepSafe)[] {
+    while (this.next() !== null);
+    return this.materialized;
+  }
 
   [Symbol.iterator](): Iterator<T & DepSafe> {
-    const cloned_iter = new ValuesImpl<T & DepSafe>(
-      this.skjson,
-      this.binding,
-      this.binding.SkipRuntime_NonEmptyIterator__clone(this.pointer),
-    );
-
-    return {
-      next() {
-        const value = cloned_iter.next();
-        return { value, done: value == null } as IteratorResult<T & DepSafe>;
-      },
+    let i = 0;
+    const next = (): IteratorResult<T & DepSafe> => {
+      // Invariant: this.materialized.length >= i
+      let value = this.materialized[i];
+      if (value === undefined /* i.e. this.materialized.length == i */) {
+        const next = this.next();
+        if (next === null) {
+          return { value: null, done: true };
+        }
+        value = next;
+      }
+      i++;
+      return { value };
     };
+
+    return { next };
   }
 }
 
@@ -820,11 +839,19 @@ export class ToBinding {
   ): Pointer<Internal.CJArray> {
     const skjson = this.getJsonConverter();
     const mapper = this.handles.get(skmapper);
-    const result = mapper.mapEntry(
-      skjson.importJSON(key) as Json,
-      new ValuesImpl<Json>(skjson, this.binding, values),
-    );
-    return skjson.exportJSON(Array.from(result) as [[Json, Json]]);
+    const context = new ContextImpl(this.refs());
+    try {
+      const result = mapper.mapEntry(
+        skjson.importJSON(key) as Json,
+        new ValuesImpl<Json>(skjson, this.binding, values),
+        context,
+      );
+      return skjson.exportJSON(Array.from(result));
+    } catch (e: unknown) {
+      console.error("Uncaught error during Skip runtime reactive update: ", e);
+      // Exception in async context will be dropped -- this `throw` is just to appease typechecker
+      throw e;
+    }
   }
 
   SkipRuntime_deleteMapper(mapper: Handle<JSONMapper>): void {
@@ -868,7 +895,7 @@ export class ToBinding {
       collections[key] = new EagerCollectionImpl<Json, Json>(name, refs);
     }
     const collection = resource.instantiate(collections, new ContextImpl(refs));
-    return (collection as EagerCollectionImpl<Json, Json>).collection;
+    return EagerCollectionImpl.getName(collection);
   }
 
   SkipRuntime_deleteResource(resource: Handle<Resource>): void {
@@ -912,9 +939,7 @@ export class ToBinding {
     const result = service.createGraph(collections, new ContextImpl(refs));
     const collectionsNames: { [name: string]: string } = {};
     for (const [name, collection] of Object.entries(result)) {
-      collectionsNames[name] = (
-        collection as EagerCollectionImpl<Json, Json>
-      ).collection;
+      collectionsNames[name] = EagerCollectionImpl.getName(collection);
     }
     return skjson.exportJSON(collectionsNames);
   }