teamplay 0.5.0-alpha.30 → 0.5.0-alpha.32

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './orm/idFields.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './orm/idFields.js';

package/dist/config.js

@@ -0,0 +1 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./orm/idFields.js";

package/dist/connect/index.d.ts

@@ -1 +1 @@
-export default function connect(options: any): void;
+export default function connect(options?: {}): void;

package/dist/connect/index.js

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

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

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

package/dist/connect/offline/index.js

@@ -3,21 +3,25 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../../orm/connection.js";
+import { configureTeamplay } from "../../config.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() {
+    return async function connect(options = {}) {
+        const { idFields } = options || {};
+        if (idFields !== undefined)
+            configureTeamplay({ idFields });
         if (connection)
             return;
         const db = new ShareDbMingo();
-        const options = { db };
+        const backendOptions = { db };
         const { pubsub } = (await init(db, storage, createPubsub)) || {};
         if (pubsub)
-            options.pubsub = pubsub;
-        const backend = new ShareBackend(options);
+            backendOptions.pubsub = pubsub;
+        const backend = new ShareBackend(backendOptions);
         setConnection(backend.connect());
     };
 }

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

@@ -3,7 +3,7 @@ export namespace storage {
     export { setItem };
     export { iterate };
 }
-declare const _default: () => Promise<void>;
+declare const _default: (options?: {}) => Promise<void>;
 export default _default;
 declare function getItem(key: any): Promise<any>;
 declare function setItem(key: any, value: any): Promise<any>;

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

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

package/dist/connect/test.d.ts

@@ -1 +1 @@
-export default function connect(): void;
+export default function connect(options?: {}): void;

package/dist/connect/test.js

@@ -4,7 +4,11 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../orm/connection.js";
-export default function connect() {
+import { configureTeamplay } from "../config.js";
+export default function connect(options = {}) {
+    const { idFields } = options || {};
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     if (connection)
         return;
     const backend = new ShareBackend({ db: new ShareDbMingo() });

package/dist/index.d.ts

@@ -59,9 +59,13 @@ export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __s
 export { default as useSuspendMemo, useSuspendMemoByKey } from './react/useSuspendMemo.js';
 export declare const observer: ObserverFunction;
 export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { default as reaction } from './orm/reaction.js';
+export type { ReactionHandle, ReactionOptions } from './orm/reaction.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 { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './config.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './config.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';

package/dist/index.js

@@ -19,8 +19,10 @@ export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __s
 export { default as useSuspendMemo, useSuspendMemoByKey } from "./react/useSuspendMemo.js";
 export const observer = runtimeObserver;
 export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { default as reaction } from "./orm/reaction.js";
 export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./config.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';

package/dist/orm/Compat/SignalCompat.js

@@ -9,16 +9,15 @@ import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFiel
 import { incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, setPublicDocReplace as _setPublicDocReplace, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from '../dataTree.js';
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from './eventsCompat.js';
 import { waitForImperativeQueryReady } from './queryReadiness.js';
-import { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js';
+import { isModelEventsEnabled } from './modelEvents.js';
 import { setRefLink, removeRefLink, getAllRefLinks } from './refRegistry.js';
 import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js';
 import { runInBatch } from '../batchScheduler.js';
-import { runInSilentContext, runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js';
+import { runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js';
 import universal$ from "../../react/universal$.js";
 import { getRootContext } from "../rootContext.js";
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
 class SignalCompat extends Signal {
-    static ID_FIELDS = ['_id'];
     static [GETTERS] = DEFAULT_GETTERS;
     path() {
         if (arguments.length > 0)
@@ -68,12 +67,6 @@ class SignalCompat extends Signal {
             return this.extra.get();
         return undefined;
     }
-    silent(value) {
-        if (arguments.length > 1)
-            throw Error('Signal.silent() expects zero or one argument');
-        const enabled = value == null ? true : !!value;
-        return createSilentSignalWrapper(this, enabled);
-    }
     get() {
         if (arguments.length > 0)
             throw Error('Signal.get() does not accept any arguments');
@@ -299,15 +292,8 @@ class SignalCompat extends Signal {
     on(eventName, pattern, handler) {
         if (arguments.length < 2)
             throw Error('Signal.on() expects at least two arguments');
-        if (eventName === 'change' || eventName === 'all') {
-            if (typeof pattern === 'function') {
-                return onCustomEvent(eventName, pattern);
-            }
-            if (typeof handler !== 'function')
-                throw Error('Signal.on() expects a handler function');
-            const normalized = normalizePattern(pattern, 'Signal.on()');
-            const rootId = (getRoot(this) || this)?.[ROOT_ID];
-            return onModelEvent(rootId, eventName, normalized, handler);
+        if ((eventName === 'change' || eventName === 'all') && typeof pattern !== 'function') {
+            throw Error('Signal model events are not supported. Use reaction() for signal changes.');
         }
         if (typeof pattern !== 'function')
             throw Error('Signal.on() expects a handler function');
@@ -316,16 +302,8 @@ class SignalCompat extends Signal {
     once(eventName, pattern, handler) {
         if (arguments.length < 2)
             throw Error('Signal.once() expects at least two arguments');
-        const isModelEvent = eventName === 'change' || eventName === 'all';
-        if (isModelEvent && typeof pattern !== 'function') {
-            if (typeof handler !== 'function')
-                throw Error('Signal.once() expects a handler function');
-            const onceHandler = (...args) => {
-                this.removeListener(eventName, onceHandler);
-                handler(...args);
-            };
-            this.on(eventName, pattern, onceHandler);
-            return onceHandler;
+        if ((eventName === 'change' || eventName === 'all') && typeof pattern !== 'function') {
+            throw Error('Signal model events are not supported. Use reaction() for signal changes.');
         }
         if (typeof pattern !== 'function')
             throw Error('Signal.once() expects a handler function');
@@ -339,10 +317,6 @@ class SignalCompat extends Signal {
     removeListener(eventName, handler) {
         if (arguments.length !== 2)
             throw Error('Signal.removeListener() expects two arguments');
-        if (eventName === 'change' || eventName === 'all') {
-            const rootId = (getRoot(this) || this)?.[ROOT_ID];
-            return removeModelListener(rootId, eventName, handler);
-        }
         return removeCustomEventListener(eventName, handler);
     }
     ref(path, target, options) {
@@ -434,53 +408,6 @@ class SignalCompat extends Signal {
             delete this[REF_TARGET];
     }
 }
-const SILENT_WRAPPER = Symbol('compat silent wrapper');
-const SILENT_WRAPPER_TARGET = Symbol('compat silent wrapper target');
-const SILENT_WRAPPER_ENABLED = Symbol('compat silent wrapper enabled');
-function createSilentSignalWrapper($signal, enabled = true) {
-    if (!$signal || typeof $signal !== 'function')
-        return $signal;
-    if ($signal[SILENT_WRAPPER]) {
-        const target = $signal[SILENT_WRAPPER_TARGET] || $signal;
-        return createSilentSignalWrapper(target, enabled);
-    }
-    const handler = {
-        get(target, key, receiver) {
-            if (key === SILENT_WRAPPER)
-                return true;
-            if (key === SILENT_WRAPPER_TARGET)
-                return target;
-            if (key === SILENT_WRAPPER_ENABLED)
-                return enabled;
-            if (key === 'silent') {
-                return function silentWrapper(value) {
-                    if (arguments.length > 1)
-                        throw Error('Signal.silent() expects zero or one argument');
-                    const nextEnabled = value == null ? true : !!value;
-                    return createSilentSignalWrapper(target, nextEnabled);
-                };
-            }
-            const value = Reflect.get(target, key, receiver);
-            if (isSignalLike(value)) {
-                return createSilentSignalWrapper(value, enabled);
-            }
-            if (typeof value === 'function') {
-                return function wrappedMethod(...args) {
-                    if (!enabled)
-                        return Reflect.apply(value, target, args);
-                    return runInSilentContext(() => Reflect.apply(value, target, args));
-                };
-            }
-            return value;
-        },
-        apply(target, thisArg, args) {
-            if (!enabled)
-                return Reflect.apply(target, thisArg, args);
-            return runInSilentContext(() => Reflect.apply(target, thisArg, args));
-        }
-    };
-    return new Proxy($signal, handler);
-}
 function getRefStore($signal) {
     const $root = getRoot($signal) || $signal;
     const rootId = $root?.[ROOT_ID];

package/dist/orm/Compat/eventsCompat.js

@@ -1,5 +1,5 @@
 import { useLayoutEffect } from 'react';
-import { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener, __resetModelEventsForTests } from './modelEvents.js';
+import { __resetModelEventsForTests } from './modelEvents.js';
 const listeners = new Map();
 export function emit(eventName, ...args) {
     const subs = listeners.get(eventName);
@@ -27,34 +27,19 @@ export function removeListener(eventName, handler) {
 }
 export function useOn(eventName, patternOrHandler, handler, deps) {
     const isModelEvent = eventName === 'change' || eventName === 'all';
-    const isCustom = !isModelEvent || typeof patternOrHandler === 'function';
-    if (isCustom) {
+    if (!isModelEvent || typeof patternOrHandler === 'function') {
         if (typeof patternOrHandler !== 'function')
             throw Error('useOn() expects a handler function');
     }
     else {
-        if (typeof handler !== 'function')
-            throw Error('useOn() expects a handler function');
+        throw Error('Signal model events are not supported. Use reaction() for signal changes.');
     }
-    const normalizedPattern = isCustom ? null : normalizePatternMaybe(patternOrHandler);
     useLayoutEffect(() => {
-        if (isCustom) {
-            const listener = on(eventName, patternOrHandler);
-            return () => {
-                removeListener(eventName, listener);
-            };
-        }
-        if (normalizedPattern == null) {
-            handler(patternOrHandler);
-            return;
-        }
-        if (!isModelEventsEnabled())
-            return;
-        const listener = onModelEvent(undefined, eventName, normalizedPattern, handler);
+        const listener = on(eventName, patternOrHandler);
         return () => {
-            removeModelListener(undefined, eventName, listener);
+            removeListener(eventName, listener);
         };
-    }, [eventName, patternOrHandler, handler, deps, normalizedPattern, isCustom]);
+    }, [eventName, patternOrHandler, deps]);
 }
 export function useEmit() {
     return emit;
@@ -63,11 +48,3 @@ export function __resetEventsForTests() {
     listeners.clear();
     __resetModelEventsForTests();
 }
-function normalizePatternMaybe(pattern) {
-    try {
-        return normalizePattern(pattern);
-    }
-    catch {
-        return null;
-    }
-}

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

@@ -1,5 +1,4 @@
 export function isSilentContextActive(): boolean;
 export function isModelEventsSilentContextActive(): boolean;
-export function runInSilentContext(fn: any): any;
 export function runInModelEventsSilentContext(fn: any): any;
 export function __resetSilentContextForTests(): void;

package/dist/orm/Compat/silentContext.js

@@ -1,20 +1,10 @@
-let silentDepth = 0;
 let modelEventsSilentDepth = 0;
 export function isSilentContextActive() {
-    return silentDepth > 0;
+    return false;
 }
 export function isModelEventsSilentContextActive() {
     return modelEventsSilentDepth > 0;
 }
-export function runInSilentContext(fn) {
-    silentDepth += 1;
-    try {
-        return fn();
-    }
-    finally {
-        silentDepth -= 1;
-    }
-}
 export function runInModelEventsSilentContext(fn) {
     modelEventsSilentDepth += 1;
     try {
@@ -25,6 +15,5 @@ export function runInModelEventsSilentContext(fn) {
     }
 }
 export function __resetSilentContextForTests() {
-    silentDepth = 0;
     modelEventsSilentDepth = 0;
 }

package/dist/orm/SignalBase.d.ts

@@ -2,7 +2,7 @@ import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from './signalS
 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"];
+    static get ID_FIELDS(): import("./idFields.js").IdFields;
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS]: string[];
     /** Association metadata registered for this model class. */

package/dist/orm/SignalBase.js

@@ -21,10 +21,9 @@ import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
 import { ROOT_FUNCTION, ROOT_ID, closeRootSignal, getRoot } from "./Root.js";
-import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
+import { getDefaultIdFields, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
 import { isCompatEnv } from './compatEnv.js';
 import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js';
-import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js';
 import { runInBatch } from './batchScheduler.js';
 import { isPublicCollection } from "./signalPathKind.js";
 import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from "./signalSymbols.js";
@@ -91,7 +90,9 @@ const SIGNAL_VALUE_MUTATION_CONTEXT = {
 };
 export class Signal extends Function {
     /** Fields that are treated as document ids and mirror the document id segment. */
-    static ID_FIELDS = DEFAULT_ID_FIELDS;
+    static get ID_FIELDS() {
+        return getDefaultIdFields();
+    }
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS] = DEFAULT_GETTERS;
     /** Association metadata registered for this model class. */
@@ -578,8 +579,10 @@ export class Signal extends Function {
     async add(value) {
         if (arguments.length > 1)
             throw Error('Signal.add() expects a single argument');
-        const id = resolveAddDocId(value, uuid);
-        const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id]);
+        const collection = this[SEGMENTS][0];
+        const collectionIdFields = getIdFieldsForSegments([collection, '']);
+        const id = resolveAddDocId(value, collectionIdFields, uuid);
+        const idFields = getIdFieldsForSegments([collection, id]);
         await this[id].set(prepareAddPayload(value, idFields, id));
         return id;
     }
@@ -849,23 +852,6 @@ export const extremelyLateBindings = {
                     }
                 }
             }
-            if (key === 'start') {
-                const [relativePath, ...depsAndGetter] = argumentsList;
-                if (typeof relativePath !== 'string')
-                    throw Error('Signal.start() expects targetPath to be a string');
-                const absolutePath = joinScopePath($parent.path(), relativePath);
-                return compatStartOnRoot(getRoot($parent) || $parent, absolutePath, ...depsAndGetter);
-            }
-            if (key === 'stop') {
-                if (argumentsList.length > 1)
-                    throw Error('Signal.stop() expects zero or one argument');
-                const relativePath = argumentsList.length === 0 ? '' : argumentsList[0];
-                if (relativePath != null && typeof relativePath !== 'string') {
-                    throw Error('Signal.stop() expects targetPath to be a string');
-                }
-                const absolutePath = joinScopePath($parent.path(), relativePath || '');
-                return compatStopOnRoot(getRoot($parent) || $parent, absolutePath);
-            }
         }
         throw Error(ERRORS.noSignalKey($parent, key));
     },

package/dist/orm/batchScheduler.d.ts

@@ -1,7 +1,7 @@
-export function beginBatch(): void;
-export function endBatch(): void;
-export function inBatch(): boolean;
-export function runInBatch(fn: any): any;
-export function scheduleReaction(reactionFn: any): void;
-export function flushReactions(): void;
-export function __resetBatchSchedulerForTests(): void;
+export function beginBatch (): void
+export function endBatch (): void
+export function inBatch (): boolean
+export function runInBatch<TResult> (fn: () => TResult): TResult
+export function scheduleReaction (reactionFn: () => unknown): void
+export function flushReactions (): void
+export function __resetBatchSchedulerForTests (): void

package/dist/orm/idFields.d.ts

@@ -2,13 +2,22 @@ import type { PathSegment } from './types/path.js';
 export type IdField = string;
 export type IdFields = readonly IdField[];
 export type PlainObject = Record<string, unknown>;
+export interface TeamplayRuntimeConfig {
+    idFields?: IdFields | null;
+}
 export declare const DEFAULT_ID_FIELDS: readonly ["_id"];
+export declare const TEAMPLAY_RUNTIME_CONFIG_SYMBOL: unique symbol;
 export declare function getIdFieldsForSegments(segments: PathSegment[]): IdFields;
+export declare function configureTeamplay({ idFields }?: TeamplayRuntimeConfig): void;
+export declare function getTeamplayConfig(): Required<TeamplayRuntimeConfig>;
+export declare function getDefaultIdFields(): IdFields;
+export declare function setDefaultIdFields(idFields?: IdFields): void;
+export declare function __resetTeamplayConfigForTests(): void;
 export declare function isPlainObject(value: unknown): value is PlainObject;
 export declare function injectIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function normalizeIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function stripIdFields<TValue>(value: TValue, idFields: IdFields): TValue;
-export declare function resolveAddDocId(value: unknown, getDefaultId: () => string): PathSegment;
+export declare function resolveAddDocId(value: unknown, idFields: IdFields, getDefaultId: () => string): PathSegment;
 export declare function prepareAddPayload<TValue extends object>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function isPublicDocPath(segments: unknown): segments is [string, PathSegment];
 export declare function isIdFieldPath(segments: unknown, idFields: IdFields): segments is [string, PathSegment, string];

package/dist/orm/idFields.js

@@ -1,8 +1,42 @@
 import { findModel } from "./addModel.js";
 export const DEFAULT_ID_FIELDS = ['_id'];
+export const TEAMPLAY_RUNTIME_CONFIG_SYMBOL = Symbol.for('teamplay.runtimeConfig');
 export function getIdFieldsForSegments(segments) {
     const Model = findModel(segments);
-    return Model?.ID_FIELDS || DEFAULT_ID_FIELDS;
+    return Model?.ID_FIELDS || getDefaultIdFields();
+}
+export function configureTeamplay({ idFields } = {}) {
+    if (arguments.length === 0)
+        return;
+    const config = getGlobalRuntimeConfig(true);
+    const options = (arguments[0] || {});
+    if (Object.prototype.hasOwnProperty.call(options, 'idFields')) {
+        config.idFields = idFields == null
+            ? DEFAULT_ID_FIELDS
+            : normalizeIdFieldsConfig(idFields);
+    }
+}
+export function getTeamplayConfig() {
+    return {
+        idFields: getDefaultIdFields()
+    };
+}
+export function getDefaultIdFields() {
+    const config = getGlobalRuntimeConfig(false);
+    if (!config || !Object.prototype.hasOwnProperty.call(config, 'idFields')) {
+        return DEFAULT_ID_FIELDS;
+    }
+    if (config.idFields == null)
+        return DEFAULT_ID_FIELDS;
+    const normalized = normalizeIdFieldsConfig(config.idFields);
+    config.idFields = normalized;
+    return normalized;
+}
+export function setDefaultIdFields(idFields = DEFAULT_ID_FIELDS) {
+    getGlobalRuntimeConfig(true).idFields = normalizeIdFieldsConfig(idFields);
+}
+export function __resetTeamplayConfigForTests() {
+    delete getGlobalRuntimeConfigHolder()[TEAMPLAY_RUNTIME_CONFIG_SYMBOL];
 }
 export function isPlainObject(value) {
     if (!value || typeof value !== 'object')
@@ -52,26 +86,28 @@ export function stripIdFields(value, idFields) {
     }
     return next;
 }
-export function resolveAddDocId(value, getDefaultId) {
+export function resolveAddDocId(value, idFields, getDefaultId) {
     if (!value || typeof value !== 'object')
         throw Error('Signal.add() expects an object argument');
     const payload = value;
-    const hasId = payload.id != null;
-    const hasUnderscoreId = payload._id != null;
-    if (hasId && hasUnderscoreId && payload.id !== payload._id) {
-        throw Error(`Signal.add() got conflicting "id" (${JSON.stringify(payload.id)}) and "_id" (${JSON.stringify(payload._id)})`);
+    const entries = getAddIdEntries(payload, idFields);
+    const [firstEntry] = entries;
+    const conflictEntry = firstEntry && entries.find(entry => entry.value !== firstEntry.value);
+    if (firstEntry && conflictEntry) {
+        throw Error(`Signal.add() got conflicting "${firstEntry.field}" (${JSON.stringify(firstEntry.value)}) ` +
+            `and "${conflictEntry.field}" (${JSON.stringify(conflictEntry.value)}) id fields`);
     }
-    return payload.id ?? payload._id ?? getDefaultId();
+    return firstEntry?.value ?? getDefaultId();
 }
 export function prepareAddPayload(value, idFields, docId) {
     const payload = value;
-    if (idFields.includes('_id'))
-        payload._id = docId;
-    if (idFields.includes('id')) {
-        payload.id = docId;
-    }
-    else if (payload.id === docId) {
-        delete payload.id;
+    for (const field of idFields)
+        payload[field] = docId;
+    for (const field of LEGACY_ADD_ID_FIELDS) {
+        if (idFields.includes(field))
+            continue;
+        if (payload[field] === docId)
+            delete payload[field];
     }
     return value;
 }
@@ -93,3 +129,55 @@ export function isIdFieldPath(segments, idFields) {
     const last = segments[2];
     return typeof last === 'string' && idFields.includes(last);
 }
+function normalizeIdFieldsConfig(idFields) {
+    if (!Array.isArray(idFields)) {
+        throw Error('Teamplay idFields config must be an array of field names');
+    }
+    const normalized = [];
+    for (const field of idFields) {
+        if (typeof field !== 'string' || field.length === 0) {
+            throw Error('Teamplay idFields config must contain only non-empty string field names');
+        }
+        if (!normalized.includes(field))
+            normalized.push(field);
+    }
+    if (normalized.length === 0) {
+        throw Error('Teamplay idFields config must contain at least one field name');
+    }
+    return Object.freeze(normalized);
+}
+function getAddIdEntries(payload, idFields) {
+    const fields = uniqueFields([...LEGACY_ADD_ID_FIELDS, ...idFields]);
+    const entries = [];
+    for (const field of fields) {
+        const value = payload[field];
+        if (value == null)
+            continue;
+        entries.push({ field, value: value });
+    }
+    return entries;
+}
+function uniqueFields(fields) {
+    const result = [];
+    for (const field of fields) {
+        if (!result.includes(field))
+            result.push(field);
+    }
+    return result;
+}
+function getGlobalRuntimeConfig(create = true) {
+    const holder = getGlobalRuntimeConfigHolder();
+    let config = holder[TEAMPLAY_RUNTIME_CONFIG_SYMBOL];
+    if (config == null && create) {
+        config = {};
+        holder[TEAMPLAY_RUNTIME_CONFIG_SYMBOL] = config;
+    }
+    if (config != null && (!isPlainObject(config))) {
+        throw Error('Teamplay runtime config must be an object');
+    }
+    return config;
+}
+function getGlobalRuntimeConfigHolder() {
+    return globalThis;
+}
+const LEGACY_ADD_ID_FIELDS = ['id', '_id'];

package/dist/orm/index.d.ts

@@ -4,4 +4,6 @@ export type { RootSignal, TeamplayCollections, TeamplayFeature, TeamplayFeatures
 export declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from './initModels.js';
+export { default as reaction } from './reaction.js';
+export type { ReactionHandle, ReactionOptions } from './reaction.js';
 export { defineSchema } from '@teamplay/schema';

package/dist/orm/index.js

@@ -3,4 +3,5 @@ export { belongsTo, hasMany, hasOne } from "./associations.js";
 export const BaseModel = Signal;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from "./initModels.js";
+export { default as reaction } from "./reaction.js";
 export { defineSchema } from '@teamplay/schema';

package/dist/orm/reaction.d.ts

@@ -0,0 +1,11 @@
+export interface ReactionOptions {
+    lazy?: boolean;
+    debugger?: Function;
+    scheduler?: (run: () => unknown) => unknown;
+    onError?: (error: unknown) => unknown;
+}
+export interface ReactionHandle {
+    dispose: () => void;
+}
+export declare function reaction(fn: () => unknown, options?: ReactionOptions): ReactionHandle;
+export default reaction;

package/dist/orm/reaction.js

@@ -0,0 +1,47 @@
+import { observe, unobserve } from '@nx-js/observer-util';
+import { scheduleReaction } from './batchScheduler.js';
+export function reaction(fn, options = {}) {
+    if (typeof fn !== 'function')
+        throw Error('reaction() expects a function');
+    let disposed = false;
+    let pendingReactionFn;
+    function runReaction(runner) {
+        if (disposed)
+            return;
+        try {
+            return runner();
+        }
+        catch (error) {
+            if (typeof options.onError === 'function')
+                return options.onError(error);
+            throw error;
+        }
+    }
+    const scheduledRun = () => {
+        if (!pendingReactionFn)
+            return;
+        return runReaction(pendingReactionFn);
+    };
+    const runner = observe(fn, {
+        lazy: true,
+        debugger: options.debugger,
+        scheduler: (reactionFn) => {
+            pendingReactionFn = reactionFn;
+            if (typeof options.scheduler === 'function')
+                return options.scheduler(scheduledRun);
+            scheduleReaction(scheduledRun);
+        }
+    });
+    if (!options.lazy)
+        runReaction(runner);
+    return {
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            pendingReactionFn = undefined;
+            unobserve(runner);
+        }
+    };
+}
+export default reaction;

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 export function createBackend(options?: {}): any;
-export function initConnection(backend: any, { fetchOnly, publicOnly, ...options }?: {
+export function initConnection(backend: any, { fetchOnly, publicOnly, idFields, ...options }?: {
     fetchOnly?: boolean | undefined;
     publicOnly?: boolean | undefined;
 }): {

package/dist/server.js

@@ -2,6 +2,7 @@ import createChannel from '@teamplay/channel/server';
 import backendCreateBackend from '@teamplay/backend';
 import { getModels } from "./orm/initModels.js";
 import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from "./orm/connection.js";
+import { configureTeamplay } from "./config.js";
 export { default as ShareDB } from 'sharedb';
 export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite, getRedis, Redis, getRedisOptions, redisPrefix, generateRedisPrefix } from '@teamplay/backend';
 export function createBackend(options = {}) {
@@ -16,11 +17,13 @@ export function createBackend(options = {}) {
     return backendCreateBackend(nextOptions);
 }
 export default createBackend;
-export function initConnection(backend, { fetchOnly = true, publicOnly = true, ...options } = {}) {
+export function initConnection(backend, { fetchOnly = true, publicOnly = true, idFields, ...options } = {}) {
     if (!backend)
         throw Error('backend is required');
     if (connection)
         throw Error('Connection already exists');
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     setConnection(backend.connect());
     setDefaultFetchOnly(fetchOnly);
     setPublicOnly(publicOnly);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.30",
+  "version": "0.5.0-alpha.32",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,11 @@
       "teamplay-ts": "./src/connect/index.js",
       "default": "./dist/connect/index.js"
     },
+    "./config": {
+      "teamplay-ts": "./src/config.ts",
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
     "./server": {
       "teamplay-ts": "./src/server.js",
       "types": "./dist/server.d.ts",
@@ -133,6 +138,5 @@
       "<rootDir>/test_client/helpers"
     ]
   },
-  "license": "MIT",
-  "gitHead": "f568bc4a6af329926d4265c542eb2994b365bc28"
+  "license": "MIT"
 }

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

@@ -1,3 +0,0 @@
-export function compatStartOnRoot($root: any, targetPath: any, ...depsAndGetter: any[]): any;
-export function compatStopOnRoot($root: any, targetPath: any): void;
-export function joinScopePath(scopePath: any, relativePath: any): string;

package/dist/orm/Compat/startStopCompat.js

@@ -1,250 +0,0 @@
-import { observe, raw, unobserve } from '@nx-js/observer-util';
-import { getActiveDocOpContext } from '../Doc.js';
-import { getRoot } from "../Root.js";
-import { scheduleReaction } from '../batchScheduler.js';
-const START_REACTIONS = Symbol('compat start reactions');
-const SKIP_TICK = Symbol('compat start skip tick');
-export function compatStartOnRoot($root, targetPath, ...depsAndGetter) {
-    if (!isRootSignal($root))
-        throw Error('Signal.start() is only available on root signal');
-    if (typeof targetPath !== 'string')
-        throw Error('Signal.start() expects targetPath to be a string');
-    if (depsAndGetter.length < 1) {
-        throw Error('Signal.start() expects targetPath, dependencies, and a getter function');
-    }
-    const getter = depsAndGetter[depsAndGetter.length - 1];
-    if (typeof getter !== 'function') {
-        throw Error('Signal.start() expects the last argument to be a getter function');
-    }
-    const deps = depsAndGetter.slice(0, -1);
-    const targetSegments = parsePathSegments(targetPath);
-    const $target = resolveSignal($root, targetSegments);
-    const targetKey = $target.path();
-    const depPaths = deps
-        .map(dep => getStartDepPath(dep, $root))
-        .filter(Boolean);
-    const store = getStartStore($root);
-    const existing = store.get(targetKey);
-    if (existing)
-        existing.stop();
-    let lastSourceSnapshot = UNSET;
-    let lastTargetSnapshot = UNSET;
-    const reaction = observe(() => {
-        const resolvedDeps = [];
-        for (const dep of deps) {
-            const resolved = resolveStartDep(dep, $root);
-            if (resolved === SKIP_TICK)
-                return;
-            resolvedDeps.push(resolved);
-        }
-        let nextValue;
-        try {
-            nextValue = getter(...resolvedDeps);
-        }
-        catch (err) {
-            if (isThenable(err))
-                return;
-            throw err;
-        }
-        const sourceSnapshot = detachStartValue(nextValue);
-        if (lastSourceSnapshot !== UNSET && deepEqualStartValue(lastSourceSnapshot, sourceSnapshot)) {
-            return;
-        }
-        const currentTargetSnapshot = lastTargetSnapshot === UNSET
-            ? UNSET
-            : detachStartValue($target.peek());
-        if (currentTargetSnapshot !== UNSET && deepEqualStartValue(currentTargetSnapshot, sourceSnapshot)) {
-            lastSourceSnapshot = sourceSnapshot;
-            lastTargetSnapshot = sourceSnapshot;
-            return;
-        }
-        if (currentTargetSnapshot !== UNSET &&
-            !deepEqualStartValue(lastTargetSnapshot, currentTargetSnapshot) &&
-            isActiveLocalDocOpForDeps(depPaths)) {
-            lastSourceSnapshot = sourceSnapshot;
-            return;
-        }
-        lastSourceSnapshot = sourceSnapshot;
-        const detachedValue = detachStartValue(sourceSnapshot);
-        lastTargetSnapshot = detachStartValue(detachedValue);
-        // Keep the detached snapshot to avoid aliasing source and target.
-        // Old racer start() writes through diffDeep by default. In compat mode we must preserve
-        // that behavior, but also avoid reading the target reactively inside start(), otherwise
-        // start() subscribes to its own output and local child edits get immediately overwritten.
-        const maybePromise = $target.setDiffDeep(detachedValue);
-        if (maybePromise?.then) {
-            maybePromise
-                .then(() => { })
-                .catch(ignorePromiseRejection);
-        }
-    }, { scheduler: scheduleReaction });
-    store.set(targetKey, { stop: () => unobserve(reaction) });
-    return $target;
-}
-export function compatStopOnRoot($root, targetPath) {
-    if (!isRootSignal($root))
-        throw Error('Signal.stop() is only available on root signal');
-    if (typeof targetPath !== 'string')
-        throw Error('Signal.stop() expects targetPath to be a string');
-    const targetSegments = parsePathSegments(targetPath);
-    const $target = resolveSignal($root, targetSegments);
-    const targetKey = $target.path();
-    const store = getStartStore($root);
-    const existing = store.get(targetKey);
-    if (!existing)
-        return;
-    existing.stop();
-    store.delete(targetKey);
-}
-export function joinScopePath(scopePath, relativePath) {
-    if (typeof scopePath !== 'string')
-        scopePath = '';
-    const segments = [];
-    if (scopePath)
-        segments.push(...parsePathSegments(scopePath));
-    if (relativePath)
-        segments.push(...parsePathSegments(relativePath));
-    return segments.join('.');
-}
-function getStartStore($root) {
-    $root[START_REACTIONS] ??= new Map();
-    return $root[START_REACTIONS];
-}
-function resolveStartDep(dep, $root) {
-    try {
-        if (isSignalLike(dep))
-            return getStartDepValue(dep);
-        if (typeof dep === 'string')
-            return getStartDepValue(resolveSignal($root, parsePathSegments(dep)));
-        return dep;
-    }
-    catch (err) {
-        if (isThenable(err))
-            return SKIP_TICK;
-        throw err;
-    }
-}
-function getStartDepPath(dep, $root) {
-    if (isSignalLike(dep))
-        return dep.path();
-    if (typeof dep === 'string')
-        return resolveSignal($root, parsePathSegments(dep)).path();
-}
-function getStartDepValue($signal) {
-    return readReactiveSnapshot($signal.get());
-}
-function isActiveLocalDocOpForDeps(depPaths) {
-    const context = getActiveDocOpContext();
-    if (!context?.source)
-        return false;
-    const docPath = `${context.collection}.${context.docId}`;
-    return depPaths.some(depPath => depPath === docPath || depPath.startsWith(docPath + '.'));
-}
-function readReactiveSnapshot(value) {
-    if (!value || typeof value !== 'object')
-        return value;
-    if (value instanceof Date)
-        return new Date(value);
-    if (Array.isArray(value)) {
-        const array = [];
-        for (let i = 0; i < value.length; i++) {
-            array[i] = readReactiveSnapshot(value[i]);
-        }
-        return array;
-    }
-    const object = new value.constructor();
-    for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            object[key] = readReactiveSnapshot(value[key]);
-        }
-    }
-    return object;
-}
-function isSignalLike(value) {
-    return value && typeof value.path === 'function' && typeof value.get === 'function';
-}
-function parsePathSegments(path) {
-    return path.split('.').filter(Boolean);
-}
-function resolveSignal($base, segments) {
-    let $cursor = $base;
-    for (const segment of segments)
-        $cursor = $cursor[segment];
-    return $cursor;
-}
-function isRootSignal($signal) {
-    return getRoot($signal) === $signal;
-}
-function ignorePromiseRejection() { }
-function isThenable(value) {
-    return !!value && typeof value.then === 'function';
-}
-const UNSET = Symbol('compat start unset');
-function detachStartValue(value) {
-    const rawValue = raw(value);
-    if (!rawValue || typeof rawValue !== 'object')
-        return rawValue;
-    if (typeof globalThis.structuredClone === 'function') {
-        try {
-            return globalThis.structuredClone(rawValue);
-        }
-        catch { }
-    }
-    return racerDeepCopy(rawValue);
-}
-function racerDeepCopy(value) {
-    if (value instanceof Date)
-        return new Date(value);
-    if (typeof value === 'object') {
-        if (value === null)
-            return null;
-        if (Array.isArray(value)) {
-            const array = [];
-            for (let i = value.length; i--;) {
-                array[i] = racerDeepCopy(value[i]);
-            }
-            return array;
-        }
-        const object = new value.constructor();
-        for (const key in value) {
-            if (Object.prototype.hasOwnProperty.call(value, key)) {
-                object[key] = racerDeepCopy(value[key]);
-            }
-        }
-        return object;
-    }
-    return value;
-}
-function deepEqualStartValue(left, right) {
-    if (left === right)
-        return true;
-    if (Number.isNaN(left) && Number.isNaN(right))
-        return true;
-    if (left instanceof Date || right instanceof Date) {
-        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
-    }
-    if (!left || !right || typeof left !== 'object' || typeof right !== 'object')
-        return false;
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!Array.isArray(left) || !Array.isArray(right))
-            return false;
-        if (left.length !== right.length)
-            return false;
-        for (let i = 0; i < left.length; i++) {
-            if (!deepEqualStartValue(left[i], right[i]))
-                return false;
-        }
-        return true;
-    }
-    const leftKeys = Object.keys(left);
-    const rightKeys = Object.keys(right);
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    for (const key of leftKeys) {
-        if (!Object.prototype.hasOwnProperty.call(right, key))
-            return false;
-        if (!deepEqualStartValue(left[key], right[key]))
-            return false;
-    }
-    return true;
-}