teamplay 0.5.0-alpha.3 → 0.5.0-alpha.5

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;
@@ -54,7 +70,7 @@ export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, p
 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/orm/Aggregation.d.ts

@@ -13,5 +13,5 @@ export function getAggregationDocId (
   segments: readonly unknown[],
   rootId?: string,
   method?: (path: unknown[]) => unknown
-): string | number | undefined
+): string | undefined
 export function getAggregationCollectionName (segments: readonly unknown[]): string | undefined

package/dist/orm/Aggregation.js

@@ -91,8 +91,12 @@ export function getAggregationDocId(segments, rootId, method) {
     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;
+    const underscoreId = method([...segments.slice(0, 3), '_id']);
+    if (typeof underscoreId === 'string')
+        return underscoreId;
+    const id = method([...segments.slice(0, 3), 'id']);
+    if (typeof id === 'string')
+        return id;
 }
 export function getAggregationCollectionName(segments) {
     if (!(segments.length >= 2))

package/dist/orm/Signal.d.ts

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

package/dist/orm/SignalBase.d.ts

@@ -51,11 +51,11 @@ export declare class Signal<TValue = unknown> extends Function {
     /** Read the current value and track it for reactive rendering. */
     get(): TValue;
     /** Return document ids for a query or aggregation signal. */
-    getIds(): Array<string | number>;
+    getIds(): string[];
     /** Read the current value without tracking it for reactive rendering. */
     peek(): TValue;
     /** Return the document id represented by this document signal. */
-    getId(): string | number;
+    getId(): string | undefined;
     /** Return the public collection name this signal belongs to. */
     getCollection(): string;
     /** Return association metadata registered on this signal's model class. */

package/dist/orm/SignalBase.js

@@ -205,7 +205,10 @@ export class Signal extends Function {
     /** Return the document id represented by this document signal. */
     getId() {
         const $root = getRoot(this) || this;
-        return getSignalId(this, $root?.[ROOT_ID]);
+        const rootId = $root?.[ROOT_ID];
+        return getSignalId(this, rootId, segments => (isPrivateSignalSegments(segments)
+            ? getPrivateData(rootId, segments)
+            : _get(getSignalStorageSegments({ [SEGMENTS]: segments }))));
     }
     /** Return the public collection name this signal belongs to. */
     getCollection() {

package/dist/orm/addModel.d.ts

@@ -1,6 +1,13 @@
 import type { SignalClass } from './Signal.js';
-import type { TeamplayModels } from '../index.js';
+import type { TeamplayModels, TeamplayPluginModels } from '../index.js';
 import type { PathSegment } from './types/path.js';
 export declare const MODELS: Record<string, SignalClass<any>>;
-export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof TeamplayModels ? TeamplayModels[TPattern] : SignalClass<any>): void;
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[TPattern] : SignalClass<any>): void;
 export declare function findModel(segments: PathSegment[]): SignalClass<any> | undefined;
+export {};

package/dist/orm/index.d.ts

@@ -1,6 +1,6 @@
 export { belongsTo, hasMany, hasOne } from './associations.js';
-export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, ComputedQueryParamsInput, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
-export type { RootSignal, TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../index.js';
+export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, ComputedQueryParamsInput, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest, PrivateSignalFromSpec, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, RootPrivateCollections, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
+export type { RootSignal, TeamplayCollections, TeamplayFeature, TeamplayFeatures, TeamplayModels, TeamplayPluginCollections, TeamplayPluginPrivateCollections, TeamplayPluginModels, TeamplayPluginOption, TeamplayPluginOptions, TeamplayPluginSignalFields, TeamplayPrivateCollections, TeamplaySignalFields } from '../index.js';
 export declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from './initModels.js';

package/dist/orm/signalMetadata.d.ts

@@ -12,6 +12,6 @@ export declare function getSignalPath($signal: Pick<SignalMetadataOwner, typeof
 export declare function getSignalLeaf($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>): string;
 export declare function getSignalParentSegments($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, levels: unknown, argumentCount: number): PathSegment[];
 export declare function normalizeParentLevels(levels: unknown, argumentCount: number): number;
-export declare function getSignalId($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, rootId?: string): string | number | undefined;
+export declare function getSignalId($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, rootId?: string, readPath?: (segments: PathSegment[]) => unknown): string | undefined;
 export declare function getSignalCollection($signal: SignalMetadataOwner): PathSegment | undefined;
 export declare function getSignalAssociations($rawSignal: Pick<SignalMetadataOwner, 'constructor'>): readonly unknown[];

package/dist/orm/signalMetadata.js

@@ -1,4 +1,5 @@
 import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
+import { isPrivateCollectionSegments } from "./rootScope.js";
 import { SEGMENTS } from "./signalSymbols.js";
 export function getSignalPath($signal) {
     return $signal[SEGMENTS].join('.');
@@ -27,16 +28,23 @@ export function normalizeParentLevels(levels, argumentCount) {
         throw Error('Signal.parent() expects a positive integer');
     return levels;
 }
-export function getSignalId($signal, rootId) {
+export function getSignalId($signal, rootId, readPath) {
     const segments = $signal[SEGMENTS];
     if (segments.length === 0)
         throw Error('Can\'t get the id of the root signal');
     if (segments.length === 1)
         throw Error('Can\'t get the id of a collection');
+    if (isDirectPublicDocumentSegments(segments))
+        return getLeafId(segments);
+    if (readPath) {
+        const valueId = getValueIdFromPaths(segments, readPath);
+        if (valueId.found)
+            return valueId.id;
+    }
     if (segments[0] === AGGREGATIONS && segments.length === 3) {
         return getAggregationDocId(segments, rootId);
     }
-    return segments[segments.length - 1];
+    return getLeafId(segments);
 }
 export function getSignalCollection($signal) {
     const segments = $signal[SEGMENTS];
@@ -54,3 +62,21 @@ export function getSignalCollection($signal) {
 export function getSignalAssociations($rawSignal) {
     return $rawSignal.constructor.associations || [];
 }
+function getValueIdFromPaths(segments, readPath) {
+    const underscoreId = readPath([...segments, '_id']);
+    if (typeof underscoreId === 'string')
+        return { found: true, id: underscoreId };
+    const id = readPath([...segments, 'id']);
+    if (typeof id === 'string')
+        return { found: true, id };
+    if (underscoreId !== undefined || id !== undefined)
+        return { found: true };
+    return { found: false };
+}
+function isDirectPublicDocumentSegments(segments) {
+    return segments.length === 2 && !isPrivateCollectionSegments(segments);
+}
+function getLeafId(segments) {
+    const leaf = segments[segments.length - 1];
+    return typeof leaf === 'string' ? leaf : undefined;
+}

package/dist/orm/signalReads.d.ts

@@ -21,6 +21,6 @@ export interface SignalReadContext<TSignal extends SignalReadOwner> {
 }
 export declare function readSignalValue<TSignal extends SignalReadOwner, TValue>($signal: TSignal, context: SignalReadContext<TSignal>, method: SignalReadMethod<TValue>, rawMethod: SignalReadMethod): TValue;
 export declare function getSignalValue<TSignal extends SignalReadOwner, TValue>($signal: TSignal, context: SignalReadContext<TSignal>, method: SignalReadMethod<TValue>, rawMethod: SignalReadMethod): TValue;
-export declare function getSignalIds<TSignal extends SignalReadOwner>($signal: TSignal, context: SignalReadContext<TSignal>): Array<string | number>;
+export declare function getSignalIds<TSignal extends SignalReadOwner>($signal: TSignal, context: SignalReadContext<TSignal>): string[];
 export declare function isQueryIdsValueSignal<TSignal extends SignalReadOwner>($signal: TSignal): boolean;
 export declare function isAggregationValueSignal<TSignal extends SignalReadOwner>($signal: TSignal): boolean;

package/dist/orm/signalReads.js

@@ -23,7 +23,7 @@ export function getSignalValue($signal, context, method, rawMethod) {
             context.warn('Signal.get() on Query didn\'t find ids', $signal[SEGMENTS]);
             return [];
         }
-        return ids;
+        return ids.filter(isString);
     }
     return readSignalValue($signal, context, method, rawMethod);
 }
@@ -35,13 +35,13 @@ export function getSignalIds($signal, context) {
             context.warn('Signal.getIds() on Query didn\'t find ids', [QUERIES, getQueryHashSegment($signal), 'ids']);
             return [];
         }
-        return ids;
+        return ids.filter(isString);
     }
     if ($signal[IS_AGGREGATION]) {
         const docs = context.readPrivateData(rootId, $signal[SEGMENTS], false);
         if (!Array.isArray(docs))
             return [];
-        return docs.map(getAggregationRowId);
+        return docs.map(getAggregationRowId).filter(isString);
     }
     context.error('Signal.getIds() can only be used on query signals or aggregation signals. ' +
         'Received a regular signal: ' + JSON.stringify($signal[SEGMENTS]));
@@ -57,7 +57,13 @@ export function isAggregationValueSignal($signal) {
 }
 function getAggregationRowId(doc) {
     const row = doc;
-    return row._id || row.id;
+    if (typeof row?._id === 'string')
+        return row._id;
+    if (typeof row?.id === 'string')
+        return row.id;
+}
+function isString(value) {
+    return typeof value === 'string';
 }
 function getQueryHashSegment($signal) {
     return $signal[HASH];

package/dist/orm/types/baseMethods.d.ts

@@ -6,7 +6,7 @@ export interface SignalMetadataMethods {
     readonly [Symbol.toStringTag]: string;
     parent: (levels?: number) => unknown;
     id: () => string;
-    getId: () => string | number;
+    getId: () => string | undefined;
     getCollection: () => string;
     getAssociations: () => readonly unknown[];
 }

package/dist/orm/types/modelManifest.d.ts

@@ -1,5 +1,6 @@
 import type { Signal as BaseSignal } from '../SignalBase.js';
 import type { CollectionSpec, JsonSchemaSpec, SignalClass } from './signal.js';
+import type { FromJsonSchema } from './jsonSchema.js';
 export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>, TSchema = unknown> {
     default?: TModel;
     schema?: TSchema;
@@ -8,10 +9,14 @@ export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>,
 }
 export type ModelManifest = Record<string, ModelEntry>;
 type StringKey<TValue> = Extract<keyof TValue, string>;
-type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `_${string}` | `$${string}` ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type PrivateCollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey extends `_${string}` | `$${string}` ? TKey : never;
 type CollectionManifestKeys<TModels> = {
     [K in StringKey<TModels>]: CollectionManifestKey<K>;
 }[StringKey<TModels>];
+type PrivateCollectionManifestKeys<TModels> = {
+    [K in StringKey<TModels>]: PrivateCollectionManifestKey<K>;
+}[StringKey<TModels>];
 type ModelPathManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}*${string}` ? TKey : never;
 type ModelPathManifestKeys<TModels> = {
     [K in StringKey<TModels>]: ModelPathManifestKey<K>;
@@ -26,9 +31,15 @@ type SchemaFromEntry<TEntry> = TEntry extends {
 type CollectionSpecFromManifestEntry<TModels, TCollection extends string> = [
     SchemaFromEntry<ManifestEntry<TModels, TCollection>>
 ] extends [never] ? CollectionSpec<unknown, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>> : JsonSchemaSpec<SchemaFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>>;
+type PrivateCollectionValueFromManifestEntry<TModels, TCollection extends string> = [
+    SchemaFromEntry<ManifestEntry<TModels, TCollection>>
+] extends [never] ? unknown : FromJsonSchema<SchemaFromEntry<ManifestEntry<TModels, TCollection>>>;
 export type CollectionsFromManifest<TModels extends Record<string, any>> = {
     [K in CollectionManifestKeys<TModels>]: CollectionSpecFromManifestEntry<TModels, K>;
 };
+export type PrivateCollectionsFromManifest<TModels extends Record<string, any>> = {
+    [K in PrivateCollectionManifestKeys<TModels>]: PrivateCollectionValueFromManifestEntry<TModels, K>;
+};
 export type PathModelsFromManifest<TModels extends Record<string, any>> = {
     [K in ModelPathManifestKeys<TModels> as ManifestEntry<TModels, K> extends {
         default: any;

package/dist/orm/types/signal.d.ts

@@ -1,4 +1,4 @@
-import type { TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../../index.js';
+import type { TeamplayCollections, TeamplayPrivateCollections, TeamplayPluginPrivateCollections, TeamplayModels, TeamplayPluginCollections, TeamplayPluginModels, TeamplayPluginSignalFields, TeamplaySignalFields } from '../../index.js';
 import type { Signal, GETTERS } from '../SignalBase.js';
 import type { FromJsonSchema, InferZodSchema, JsonSchema, ZodLikeSchema } from './jsonSchema.js';
 import type { AppendPath, JoinPath, PathSegment, WildcardSignalPath } from './path.js';
@@ -20,11 +20,29 @@ type SignalQueryMethodKeys = SignalArrayReaderMethodKeys | SignalArrayMutatorMet
 type BlockedArrayMutators = {
     readonly [K in SignalArrayMutatorMethodKeys]?: never;
 };
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayCollections = TeamplayCollections & MergeRegistry<TeamplayPluginCollections>;
+type EffectiveTeamplayPrivateCollections = TeamplayPrivateCollections & MergeRegistry<TeamplayPluginPrivateCollections>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+type EffectiveTeamplaySignalFields = TeamplaySignalFields & MergeRegistry<TeamplayPluginSignalFields>;
+type RootDollarAliases = {
+    readonly session: '_session';
+    readonly page: '_page';
+    readonly render: '$render';
+    readonly system: '$system';
+};
 type SignalArrayLike<TItem> = SignalArrayReaderMethods<TItem>;
-type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplayModels ? TeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? TeamplayModels[JoinPath<TPath>] : TeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? TeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
+type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? EffectiveTeamplayModels[JoinPath<TPath>] : EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? EffectiveTeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
 type ArrayItemSignal<Item, TPath extends WildcardSignalPath> = DocumentSignal<Item, typeof Signal, AppendPath<TPath, '*'>>;
 type SignalArrayMethods<TValue, TPath extends WildcardSignalPath> = NonNullable<TValue> extends ReadonlyArray<infer Item> ? SignalArrayLike<ArrayItemSignal<Item, TPath>> : Pick<Signal<TValue>, SignalArrayReaderMethodKeys>;
-type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplaySignalFields ? TeamplaySignalFields[JoinPath<TPath>] : {};
+type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplaySignalFields ? EffectiveTeamplaySignalFields[JoinPath<TPath>] : {};
+type DocumentSignalIdMethod = {
+    getId: () => string;
+};
 export type AnySignal = Signal<any>;
 type IsAny<TValue> = 0 extends (1 & TValue) ? true : false;
 type IsUnknown<TValue> = IsAny<TValue> extends true ? false : unknown extends TValue ? true : false;
@@ -34,7 +52,7 @@ type IsUnion<TValue, TUnion = TValue> = [
 ] extends [never] ? false : TValue extends unknown ? [TUnion] extends [TValue] ? false : true : false;
 type SingleKey<TKey> = IsUnion<TKey> extends true ? never : TKey;
 export type SignalKind = 'root' | 'document' | 'collection' | 'nestedValue' | 'localArray' | 'array' | 'query' | 'aggregation' | 'collectionQuery';
-type DocumentSignalForKind<TValue, TModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TValue, PathModel<TValue, TModel, TPath>>, SignalArrayReaderMethodKeys> & SignalArrayMethods<TValue, TPath> & SignalChildren<TValue, TPath> & SignalFieldsForPath<TPath>;
+type DocumentSignalForKind<TValue, TModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TValue, PathModel<TValue, TModel, TPath>>, SignalArrayReaderMethodKeys | 'getId'> & DocumentSignalIdMethod & SignalArrayMethods<TValue, TPath> & SignalChildren<TValue, TPath> & SignalFieldsForPath<TPath>;
 type CollectionSignalForKind<TDocument, TCollectionModel extends SignalClass<any>, TDocumentModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TDocument[], PathModel<TDocument[], TCollectionModel, TPath>>, SignalCollectionMethodKeys> & SignalArrayLike<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>> & BlockedArrayMutators & {
     add: (value: TDocument) => Promise<string>;
 } & CollectionDocumentIndex<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>>;
@@ -43,7 +61,7 @@ type ArraySignalForKind<TDocument, TDocumentModel extends SignalClass<any>, TDoc
     readonly [index: number]: DocumentSignal<TDocument, TDocumentModel, TDocumentPath>;
 } & BlockedArrayMutators;
 type QueryMetadataSignals = {
-    readonly ids: Signal<Array<string | number>>;
+    readonly ids: Signal<string[]>;
     readonly extra: Signal<unknown>;
 };
 type QuerySignalForKind<TDocument, TDocumentModel extends SignalClass<any>, TDocumentPath extends WildcardSignalPath> = ArraySignalForKind<TDocument, TDocumentModel, TDocumentPath> & QueryMetadataSignals;
@@ -59,22 +77,22 @@ export type CollectionDocument<TSpec> = TSpec extends CollectionSpec<infer Docum
 export type CollectionDocumentModel<TSpec> = TSpec extends CollectionSpec<any, any, infer DocumentModel> ? DocumentModel : typeof Signal;
 export type CollectionQuerySignal<TDocument, TCollectionModel extends SignalClass<any>, TDocumentModel extends SignalClass<any>, TCollectionPath extends WildcardSignalPath> = CollectionSignalForKind<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> & QueryMetadataSignals;
 type MatchingDocumentCollectionKeys<TValue> = IsAny<TValue> extends true ? never : {
-    [K in keyof TeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<TeamplayCollections[K]>>> extends true ? K : never;
-}[keyof TeamplayCollections & string];
+    [K in keyof EffectiveTeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<EffectiveTeamplayCollections[K]>>> extends true ? K : never;
+}[keyof EffectiveTeamplayCollections & string];
 type MatchingCollectionKeys<TValue> = IsAny<TValue> extends true ? never : NonNullable<TValue> extends ReadonlyArray<infer TDocument> ? MatchingDocumentCollectionKeys<TDocument> : never;
 type SingleDocumentCollectionKey<TValue> = SingleKey<MatchingDocumentCollectionKeys<TValue>>;
 type SingleCollectionKey<TValue> = SingleKey<MatchingCollectionKeys<TValue>>;
 type DocumentSignalModelForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? CollectionDocumentModel<TeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
+] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? CollectionDocumentModel<EffectiveTeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
 type DocumentSignalPathForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
+] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
 type SignalForDocumentValue<TValue> = TypedSignal<TValue, DocumentSignalModelForValue<TValue>, DocumentSignalPathForValue<TValue>>;
-type SignalForCollectionArrayValue<TCollection extends keyof TeamplayCollections & string> = CollectionSignal<CollectionDocument<TeamplayCollections[TCollection]>, TeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection]>;
+type SignalForCollectionArrayValue<TCollection extends keyof EffectiveTeamplayCollections & string> = CollectionSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, EffectiveTeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection]>;
 type SignalForArrayValue<TValue> = [
     SingleCollectionKey<TValue>
-] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof TeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
+] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
 export type PublicSignal<TValue = unknown> = IsAny<TValue> extends true ? TypedSignal<TValue> : NonNullable<TValue> extends ReadonlyArray<any> ? SignalForArrayValue<TValue> : SignalForDocumentValue<TValue>;
 export interface LocalSignalFactory {
     (): any;
@@ -82,12 +100,12 @@ export interface LocalSignalFactory {
     <TValue>(factory: () => TValue): TypedSignal<TValue>;
     <TValue>(value: TValue): TypedSignal<TValue>;
 }
-export type RootCollections<TCollections extends Record<string, any> = TeamplayCollections> = {
+export type RootCollections<TCollections = EffectiveTeamplayCollections> = {
     readonly [K in keyof TCollections & string]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 } & {
     readonly [K in keyof TCollections & string as `$${K}`]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 };
-export type RootSignal<TCollections extends Record<string, any> = TeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections>;
+export type RootSignal<TCollections = EffectiveTeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections> & RootPrivateCollections;
 export interface RegisteredAggregationInput<TCollection extends string = string, TOutput = unknown> {
     readonly __isAggregation: true;
     readonly collection: TCollection;
@@ -98,10 +116,10 @@ export interface TypedAggregationInput<TDocument = unknown, TDocumentModel exten
     readonly __teamplayDocument?: TDocument;
     readonly __teamplayDocumentModel?: TDocumentModel;
 }
-export type CollectionAggregationSignal<TCollection extends keyof TeamplayCollections & string> = AggregationSignal<CollectionDocument<TeamplayCollections[TCollection]>, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
+export type CollectionAggregationSignal<TCollection extends keyof EffectiveTeamplayCollections & string> = AggregationSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
 export type TypedAggregationSignal<TDocument, TDocumentModel extends SignalClass<any>> = AggregationSignal<TDocument, TDocumentModel>;
 export type AggregationOutputSignal<TOutput> = IsAny<TOutput> extends true ? QuerySignal : NonNullable<TOutput> extends ReadonlyArray<infer TDocument> ? AggregationSignal<TDocument, DocumentSignalModelForValue<TDocument>, DocumentSignalPathForValue<TDocument>> : SignalForDocumentValue<TOutput>;
-type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof TeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
+type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof EffectiveTeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
 export type MaybePromise<TValue> = TValue | Promise<TValue>;
 export type SubResult<TSignal, TParams = undefined> = TSignal extends ClientAggregationFunction<infer TOutput, infer TCollection> ? RegisteredAggregationSignal<TCollection, TOutput> : TSignal extends AggregationFunction<infer TOutput, any> ? IsUnknown<TOutput> extends true ? QuerySignal : AggregationOutputSignal<TOutput> : TSignal extends TypedAggregationInput<infer TDocument, infer TDocumentModel> ? TypedAggregationSignal<TDocument, TDocumentModel> : TSignal extends RegisteredAggregationInput<infer TCollection, infer TOutput> ? RegisteredAggregationSignal<TCollection, TOutput> : [TParams] extends [undefined] ? TSignal extends DocumentSignal<any, any, any> ? TSignal : QuerySignal : TSignal extends CollectionSignal<infer TDocument, infer TCollectionModel, infer TDocumentModel, infer TCollectionPath> ? CollectionQuerySignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> : QuerySignal;
 export type MaybePromiseSubResult<TSignal, TParams = undefined> = MaybePromise<SubResult<TSignal, TParams>>;
@@ -121,6 +139,17 @@ export interface CollectionSpec<TDocument = unknown, TCollectionModel extends Si
 export type JsonSchemaSpec<TSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<FromJsonSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type ZodSchemaSpec<TSchema extends ZodLikeSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<InferZodSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type CollectionSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = TSpec extends CollectionSpec<infer Document, infer CollectionModel, infer DocumentModel> ? CollectionSignal<Document, CollectionModel, DocumentModel, TPath> : TSpec extends JsonSchema ? CollectionSignal<FromJsonSchema<TSpec>, typeof Signal, typeof Signal, TPath> : CollectionSignal;
+export type PrivateSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = Omit<DocumentSignal<TSpec, typeof Signal, TPath>, 'add'>;
+type PrivateSignalForAlias<TPrivateCollections, TAlias extends keyof RootDollarAliases & string> = RootDollarAliases[TAlias] extends keyof TPrivateCollections & string ? PrivateSignalFromSpec<TPrivateCollections[RootDollarAliases[TAlias]], readonly [RootDollarAliases[TAlias]]> : never;
+export type RootPrivateCollections<TPrivateCollections = EffectiveTeamplayPrivateCollections> = {
+    readonly [K in keyof TPrivateCollections & string]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof TPrivateCollections & string as `$${K}`]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? K : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? `$${K}` : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+};
 export interface SignalConstructor {
     new <TValue = unknown>(segments: PathSegment[]): TypedSignal<TValue>;
     readonly ID_FIELDS: typeof Signal.ID_FIELDS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.3",
+  "version": "0.5.0-alpha.5",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -69,13 +69,13 @@
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
     "@startupjs/sharedb-mingo-memory": "^4.0.0-2",
-    "@teamplay/backend": "^0.5.0-alpha.1",
+    "@teamplay/backend": "^0.5.0-alpha.5",
     "@teamplay/cache": "^0.5.0-alpha.0",
     "@teamplay/channel": "^0.5.0-alpha.0",
     "@teamplay/debug": "^0.5.0-alpha.0",
     "@teamplay/schema": "^0.5.0-alpha.1",
-    "@teamplay/utils": "^0.5.0-alpha.0",
-    "babel-plugin-teamplay": "^0.5.0-alpha.1",
+    "@teamplay/utils": "^0.5.0-alpha.5",
+    "babel-plugin-teamplay": "^0.5.0-alpha.5",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
@@ -128,5 +128,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "08829f3421180538991f1da72dcc6919f5a274d1"
+  "gitHead": "4527ba386f4994295901c4b4e30c5eaf42739103"
 }