teamplay 0.4.0 → 0.5.0-alpha.1

package/dist/orm/Reaction.d.ts

@@ -0,0 +1,10 @@
+export function setDeletionDelay(delayInMs: any): void;
+export let DELETION_DELAY: number;
+export const reactionSubscriptions: ReactionSubscriptions;
+declare class ReactionSubscriptions {
+    initialized: Map<any, any>;
+    fr: import("../utils/MockFinalizationRegistry.js").FinalizationRegistryLike<unknown>;
+    init($value: any, fn: any): void;
+    destroy(rootId: any, id: any, reaction: any): void;
+}
+export {};

package/dist/orm/Reaction.js

@@ -0,0 +1,41 @@
+import { observe, unobserve } from '@nx-js/observer-util';
+import { SEGMENTS } from "./Signal.js";
+import { LOCAL } from './Value.js';
+import FinalizationRegistry from "../utils/MockFinalizationRegistry.js";
+import { scheduleReaction } from './batchScheduler.js';
+import { getRoot, ROOT_ID } from "./Root.js";
+import { delPrivateData, setPrivateData } from './privateData.js';
+// this is `let` to be able to directly change it if needed in tests or in the app
+export let DELETION_DELAY = 0;
+class ReactionSubscriptions {
+    constructor() {
+        this.initialized = new Map();
+        this.fr = new FinalizationRegistry(([rootId, id, reaction]) => this.destroy(rootId, id, reaction));
+    }
+    init($value, fn) {
+        const id = $value[SEGMENTS][1];
+        if (this.initialized.has(id))
+            return;
+        this.initialized.set(id, true);
+        const rootId = getRoot($value)?.[ROOT_ID] || $value?.[ROOT_ID];
+        const reactionScheduler = reaction => scheduleReaction(() => runReaction(rootId, id, reaction));
+        const reaction = observe(fn, { lazy: true, scheduler: reactionScheduler });
+        this.fr.register($value, [rootId, id, reaction]);
+        runReaction(rootId, id, reaction);
+    }
+    destroy(rootId, id, reaction) {
+        this.initialized.delete(id);
+        unobserve(reaction);
+        // don't delete data right away to prevent dependent reactions which are also going to be GC'ed
+        // from triggering unnecessarily
+        setTimeout(() => delPrivateData(rootId, [LOCAL, id]), DELETION_DELAY);
+    }
+}
+export const reactionSubscriptions = new ReactionSubscriptions();
+function runReaction(rootId, id, reaction) {
+    const newValue = reaction();
+    setPrivateData(rootId, [LOCAL, id], newValue);
+}
+export function setDeletionDelay(delayInMs) {
+    DELETION_DELAY = delayInMs;
+}

package/dist/orm/Root.d.ts

@@ -0,0 +1,22 @@
+import type { SignalBaseInstance } from './Signal.js';
+export declare const ROOT_FUNCTION: unique symbol;
+export declare const ROOT: unique symbol;
+export declare const ROOT_ID: unique symbol;
+export declare const GLOBAL_ROOT_ID = "__global__";
+export interface RootSignalOptions extends Record<string, unknown> {
+    rootFunction?: unknown;
+    fetchOnly?: boolean;
+    rootId?: string;
+}
+export type RootTransportIntent = 'fetch' | 'subscribe';
+export type RootSignalRuntime = SignalBaseInstance & {
+    [ROOT_FUNCTION]?: unknown;
+    [ROOT]?: RootSignalRuntime;
+    [ROOT_ID]?: string;
+};
+export declare function getRootSignal({ rootFunction, fetchOnly, rootId, ...options }?: RootSignalOptions): RootSignalRuntime;
+export declare function getRoot(signal: RootSignalRuntime | undefined): RootSignalRuntime | undefined;
+export declare function getRootFetchOnly(rootOrRootId: RootSignalRuntime | string | undefined): boolean;
+export declare function getRootTransportMode(rootOrRootId: RootSignalRuntime | string | undefined, intent?: RootTransportIntent): RootTransportIntent;
+export declare function registerRootFinalizer($root: RootSignalRuntime | undefined): void;
+export declare function unregisterRootFinalizer($root: RootSignalRuntime | undefined): void;

package/dist/orm/Root.js

@@ -0,0 +1,85 @@
+import getSignal from "./getSignal.js";
+import disposeRootContext from "./disposeRootContext.js";
+import { getRootContext, reviveRootContext } from "./rootContext.js";
+import { isGlobalRootId, normalizeRootId } from "./rootScope.js";
+import ExportedFinalizationRegistry from "../utils/MockFinalizationRegistry.js";
+export const ROOT_FUNCTION = Symbol('root function');
+// TODO: in future make a connection spawnable instead of a singleton
+// export const CONNECTION = Symbol('sharedb connection, used by sub() function')
+export const ROOT = Symbol('root signal');
+export const ROOT_ID = Symbol('root signal id. Used for caching');
+export const GLOBAL_ROOT_ID = '__global__';
+const getRuntimeSignal = getSignal;
+const RootFinalizationRegistry = ExportedFinalizationRegistry;
+const ROOT_FINALIZATION_REGISTRY = new RootFinalizationRegistry((rootId) => {
+    disposeRootContext(rootId).catch(err => {
+        console.error(err);
+    });
+});
+const REGISTERED_ROOT_SIGNALS = new WeakSet();
+// TODO: create a separate local root for private collections
+export function getRootSignal({ rootFunction, fetchOnly, 
+// connection,
+rootId = '_' + createRandomString(8), ...options } = {}) {
+    reviveRootContext(rootId);
+    getRootContext(rootId, true, { fetchOnly });
+    const $root = getRuntimeSignal(undefined, [], {
+        rootId,
+        ...options
+    });
+    $root[ROOT_FUNCTION] ??= rootFunction;
+    // $root[CONNECTION] ??= connection
+    $root[ROOT_ID] ??= rootId;
+    registerRootFinalizer($root);
+    return $root;
+}
+export function getRoot(signal) {
+    if (!signal)
+        return undefined;
+    if (signal[ROOT])
+        return signal[ROOT];
+    else if (signal[ROOT_ID])
+        return signal;
+    else
+        return undefined;
+}
+export function getRootFetchOnly(rootOrRootId) {
+    const $root = typeof rootOrRootId === 'string'
+        ? undefined
+        : (getRoot(rootOrRootId) || rootOrRootId);
+    const rootId = typeof rootOrRootId === 'string'
+        ? rootOrRootId
+        : $root?.[ROOT_ID];
+    const context = getRootContext(rootId, false);
+    return context?.getFetchOnly() ?? false;
+}
+export function getRootTransportMode(rootOrRootId, intent = 'subscribe') {
+    if (intent === 'fetch')
+        return 'fetch';
+    return getRootFetchOnly(rootOrRootId) ? 'fetch' : 'subscribe';
+}
+export function registerRootFinalizer($root) {
+    if (!$root?.[ROOT_ID])
+        return;
+    if (REGISTERED_ROOT_SIGNALS.has($root))
+        return;
+    const rootId = normalizeRootId($root[ROOT_ID]);
+    if (isGlobalRootId(rootId))
+        return;
+    ROOT_FINALIZATION_REGISTRY.register($root, rootId, $root);
+    REGISTERED_ROOT_SIGNALS.add($root);
+}
+export function unregisterRootFinalizer($root) {
+    if (!$root)
+        return;
+    ROOT_FINALIZATION_REGISTRY.unregister($root);
+    REGISTERED_ROOT_SIGNALS.delete($root);
+}
+function createRandomString(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}

package/dist/orm/Signal.d.ts

@@ -0,0 +1,12 @@
+import SignalCompat from './Compat/SignalCompat.js';
+import type { SignalConstructor } from './types/signal.js';
+export type { FromJsonSchema, InferZodSchema, JsonSchema, JsonSchemaObject, ZodLikeSchema } from './types/jsonSchema.js';
+export type { QueryParams } from './types/query.js';
+export type { SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalCollectionMethods, SignalMetadataMethods, SignalStringMutatorMethods, SignalValueMethods } from './types/baseMethods.js';
+export type { AppendPath, JoinPath, PathSegment, SignalPath, WildcardPathSegment, WildcardSignalPath } from './types/path.js';
+export type { AggregationSignal, AnySignal, ArraySignal, CollectionAggregationSignal, CollectionDocument, CollectionDocumentModel, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, DocumentSignal, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, PublicSignal, LocalSignalFactory, RegisteredAggregationInput, RuntimeSignalConstructor, RuntimeSignalInstance, QuerySignal, RootCollections, RootSignal, SignalBaseInstance, SignalChild, SignalChildren, SignalClass, SignalConstructor, SignalForKind, SignalKind, SignalInstance, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodSchemaSpec } from './types/signal.js';
+export type { CollectionsFromManifest, ModelEntry, ModelManifest, PathModelsFromManifest } from './types/modelManifest.js';
+export { Signal, SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS, regularBindings, extremelyLateBindings, isPublicCollectionSignal, isPublicDocumentSignal, isPublicCollection, isPrivateCollection } from './SignalBase.js';
+export { SignalCompat };
+declare const DefaultSignal: SignalConstructor;
+export default DefaultSignal;

package/dist/orm/Signal.js

@@ -0,0 +1,7 @@
+import { Signal } from "./SignalBase.js";
+import SignalCompat from './Compat/SignalCompat.js';
+import { isCompatEnv } from './compatEnv.js';
+export { Signal, SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS, regularBindings, extremelyLateBindings, isPublicCollectionSignal, isPublicDocumentSignal, isPublicCollection, isPrivateCollection } from "./SignalBase.js";
+export { SignalCompat };
+const DefaultSignal = (isCompatEnv() ? SignalCompat : Signal);
+export default DefaultSignal;

package/dist/orm/SignalBase.d.ts

@@ -0,0 +1,168 @@
+import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from './signalSymbols.js';
+export { SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS };
+export declare class Signal<TValue = unknown> extends Function {
+    /** Fields that are treated as document ids and mirror the document id segment. */
+    static ID_FIELDS: readonly ["_id"];
+    /** Method names that keep method binding priority over child signal dot access. */
+    static [GETTERS]: string[];
+    /** Association metadata registered for this model class. */
+    static associations: never[];
+    /** Path segments from the root signal to this signal. */
+    readonly [SEGMENTS]: Array<string | number>;
+    /**
+     * Add association metadata to this model class.
+     * @param association Association metadata object to register on the model class.
+     */
+    static addAssociation(association: object): void;
+    /**
+     * Create a signal for the given root-relative path segments.
+     * @param segments Root-relative path segments this signal points to.
+     */
+    constructor(segments: Array<string | number>);
+    /** Return the dot-separated path of this signal from the root data tree. */
+    path(): string;
+    /** Return the last segment of this signal path, or an empty string for the root signal. */
+    leaf(): string;
+    /**
+     * Return the parent signal `levels` above this signal.
+     * @param levels Number of parent levels to walk upward. Defaults to `1`.
+     */
+    parent(levels?: number): Signal;
+    /** Generate a new unique id suitable for a new document. */
+    id(): string;
+    /** Run multiple signal reads and writes in a single reactive batch. */
+    batch(): undefined;
+    /**
+     * Run multiple signal reads and writes in a single reactive batch.
+     * @param fn Function to execute inside the batch.
+     */
+    batch<TResult>(fn: () => TResult): TResult;
+    /**
+     * Internal read hook used by `.get()` and `.peek()`.
+     * @param method Storage read function to use for the current signal path.
+     */
+    [GET](method: (segments: Array<string | number>) => TValue): TValue;
+    /** Read the current value and track it for reactive rendering. */
+    get(): TValue;
+    /** Return document ids for a query or aggregation signal. */
+    getIds(): Array<string | number>;
+    /** Read the current value without tracking it for reactive rendering. */
+    peek(): TValue;
+    /** Return the document id represented by this document signal. */
+    getId(): string | number;
+    /** Return the public collection name this signal belongs to. */
+    getCollection(): string;
+    /** Return association metadata registered on this signal's model class. */
+    getAssociations(): readonly unknown[];
+    /** Iterate child document signals for query signals, or item signals for array signals. */
+    [Symbol.iterator](): IterableIterator<Signal>;
+    /** Internal helper used to run array-style methods on query and array signals. */
+    [ARRAY_METHOD](method: string, nonArrayReturnValue: unknown, ...args: unknown[]): unknown;
+    /**
+     * Run `Array.prototype.map()` over query document signals or array item signals.
+     * @param callback Function called for each child signal.
+     * @param thisArg Optional `this` value for the callback.
+     */
+    map<TResult>(callback: (value: Signal, index: number, array: Signal[]) => TResult, thisArg?: any): TResult[];
+    /**
+     * Run `Array.prototype.reduce()` over query document signals or array item signals.
+     * @param callback Function called for each child signal and accumulated value.
+     */
+    reduce(callback: (previousValue: Signal, currentValue: Signal, currentIndex: number, array: Signal[]) => Signal): Signal;
+    /**
+     * Run `Array.prototype.reduce()` over query document signals or array item signals.
+     * @param callback Function called for each child signal and accumulated value.
+     * @param initialValue Initial accumulator value.
+     */
+    reduce(callback: (previousValue: Signal, currentValue: Signal, currentIndex: number, array: Signal[]) => Signal, initialValue: Signal): Signal;
+    /**
+     * Run `Array.prototype.reduce()` over query document signals or array item signals.
+     * @param callback Function called for each child signal and accumulated value.
+     * @param initialValue Initial accumulator value.
+     */
+    reduce<TResult>(callback: (previousValue: TResult, currentValue: Signal, currentIndex: number, array: Signal[]) => TResult, initialValue: TResult): TResult;
+    /**
+     * Find the first query document signal or array item signal matching a predicate.
+     * @param predicate Function called for each child signal.
+     * @param thisArg Optional `this` value for the predicate.
+     */
+    find(predicate: (value: Signal, index: number, obj: Signal[]) => unknown, thisArg?: any): Signal | undefined;
+    /**
+     * Replace this signal's value. Database writes are async and sync through ShareDB.
+     * @param value New value to store at this signal path.
+     */
+    set(value: TValue): Promise<void>;
+    /**
+     * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
+     * @param value Object containing fields to set or delete.
+     */
+    assign(value: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never): Promise<void>;
+    /**
+     * Append one item to an array signal.
+     * @param value Item to append.
+     */
+    push(value: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item : unknown): Promise<unknown>;
+    /** Remove and return the last item from an array signal. */
+    pop(): Promise<NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | undefined : unknown>;
+    /**
+     * Insert one item at the beginning of an array signal.
+     * @param value Item to insert.
+     */
+    unshift(value: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item : unknown): Promise<unknown>;
+    /** Remove and return the first item from an array signal. */
+    shift(): Promise<NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | undefined : unknown>;
+    /**
+     * Insert one or more items into an array signal at the given index.
+     * @param index Array index where the new item or items should be inserted.
+     * @param values Item or items to insert.
+     */
+    insert(index: number, values: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | Item[] : unknown): Promise<unknown>;
+    /**
+     * Remove `howMany` items from an array signal starting at `index`.
+     * @param index Array index to start removing from.
+     * @param howMany Number of items to remove. Defaults to `1`.
+     */
+    remove(index: number, howMany?: number): Promise<unknown>;
+    /**
+     * Move `howMany` array items from one index to another.
+     * @param from Source array index.
+     * @param to Destination array index.
+     * @param howMany Number of items to move. Defaults to `1`.
+     */
+    move(from: number, to: number, howMany?: number): Promise<unknown>;
+    /**
+     * Insert text into a string signal at the given character index.
+     * @param index Character index where text should be inserted.
+     * @param text Text to insert.
+     */
+    stringInsert(index: number, text: string): Promise<unknown>;
+    /**
+     * Remove `howMany` characters from a string signal starting at `index`.
+     * @param index Character index to start removing from.
+     * @param howMany Number of characters to remove. Defaults to `1`.
+     */
+    stringRemove(index: number, howMany?: number): Promise<unknown>;
+    /**
+     * Add `value` to a number signal and return the new number. Defaults to `1`.
+     * @param value Amount to add to the current number. Defaults to `1`.
+     */
+    increment(value?: number): Promise<number>;
+    /**
+     * Add a document to a collection signal and return the new document id.
+     * @param value Document value to create. May include an explicit `id` field.
+     */
+    add(value: unknown): Promise<string>;
+    /** Delete this document or field. Whole collections and the root signal cannot be deleted. */
+    del(): Promise<void>;
+}
+export declare const regularBindings: {
+    apply(signal: any, thisArg: any, argumentsList: any): any;
+    get(signal: any, key: any, receiver: any): any;
+};
+export declare const extremelyLateBindings: {
+    apply(signal: any, thisArg: any, argumentsList: any): any;
+    get(signal: any, key: any, receiver: any): any;
+};
+export declare function isPublicCollectionSignal($signal: any): boolean;
+export declare function isPublicDocumentSignal($signal: any): boolean;
+export { isPrivateCollection, isPublicCollection } from './signalPathKind.js';