teamplay 0.5.0-alpha.2 → 0.5.0-alpha.4

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import type * as React from 'react';
 import { SEGMENTS } from './orm/Signal.js';
 import useApi from './react/useApi.js';
-import type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, LocalSignalFactory, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalChild, SignalBaseInstance, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalClass, SignalCollectionMethods, SignalConstructor, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './orm/Signal.js';
+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';
 export interface TeamplayCollections {
 }
 export interface TeamplayModels {
@@ -9,7 +9,7 @@ export interface TeamplayModels {
 export interface TeamplaySignalFields {
 }
 export type Signal<TValue = unknown> = PublicSignal<TValue>;
-export type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSpec, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, CollectionsFromManifest, LocalSignalFactory, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalCollectionMethods, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec };
+export 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 interface ObserverOptions {
     forwardRef?: boolean;
     cache?: boolean;

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

@@ -1,7 +1,7 @@
 import SignalCompat from './Compat/SignalCompat.js';
 import type { SignalConstructor } from './types/signal.js';
 export type { FromJsonSchema, InferZodSchema, JsonSchema, JsonSchemaObject, ZodLikeSchema } from './types/jsonSchema.js';
-export type { QueryParams } from './types/query.js';
+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';

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/index.d.ts

@@ -1,5 +1,5 @@
 export { belongsTo, hasMany, hasOne } from './associations.js';
-export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.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 declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;

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/sub.d.ts

@@ -1,5 +1,5 @@
 import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation';
-import type { CollectionSignal, DocumentSignal, MaybePromise, MaybePromiseSubResult, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from './Signal.js';
+import type { CollectionSignal, ComputedQueryParamsInput, DocumentSignal, MaybePromise, MaybePromiseSubResult, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from './Signal.js';
 /**
  * Subscribe to an aggregation with explicit output typing outside React.
  * @param $aggregation Typed aggregation input.
@@ -35,3 +35,11 @@ export default function sub<TSignal extends DocumentSignal<any, any, any>>($sign
  * @param params Mongo-style query params, including filters and `$sort`.
  */
 export default function sub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>($collection: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>): MaybePromiseSubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys outside React.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param $collection Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ */
+export default function sub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>($collection: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>): MaybePromiseSubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;

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/jsonSchema.d.ts

@@ -38,7 +38,7 @@ type SimplifiedProperties<TSchema> = {
 type HasSimplifiedProperties<TSchema> = keyof SimplifiedProperties<TSchema> extends never ? false : true;
 type SchemaProperties<TSchema> = TSchema extends {
     readonly properties: infer Properties;
-} ? IsFullObjectSchema<TSchema> extends true ? Properties : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<string, never> : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<string, never>;
+} ? IsFullObjectSchema<TSchema> extends true ? Properties : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<never, never> : IsFullObjectSchema<TSchema> extends true ? Record<never, never> : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<never, never>;
 type ExplicitRequiredKeys<TSchema, TProperties> = TSchema extends {
     readonly required?: infer Required;
 } ? Required extends readonly string[] ? Extract<Required[number], keyof TProperties & string> : never : never;
@@ -50,10 +50,10 @@ type SimplifiedRequiredKeys<TProperties> = {
 type RequiredKeys<TSchema, TProperties> = ExplicitRequiredKeys<TSchema, TProperties> | SimplifiedRequiredKeys<TProperties>;
 type PatternPropertiesFromJsonSchema<TSchema> = TSchema extends {
     readonly patternProperties?: infer PatternProperties;
-} ? PatternProperties extends Record<string, infer PatternSchema> ? Record<string, FromJsonSchema<PatternSchema>> : {} : {};
+} ? PatternProperties extends object ? keyof PatternProperties extends never ? {} : Record<string, FromJsonSchema<PatternProperties[keyof PatternProperties]>> : {} : {};
 type AdditionalPropertiesFromJsonSchema<TSchema> = TSchema extends {
     readonly additionalProperties?: infer AdditionalProperties;
-} ? AdditionalProperties extends JsonSchema ? Record<string, FromJsonSchema<AdditionalProperties>> : {} : {};
+} ? AdditionalProperties extends false ? {} : AdditionalProperties extends JsonSchema ? Record<string, FromJsonSchema<AdditionalProperties>> : {} : {};
 type ObjectFromJsonSchema<TSchema> = SchemaProperties<TSchema> extends infer Properties ? Properties extends Record<string, unknown> ? Prettify<{
     [K in RequiredKeys<TSchema, Properties>]-?: FromJsonSchema<Properties[K]>;
 } & {

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

@@ -16,14 +16,20 @@ type QueryValue<TValue> = QueryComparable<TValue> | {
     $exists?: boolean;
     $regex?: TValue extends string ? string | RegExp : never;
 };
+type QuerySortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+type QuerySort<TDocument> = {
+    [K in QueryPath<TDocument> | '_id' | 'id']?: QuerySortDirection;
+};
 export type QueryParams<TDocument> = {
     [K in QueryPath<TDocument>]?: QueryValue<QueryPathValue<TDocument, K>>;
 } & {
     _id?: QueryValue<string | number>;
     id?: QueryValue<string | number>;
 } & {
-    [K in `${string}.${string}`]?: unknown;
+    $sort?: QuerySort<TDocument>;
 } & {
     [K in `$${string}`]?: unknown;
 };
+export type ComputedQueryParamsInput<TParams extends object> = string extends keyof TParams ? TParams : never;
+export type QueryParamsInput<TDocument, TParams extends object> = TParams extends QueryParams<TDocument> ? TParams : ComputedQueryParamsInput<TParams>;
 export {};

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

@@ -25,6 +25,9 @@ type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends Wil
 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 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 +37,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 +46,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;

package/dist/react/useSub.d.ts

@@ -1,5 +1,5 @@
 import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation';
-import type { CollectionSignal, DocumentSignal, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from '../orm/Signal.js';
+import type { CollectionSignal, ComputedQueryParamsInput, DocumentSignal, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from '../orm/Signal.js';
 export interface UseSubOptions {
     /** Return `undefined` while loading instead of throwing a Suspense promise. */
     async?: boolean;
@@ -24,6 +24,15 @@ export declare function useAsyncSub<TSignal extends DocumentSignal<any, any, any
  * @param options Subscription behavior options.
  */
 export declare function useAsyncSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys in React async mode.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ * @param options Subscription behavior options.
+ */
+export declare function useAsyncSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;
 /**
  * Subscribe to a registered collection aggregation in React async mode.
  * @param signal Aggregation header generated by StartupJS model loading.
@@ -66,6 +75,15 @@ export default function useSub<TSignal extends DocumentSignal<any, any, any>>(si
  * @param options Subscription behavior options.
  */
 export default function useSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys in React.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;
 /**
  * Subscribe to a registered collection aggregation in React.
  * @param signal Aggregation header generated by StartupJS model loading.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.2",
+  "version": "0.5.0-alpha.4",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -128,5 +128,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "6d03dc309c39801dac31320a089dc30327613123"
+  "gitHead": "7ec37caa078961926442b1aba74768792359c2c2"
 }