teamplay 0.5.0-alpha.3 → 0.5.0-alpha.31

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

@@ -1,15 +1,31 @@
 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, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, 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';
+import type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest, PrivateSignalFromSpec, PublicSignal, LocalSignalFactory, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootPrivateCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, 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 TeamplayPrivateCollections {
+}
 export interface TeamplayModels {
 }
 export interface TeamplaySignalFields {
 }
+export interface TeamplayPluginCollections {
+}
+export interface TeamplayPluginPrivateCollections {
+}
+export interface TeamplayPluginModels {
+}
+export interface TeamplayPluginSignalFields {
+}
+export interface TeamplayPluginOptions {
+}
+export interface TeamplayFeatures {
+}
+export type TeamplayPluginOption<TName extends string> = TName extends keyof TeamplayPluginOptions ? TeamplayPluginOptions[TName] : {};
+export type TeamplayFeature<TName extends string> = TName extends keyof TeamplayFeatures ? TeamplayFeatures[TName] : unknown;
 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, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalCollectionMethods, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec };
+export type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSpec, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, CollectionsFromManifest, PrivateCollectionsFromManifest, LocalSignalFactory, PathModelsFromManifest, PrivateSignalFromSpec, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, RootPrivateCollections, 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;
@@ -36,25 +52,25 @@ export { defineModels, default as initModels, getModels, resetModelsForTests } f
 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 sub, unsub } from './orm/sub.js';
+export type { SubMode, SubOptions } from './orm/sub.js';
+export { default as useSub, useAsyncSub, useBatchSub, 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 { 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';
 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 type { AccessControl, AccessControlOptions, 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;
@@ -63,4 +79,5 @@ 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>;
+export declare function getRootSignal(options?: Record<string, any>): RootSignal;
+export declare function getRootSignal<TCollections extends Record<string, any>>(options?: Record<string, any>): RootSignal<TCollections>;

package/dist/index.js

@@ -13,17 +13,15 @@ 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 sub, unsub } from "./orm/sub.js";
+export { default as useSub, useAsyncSub, useBatchSub, 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 { 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/Aggregation.d.ts

@@ -3,15 +3,17 @@ import type {
   QuerySubscriptions,
   QuerySignalOptions
 } from './Query.js'
+import type { PathSegment } from './types/path.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 getAggregationRowId (row: unknown, collectionName?: string): string | undefined
 export function getAggregationDocId (
-  segments: readonly unknown[],
+  segments: readonly PathSegment[],
   rootId?: string,
-  method?: (path: unknown[]) => unknown
-): string | number | undefined
-export function getAggregationCollectionName (segments: readonly unknown[]): string | undefined
+  method?: (path: PathSegment[]) => unknown
+): string | undefined
+export function getAggregationCollectionName (segments: readonly PathSegment[]): string | undefined

package/dist/orm/Aggregation.js

@@ -1,13 +1,14 @@
 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 { QuerySubscriptions, hashQuery, Query, cloneQueryParams, 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';
+const DEFAULT_AGGREGATION_ID_FIELDS = ['_id', 'id'];
 class Aggregation extends Query {
     _initData() {
         this._syncAllRootsData();
@@ -39,21 +40,31 @@ aggregationSubscriptions.runtimeKind = 'aggregation';
 function injectAggregationIds(extra, collectionName) {
     if (!Array.isArray(extra))
         return;
-    const idFields = getIdFieldsForSegments([collectionName, '']);
+    const idFields = getCollectionIdFields(collectionName);
     for (const doc of extra) {
         if (!isPlainObject(doc))
             continue;
-        const docId = doc._id ?? doc.id;
+        const docId = getAggregationRowId(doc, collectionName);
         if (docId == null)
             continue;
-        if (idFields.includes('_id') && doc._id !== docId)
-            doc._id = docId;
-        if (idFields.includes('id') && doc.id !== docId)
-            doc.id = docId;
+        for (const field of idFields) {
+            if (doc[field] !== docId)
+                doc[field] = docId;
+        }
+    }
+}
+export function getAggregationRowId(row, collectionName) {
+    if (!isPlainObject(row))
+        return;
+    const idFields = getAggregationIdFields(collectionName);
+    for (const field of idFields) {
+        const value = row[field];
+        if (typeof value === 'string')
+            return value;
     }
 }
 export function getAggregationSignal(collectionName, params, options) {
-    params = JSON.parse(JSON.stringify(params));
+    params = cloneQueryParams(collectionName, params);
     const transportHash = hashQuery(collectionName, params);
     const { root, signalOptions } = parseAggregationSignalOptions(options);
     const $aggregation = getSignal(root, [AGGREGATIONS, transportHash], signalOptions);
@@ -80,7 +91,7 @@ export function isAggregationSignal($signal) {
     return true;
 }
 // example: ['$aggregations', '{"active":true}', 42]
-//          AND only if it also has either '_id' or 'id' field inside
+//          AND only if the aggregation row carries a source document id field
 export function getAggregationDocId(segments, rootId, method) {
     if (!(segments.length >= 3))
         return;
@@ -88,11 +99,16 @@ export function getAggregationDocId(segments, rootId, method) {
         return;
     if (!(typeof segments[2] === 'number'))
         return;
+    const collectionName = getAggregationCollectionName(segments);
+    const idFields = getAggregationIdFields(collectionName);
     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;
+    for (const field of idFields) {
+        const id = method([...segments.slice(0, 3), field]);
+        if (typeof id === 'string')
+            return id;
+    }
 }
 export function getAggregationCollectionName(segments) {
     if (!(segments.length >= 2))
@@ -113,3 +129,15 @@ function parseAggregationSignalOptions(options) {
     const { root, ...signalOptions } = options;
     return { root, signalOptions };
 }
+function getAggregationIdFields(collectionName) {
+    const idFields = getCollectionIdFields(collectionName);
+    return uniq(idFields.concat(DEFAULT_AGGREGATION_ID_FIELDS));
+}
+function getCollectionIdFields(collectionName) {
+    return collectionName
+        ? getIdFieldsForSegments([collectionName, ''])
+        : [];
+}
+function uniq(values) {
+    return Array.from(new Set(values));
+}