teamplay 0.5.0-alpha.4 → 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/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/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/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,26 @@ 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;
 };
@@ -62,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;
@@ -85,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;
@@ -101,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>>;
@@ -124,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.4",
+  "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": "7ec37caa078961926442b1aba74768792359c2c2"
+  "gitHead": "4527ba386f4994295901c4b4e30c5eaf42739103"
 }