teamplay 0.5.0-alpha.3 → 0.5.0-alpha.4

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/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.3",
+  "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": "08829f3421180538991f1da72dcc6919f5a274d1"
+  "gitHead": "7ec37caa078961926442b1aba74768792359c2c2"
 }