teamplay 0.4.0 → 0.5.0-alpha.1

package/babel-loader.cjs

@@ -0,0 +1 @@
+module.exports = require('babel-plugin-teamplay/loader')

package/babel.cjs

@@ -0,0 +1 @@
+module.exports = require('babel-plugin-teamplay')

package/dist/connect/index.d.ts

@@ -0,0 +1 @@
+export default function connect(options: any): void;

package/dist/connect/index.js

@@ -0,0 +1,9 @@
+import Socket from '@teamplay/channel';
+import Connection from './sharedbConnection.cjs';
+import { connection, setConnection } from "../orm/connection.js";
+export default function connect(options) {
+    if (connection)
+        return;
+    const socket = new Socket(options);
+    setConnection(new Connection(socket));
+}

package/dist/connect/lib/sharedb-crosstab-pubsub.d.cts

@@ -0,0 +1,10 @@
+export = CrossTabPubSub;
+declare function CrossTabPubSub({ onMessage, ...options }?: {}): CrossTabPubSub;
+declare class CrossTabPubSub {
+    constructor({ onMessage, ...options }?: {});
+    _onMessage: any;
+    close(callback: any): void;
+    _subscribe(channel: any, callback: any): any;
+    _unsubscribe(channel: any, callback: any): any;
+    _publish(channels: any, data: any, callback: any): any;
+}

package/dist/connect/offline/index.d.ts

@@ -0,0 +1 @@
+export default function createConnectWithPersistence({ storage, createPubsub }?: {}): () => Promise<void>;

package/dist/connect/offline/index.js

@@ -0,0 +1,126 @@
+// Offline 'connect' implementation with persistence to local storage.
+// This creates a full sharedb server with mingo database in the browser or react-native app.
+import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
+import ShareBackend from 'sharedb';
+import { connection, setConnection } from "../../orm/connection.js";
+const STORAGE_NAMESPACE = 'teamplay-offline';
+const DOCS_PREFIX = `${STORAGE_NAMESPACE}:docs:`;
+const LAST_OP_PREFIX = `${STORAGE_NAMESPACE}:last-op:`;
+export default function createConnectWithPersistence({ storage, createPubsub } = {}) {
+    if (!storage)
+        throw new Error('[connect-offline] storage is required');
+    return async function connect() {
+        if (connection)
+            return;
+        const db = new ShareDbMingo();
+        const options = { db };
+        const { pubsub } = (await init(db, storage, createPubsub)) || {};
+        if (pubsub)
+            options.pubsub = pubsub;
+        const backend = new ShareBackend(options);
+        setConnection(backend.connect());
+    };
+}
+async function init(db, storage, createPubsub) {
+    await loadData(db, storage);
+    addPersistence(db, storage);
+    globalThis.db = db;
+    const pubsub = createPubsub
+        ? createPubsub((channel, data) => {
+            if (!(data?.c && data?.d))
+                return;
+            updateDocInDb(db, storage, data.c, data.d);
+        })
+        : null;
+    return { pubsub };
+}
+// do same thing as in loadData but for a single doc
+async function updateDocInDb(db, storage, collection, docId) {
+    try {
+        const snapshot = await storage.getItem(getDocsKey(collection, docId));
+        if (!snapshot)
+            return;
+        if (!db.docs[collection]) {
+            db.docs[collection] = {};
+            db.ops[collection] = {};
+        }
+        if (snapshot && typeof snapshot === 'object' && snapshot.v == null)
+            snapshot.v = 0;
+        db.docs[collection][docId] = snapshot;
+        if (!db.ops[collection])
+            db.ops[collection] = {};
+        const lastOp = await storage.getItem(getLastOpKey(collection, docId));
+        db.ops[collection][docId] = buildOpsArray(lastOp);
+    }
+    catch (err) {
+        console.error('Error updating doc from storage:', err);
+    }
+}
+async function loadData(db, storage) {
+    const docsToLoad = [];
+    await storage.iterate((value, key) => {
+        const parsedKey = parseStorageKey(key);
+        if (!parsedKey || parsedKey.type !== 'docs')
+            return;
+        const { collection, docId } = parsedKey;
+        if (!db.docs[collection]) {
+            db.docs[collection] = {};
+            db.ops[collection] = {};
+        }
+        // We don't support multiplayer in offline-only mode.
+        // Note: if you have multiple tabs open in browser then the last operation wins.
+        if (value && typeof value === 'object' && value.v == null)
+            value.v = 0;
+        db.docs[collection][docId] = value;
+        if (!db.ops[collection][docId])
+            db.ops[collection][docId] = [];
+        docsToLoad.push({ collection, docId });
+    });
+    for (const { collection, docId } of docsToLoad) {
+        const lastOp = await storage.getItem(getLastOpKey(collection, docId));
+        if (!db.ops[collection])
+            db.ops[collection] = {};
+        db.ops[collection][docId] = buildOpsArray(lastOp);
+    }
+    console.log('DB data was loaded from storage to shareDbMingo');
+}
+function addPersistence(db, storage) {
+    const originalCommit = db.commit;
+    db.commit = function (collection, docId, op, snapshot, options, callback) {
+        originalCommit.call(this, collection, docId, op, snapshot, options, async (err) => {
+            if (err)
+                return callback(err);
+            try {
+                await storage.setItem(getDocsKey(collection, docId), snapshot);
+                await storage.setItem(getLastOpKey(collection, docId), op);
+            }
+            catch (err) {
+                throw Error('Error saving to storage:\n', err.message);
+            }
+            callback(null, true);
+        });
+    };
+}
+function parseStorageKey(key) {
+    const [namespace, type, collection, ...docSegments] = key.split(':');
+    if (namespace !== STORAGE_NAMESPACE)
+        return null;
+    return { type, collection, docId: docSegments.join(':') };
+}
+function getDocsKey(collection, docId) {
+    return `${DOCS_PREFIX}${collection}:${docId}`;
+}
+function getLastOpKey(collection, docId) {
+    return `${LAST_OP_PREFIX}${collection}:${docId}`;
+}
+function buildOpsArray(lastOp) {
+    if (!lastOp)
+        return [];
+    const version = lastOp.v;
+    if (Number.isFinite(version) && version > 0) {
+        const ops = new Array(version + 1);
+        ops[version] = lastOp;
+        return ops;
+    }
+    return [lastOp];
+}

package/dist/connect/offline/react-native.d.ts

@@ -0,0 +1,10 @@
+export namespace storage {
+    export { getItem };
+    export { setItem };
+    export { iterate };
+}
+declare const _default: () => Promise<void>;
+export default _default;
+declare function getItem(key: any): Promise<any>;
+declare function setItem(key: any, value: any): Promise<any>;
+declare function iterate(iterator: any): Promise<void>;

package/dist/connect/offline/react-native.js

@@ -0,0 +1,25 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import createConnectWithPersistence from './index.js';
+async function getItem(key) {
+    const value = await AsyncStorage.getItem(key);
+    if (value == null)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function setItem(key, value) {
+    return AsyncStorage.setItem(key, JSON.stringify(value));
+}
+async function iterate(iterator) {
+    const keys = await AsyncStorage.getAllKeys();
+    for (const key of keys) {
+        const value = await getItem(key);
+        await iterator(value, key);
+    }
+}
+export const storage = { getItem, setItem, iterate };
+export default createConnectWithPersistence({ storage });

package/dist/connect/offline/web.d.ts

@@ -0,0 +1,9 @@
+export function createPubsub(onMessage: any): SharedbCrosstabPubsub;
+export namespace storage {
+    function getItem(key: any): Promise<any>;
+    function setItem(key: any, value: any): Promise<any>;
+    function iterate(iterator: any): Promise<any>;
+}
+declare const _default: () => Promise<void>;
+export default _default;
+import SharedbCrosstabPubsub from '../lib/sharedb-crosstab-pubsub.cjs';

package/dist/connect/offline/web.js

@@ -0,0 +1,12 @@
+import localforage from 'localforage';
+import SharedbCrosstabPubsub from '../lib/sharedb-crosstab-pubsub.cjs';
+import createConnectWithPersistence from './index.js';
+export const storage = {
+    getItem: key => localforage.getItem(key),
+    setItem: (key, value) => localforage.setItem(key, value),
+    iterate: iterator => localforage.iterate(iterator)
+};
+export function createPubsub(onMessage) {
+    return new SharedbCrosstabPubsub({ onMessage });
+}
+export default createConnectWithPersistence({ storage, createPubsub });

package/dist/connect/sharedbConnection.d.cts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/dist/connect/test.d.ts

@@ -0,0 +1 @@
+export default function connect(): void;

package/dist/connect/test.js

@@ -0,0 +1,12 @@
+// mock of client connection to sharedb to use inside tests.
+// This just creates a sharedb server with in-memory database
+// and creates a server connection to it.
+import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
+import ShareBackend from 'sharedb';
+import { connection, setConnection } from "../orm/connection.js";
+export default function connect() {
+    if (connection)
+        return;
+    const backend = new ShareBackend({ db: new ShareDbMingo() });
+    setConnection(backend.connect());
+}

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import type * as React from 'react';
+import { SEGMENTS } from './orm/Signal.js';
+import useApi from './react/useApi.js';
+import type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, LocalSignalFactory, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalChild, SignalBaseInstance, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalClass, SignalCollectionMethods, SignalConstructor, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './orm/Signal.js';
+export interface TeamplayCollections {
+}
+export interface TeamplayModels {
+}
+export interface TeamplaySignalFields {
+}
+export type Signal<TValue = unknown> = PublicSignal<TValue>;
+export type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSpec, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, CollectionsFromManifest, LocalSignalFactory, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalCollectionMethods, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec };
+export interface ObserverOptions {
+    forwardRef?: boolean;
+    cache?: boolean;
+    throttle?: number | boolean;
+    defer?: boolean | number;
+    suspenseProps?: React.ComponentProps<typeof React.Suspense>;
+}
+export type ObserverComponent<TProps extends object> = (props: TProps) => React.ReactNode;
+export type ObserverForwardRefComponent<TProps extends object, TRef> = (props: TProps, ref: React.ForwardedRef<TRef>) => React.ReactNode;
+export type ObserverForwardRefOptions = Omit<ObserverOptions, 'forwardRef'> & {
+    forwardRef: true;
+};
+export interface ObserverFunction {
+    <TProps extends object, TRef = unknown>(Component: ObserverForwardRefComponent<TProps, TRef>, options: ObserverForwardRefOptions): React.NamedExoticComponent<React.PropsWithoutRef<TProps> & React.RefAttributes<TRef>>;
+    <TProps extends object>(Component: ObserverComponent<TProps>, options?: ObserverOptions): React.NamedExoticComponent<TProps>;
+    __wrapObserverMeta: unknown;
+    __makeObserver: unknown;
+}
+export declare const Signal: SignalConstructor;
+export { SEGMENTS };
+export { __DEBUG_SIGNALS_CACHE__, rawSignal, getSignalClass } from './orm/getSignal.js';
+export { default as addModel } from './orm/addModel.js';
+export { defineModels, default as initModels, getModels, resetModelsForTests } from './orm/initModels.js';
+export { default as signal } from './orm/getSignal.js';
+export { GLOBAL_ROOT_ID } from './orm/Root.js';
+export declare const $: RootSignal;
+export declare const $root: RootSignal;
+export declare const model: RootSignal;
+export default $;
+export { default as sub } from './orm/sub.js';
+export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
+export { default as useSuspendMemo, useSuspendMemoByKey } from './react/useSuspendMemo.js';
+export declare const observer: ObserverFunction;
+export { useValue, useValue$, useModel, useLocal, useLocal$, useLocalDoc, useLocalDoc$, useSession, useSession$, usePage, usePage$, useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
+export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { useDidUpdate, useOnce, useSyncEffect } from './react/helpers.js';
+export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js';
+export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.js';
+export { getSubscriptionGcDelay, setSubscriptionGcDelay } from './orm/subscriptionGcDelay.js';
+export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.js';
+export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';
+export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation';
+export { accessControl } from '@teamplay/utils/accessControl';
+export type { AggregationCallback, AggregationContext, AggregationFunction, AggregationMeta, AggregationParams, AggregationQuery, ClientAggregationFunction, DefaultAggregationSession } from '@teamplay/utils/aggregation';
+export type { AccessControl, AccessControlRules, AccessCreateContext, AccessDecision, AccessDeleteContext, AccessOperation, AccessReadContext, AccessRule, AccessUpdateContext, AccessValidator, AccessValidatorObject, DefaultAccessSession } from '@teamplay/utils/accessControl';
+export declare function batch(): undefined;
+export declare function batch<TResult>(fn: () => TResult): TResult;
+export declare function batchModel(): undefined;
+export declare function batchModel<TResult>(fn: () => TResult): TResult;
+export declare function serverOnly<TValue>(value: TValue): TValue;
+export declare function clone<TValue>(value: TValue): TValue;
+export declare function initLocalCollection(name: string): any;
+export { useApi };
+export declare function getRootSignal<TCollections extends Record<string, any> = TeamplayCollections>(options?: Record<string, any>): RootSignal<TCollections>;

package/dist/index.js

@@ -0,0 +1,74 @@
+import RuntimeSignal, { SEGMENTS } from "./orm/Signal.js";
+import { getRootSignal as _getRootSignal, GLOBAL_ROOT_ID } from "./orm/Root.js";
+import universal$ from "./react/universal$.js";
+import useApi from "./react/useApi.js";
+import runtimeObserver from "./react/observer.js";
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const Signal = RuntimeSignal;
+export { SEGMENTS };
+export { __DEBUG_SIGNALS_CACHE__, rawSignal, getSignalClass } from "./orm/getSignal.js";
+export { default as addModel } from "./orm/addModel.js";
+export { defineModels, default as initModels, getModels, resetModelsForTests } from "./orm/initModels.js";
+export { default as signal } from "./orm/getSignal.js";
+export { GLOBAL_ROOT_ID } from "./orm/Root.js";
+const getRuntimeRootSignal = _getRootSignal;
+export const $ = getRuntimeRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ });
+export const $root = $;
+export const model = $;
+export default $;
+export { default as sub } from "./orm/sub.js";
+export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";
+export { default as useSuspendMemo, useSuspendMemoByKey } from "./react/useSuspendMemo.js";
+export const observer = runtimeObserver;
+export { useValue, useValue$, useModel, useLocal, useLocal$, useLocalDoc, useLocalDoc$, useSession, useSession$, usePage, usePage$, useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
+export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
+export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";
+export { getSubscriptionGcDelay, setSubscriptionGcDelay } from "./orm/subscriptionGcDelay.js";
+export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from "./react/helpers.js";
+export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';
+export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation';
+export { accessControl } from '@teamplay/utils/accessControl';
+export function batch(fn) {
+    return fn == null ? $.batch() : $.batch(fn);
+}
+export function batchModel(fn) {
+    return fn == null ? $.batch() : $.batch(fn);
+}
+export function serverOnly(value) {
+    return value;
+}
+export function clone(value) {
+    if (typeof globalThis.structuredClone === 'function') {
+        try {
+            return globalThis.structuredClone(value);
+        }
+        catch { }
+    }
+    if (value == null)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+export function initLocalCollection(name) {
+    if (typeof name !== 'string')
+        throw Error('initLocalCollection() expects a collection name');
+    if (!name)
+        return;
+    const segments = name.split('.').filter(Boolean);
+    if (!segments.length)
+        return;
+    let $cursor = $;
+    for (const segment of segments) {
+        $cursor = $cursor[segment];
+    }
+    if ($cursor.get() == null)
+        $cursor.set({});
+    return $cursor;
+}
+export { useApi };
+export function getRootSignal(options) {
+    return getRuntimeRootSignal({
+        rootFunction: universal$,
+        ...options
+    });
+}

package/dist/orm/$.d.ts

@@ -0,0 +1,9 @@
+import type Signal from './Signal.js'
+
+export const LOCAL: string
+
+export default function $ (
+  $root: Signal,
+  value?: unknown,
+  id?: string
+): Signal

package/dist/orm/$.js

@@ -0,0 +1,34 @@
+// this is just the $() function implementation.
+// The actual $ exported from this package is a Proxy targeting the dataTree root,
+// and this function is an implementation of the `apply` handler for that Proxy.
+import getSignal from "./getSignal.js";
+import Signal from "./Signal.js";
+import { LOCAL, valueSubscriptions } from './Value.js';
+import { reactionSubscriptions } from './Reaction.js';
+export { LOCAL } from './Value.js';
+let counter = 0;
+function newIncrementalId() {
+    const id = `_${counter}`;
+    counter += 1;
+    return id;
+}
+export default function $($root, value, id) {
+    if (!($root instanceof Signal))
+        throw Error('First argument of $() should be a Root Signal');
+    if (typeof value === 'function') {
+        return reaction$($root, value, id);
+    }
+    else {
+        return value$($root, value, id);
+    }
+}
+function value$($root, value, id = newIncrementalId()) {
+    const $value = getSignal($root, [LOCAL, id]);
+    valueSubscriptions.init($value, value);
+    return $value;
+}
+function reaction$($root, fn, id = newIncrementalId()) {
+    const $value = getSignal($root, [LOCAL, id]);
+    reactionSubscriptions.init($value, fn);
+    return $value;
+}

package/dist/orm/Aggregation.d.ts

@@ -0,0 +1,17 @@
+import type Signal from './Signal.js'
+import type {
+  QuerySubscriptions,
+  QuerySignalOptions
+} from './Query.js'
+
+export const IS_AGGREGATION: unique symbol
+export const AGGREGATIONS: '$aggregations'
+export const aggregationSubscriptions: QuerySubscriptions
+export function getAggregationSignal (collectionName: string, params: unknown, options?: QuerySignalOptions): Signal
+export function isAggregationSignal ($signal: unknown): boolean | undefined
+export function getAggregationDocId (
+  segments: readonly unknown[],
+  rootId?: string,
+  method?: (path: unknown[]) => unknown
+): string | number | undefined
+export function getAggregationCollectionName (segments: readonly unknown[]): string | undefined

package/dist/orm/Aggregation.js

@@ -0,0 +1,115 @@
+import { raw } from '@nx-js/observer-util';
+import { getRaw } from './dataTree.js';
+import getSignal from "./getSignal.js";
+import { QuerySubscriptions, hashQuery, Query, HASH, PARAMS, COLLECTION_NAME, parseQueryHash } from './Query.js';
+import Signal, { SEGMENTS } from "./Signal.js";
+import { getIdFieldsForSegments, isPlainObject } from "./idFields.js";
+import { delPrivateData, getPrivateData, setPrivateData } from './privateData.js';
+import { setSignalRuntimeDescriptor } from "./signalRuntimeDescriptor.js";
+export const IS_AGGREGATION = Symbol('is aggregation signal');
+export const AGGREGATIONS = '$aggregations';
+class Aggregation extends Query {
+    _initData() {
+        this._syncAllRootsData();
+        this.shareQuery.on('extra', extra => {
+            extra = raw(extra);
+            injectAggregationIds(extra, this.collectionName);
+            this._forEachRoot(rootId => {
+                setPrivateData(rootId, [AGGREGATIONS, this.hash], extra);
+            });
+        });
+    }
+    _syncRootData(rootId) {
+        if (!this.shareQuery)
+            return;
+        const extra = raw(this.shareQuery.extra);
+        injectAggregationIds(extra, this.collectionName);
+        setPrivateData(rootId, [AGGREGATIONS, this.hash], extra);
+    }
+    _removeRootData(rootId) {
+        delPrivateData(rootId, [AGGREGATIONS, this.hash]);
+    }
+    _removeData() {
+        this._forEachRoot(rootId => this._removeRootData(rootId));
+        this.rootIds.clear();
+    }
+}
+export const aggregationSubscriptions = new QuerySubscriptions(Aggregation);
+aggregationSubscriptions.runtimeKind = 'aggregation';
+function injectAggregationIds(extra, collectionName) {
+    if (!Array.isArray(extra))
+        return;
+    const idFields = getIdFieldsForSegments([collectionName, '']);
+    for (const doc of extra) {
+        if (!isPlainObject(doc))
+            continue;
+        const docId = doc._id ?? doc.id;
+        if (docId == null)
+            continue;
+        if (idFields.includes('_id') && doc._id !== docId)
+            doc._id = docId;
+        if (idFields.includes('id') && doc.id !== docId)
+            doc.id = docId;
+    }
+}
+export function getAggregationSignal(collectionName, params, options) {
+    params = JSON.parse(JSON.stringify(params));
+    const transportHash = hashQuery(collectionName, params);
+    const { root, signalOptions } = parseAggregationSignalOptions(options);
+    const $aggregation = getSignal(root, [AGGREGATIONS, transportHash], signalOptions);
+    $aggregation[IS_AGGREGATION] ??= true;
+    $aggregation[COLLECTION_NAME] ??= collectionName;
+    $aggregation[PARAMS] ??= params;
+    $aggregation[HASH] ??= transportHash;
+    setSignalRuntimeDescriptor($aggregation, {
+        kind: 'aggregation',
+        collectionName,
+        itemPattern: [collectionName, '*']
+    });
+    return $aggregation;
+}
+// example: ['$aggregations', '{"active":true}']
+export function isAggregationSignal($signal) {
+    if (!($signal instanceof Signal))
+        return;
+    const segments = $signal[SEGMENTS];
+    if (!(segments.length === 2))
+        return;
+    if (!(segments[0] === AGGREGATIONS))
+        return;
+    return true;
+}
+// example: ['$aggregations', '{"active":true}', 42]
+//          AND only if it also has either '_id' or 'id' field inside
+export function getAggregationDocId(segments, rootId, method) {
+    if (!(segments.length >= 3))
+        return;
+    if (!(segments[0] === AGGREGATIONS))
+        return;
+    if (!(typeof segments[2] === 'number'))
+        return;
+    if (typeof method !== 'function') {
+        method = path => rootId == null ? getRaw(path) : getPrivateData(rootId, path);
+    }
+    const docId = method([...segments.slice(0, 3), '_id']) || method([...segments.slice(0, 3), 'id']);
+    return docId;
+}
+export function getAggregationCollectionName(segments) {
+    if (!(segments.length >= 2))
+        return;
+    if (!(segments[0] === AGGREGATIONS))
+        return;
+    const hash = segments[1];
+    const { collectionName } = parseQueryHash(hash);
+    return collectionName;
+}
+function parseAggregationSignalOptions(options) {
+    if (!options || typeof options !== 'object') {
+        return {
+            root: undefined,
+            signalOptions: {}
+        };
+    }
+    const { root, ...signalOptions } = options;
+    return { root, signalOptions };
+}

package/dist/orm/Cache.d.ts

@@ -0,0 +1,9 @@
+export default class Cache<TValue extends object = object> {
+    private readonly cache;
+    private readonly fr;
+    _getKeys(): string[];
+    get(key: string): TValue | undefined;
+    set(key: string, value: TValue, inputs?: readonly object[]): void;
+    delete(key: string): void;
+    get size(): number;
+}

package/dist/orm/Cache.js

@@ -0,0 +1,32 @@
+import FinalizationRegistry from "../utils/MockFinalizationRegistry.js";
+import WeakRef, { destroyMockWeakRef } from "../utils/MockWeakRef.js";
+export default class Cache {
+    cache = new Map();
+    fr = new FinalizationRegistry(([key]) => {
+        // FinalizationRegistry can trigger long after the WeakRef was already
+        // collected and a fresh value was stored for the same key.
+        if (this.get(key))
+            return;
+        this.delete(key);
+    });
+    // For testing purposes.
+    _getKeys() {
+        return Array.from(this.cache.keys()).sort();
+    }
+    get(key) {
+        return this.cache.get(key)?.deref();
+    }
+    set(key, value, inputs = []) {
+        if (typeof key !== 'string')
+            throw Error('Cache key should be a string');
+        this.cache.set(key, new WeakRef(value));
+        this.fr.register(value, [key, ...inputs]);
+    }
+    delete(key) {
+        destroyMockWeakRef(this.cache.get(key));
+        this.cache.delete(key);
+    }
+    get size() {
+        return this.cache.size;
+    }
+}

package/dist/orm/Compat/SignalCompat.d.ts

@@ -0,0 +1,3 @@
+import { Signal } from '../SignalBase.js'
+
+export default class SignalCompat<TValue = unknown> extends Signal<TValue> {}