teamplay 0.5.0-alpha.30 → 0.5.0-alpha.31

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './orm/idFields.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './orm/idFields.js';

package/dist/config.js

@@ -0,0 +1 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./orm/idFields.js";

package/dist/connect/index.d.ts

@@ -1 +1 @@
-export default function connect(options: any): void;
+export default function connect(options?: {}): void;

package/dist/connect/index.js

@@ -1,9 +1,13 @@
 import Socket from '@teamplay/channel';
 import Connection from './sharedbConnection.cjs';
 import { connection, setConnection } from "../orm/connection.js";
-export default function connect(options) {
+import { configureTeamplay } from "../config.js";
+export default function connect(options = {}) {
+    const { idFields, ...socketOptions } = options || {};
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     if (connection)
         return;
-    const socket = new Socket(options);
+    const socket = new Socket(socketOptions);
     setConnection(new Connection(socket));
 }

package/dist/connect/offline/index.d.ts

@@ -1 +1 @@
-export default function createConnectWithPersistence({ storage, createPubsub }?: {}): () => Promise<void>;
+export default function createConnectWithPersistence({ storage, createPubsub }?: {}): (options?: {}) => Promise<void>;

package/dist/connect/offline/index.js

@@ -3,21 +3,25 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../../orm/connection.js";
+import { configureTeamplay } from "../../config.js";
 const STORAGE_NAMESPACE = 'teamplay-offline';
 const DOCS_PREFIX = `${STORAGE_NAMESPACE}:docs:`;
 const LAST_OP_PREFIX = `${STORAGE_NAMESPACE}:last-op:`;
 export default function createConnectWithPersistence({ storage, createPubsub } = {}) {
     if (!storage)
         throw new Error('[connect-offline] storage is required');
-    return async function connect() {
+    return async function connect(options = {}) {
+        const { idFields } = options || {};
+        if (idFields !== undefined)
+            configureTeamplay({ idFields });
         if (connection)
             return;
         const db = new ShareDbMingo();
-        const options = { db };
+        const backendOptions = { db };
         const { pubsub } = (await init(db, storage, createPubsub)) || {};
         if (pubsub)
-            options.pubsub = pubsub;
-        const backend = new ShareBackend(options);
+            backendOptions.pubsub = pubsub;
+        const backend = new ShareBackend(backendOptions);
         setConnection(backend.connect());
     };
 }

package/dist/connect/offline/react-native.d.ts

@@ -3,7 +3,7 @@ export namespace storage {
     export { setItem };
     export { iterate };
 }
-declare const _default: () => Promise<void>;
+declare const _default: (options?: {}) => Promise<void>;
 export default _default;
 declare function getItem(key: any): Promise<any>;
 declare function setItem(key: any, value: any): Promise<any>;

package/dist/connect/offline/web.d.ts

@@ -4,6 +4,6 @@ export namespace storage {
     function setItem(key: any, value: any): Promise<any>;
     function iterate(iterator: any): Promise<any>;
 }
-declare const _default: () => Promise<void>;
+declare const _default: (options?: {}) => Promise<void>;
 export default _default;
 import SharedbCrosstabPubsub from '../lib/sharedb-crosstab-pubsub.cjs';

package/dist/connect/test.d.ts

@@ -1 +1 @@
-export default function connect(): void;
+export default function connect(options?: {}): void;

package/dist/connect/test.js

@@ -4,7 +4,11 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../orm/connection.js";
-export default function connect() {
+import { configureTeamplay } from "../config.js";
+export default function connect(options = {}) {
+    const { idFields } = options || {};
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     if (connection)
         return;
     const backend = new ShareBackend({ db: new ShareDbMingo() });

package/dist/index.d.ts

@@ -62,6 +62,8 @@ export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
 export { useDidUpdate, useOnce, useSyncEffect } from './react/helpers.js';
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js';
 export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.js';
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './config.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './config.js';
 export { getSubscriptionGcDelay, setSubscriptionGcDelay } from './orm/subscriptionGcDelay.js';
 export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.js';
 export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';

package/dist/index.js

@@ -21,6 +21,7 @@ export const observer = runtimeObserver;
 export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
 export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./config.js";
 export { getSubscriptionGcDelay, setSubscriptionGcDelay } from "./orm/subscriptionGcDelay.js";
 export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from "./react/helpers.js";
 export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';

package/dist/orm/Compat/SignalCompat.js

@@ -18,7 +18,6 @@ import universal$ from "../../react/universal$.js";
 import { getRootContext } from "../rootContext.js";
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
 class SignalCompat extends Signal {
-    static ID_FIELDS = ['_id'];
     static [GETTERS] = DEFAULT_GETTERS;
     path() {
         if (arguments.length > 0)

package/dist/orm/SignalBase.d.ts

@@ -2,7 +2,7 @@ import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from './signalS
 export { SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS };
 export declare class Signal<TValue = unknown> extends Function {
     /** Fields that are treated as document ids and mirror the document id segment. */
-    static ID_FIELDS: readonly ["_id"];
+    static get ID_FIELDS(): import("./idFields.js").IdFields;
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS]: string[];
     /** Association metadata registered for this model class. */

package/dist/orm/SignalBase.js

@@ -21,7 +21,7 @@ import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
 import { ROOT_FUNCTION, ROOT_ID, closeRootSignal, getRoot } from "./Root.js";
-import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
+import { getDefaultIdFields, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
 import { isCompatEnv } from './compatEnv.js';
 import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js';
 import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js';
@@ -91,7 +91,9 @@ const SIGNAL_VALUE_MUTATION_CONTEXT = {
 };
 export class Signal extends Function {
     /** Fields that are treated as document ids and mirror the document id segment. */
-    static ID_FIELDS = DEFAULT_ID_FIELDS;
+    static get ID_FIELDS() {
+        return getDefaultIdFields();
+    }
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS] = DEFAULT_GETTERS;
     /** Association metadata registered for this model class. */
@@ -578,8 +580,10 @@ export class Signal extends Function {
     async add(value) {
         if (arguments.length > 1)
             throw Error('Signal.add() expects a single argument');
-        const id = resolveAddDocId(value, uuid);
-        const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id]);
+        const collection = this[SEGMENTS][0];
+        const collectionIdFields = getIdFieldsForSegments([collection, '']);
+        const id = resolveAddDocId(value, collectionIdFields, uuid);
+        const idFields = getIdFieldsForSegments([collection, id]);
         await this[id].set(prepareAddPayload(value, idFields, id));
         return id;
     }

package/dist/orm/idFields.d.ts

@@ -2,13 +2,22 @@ import type { PathSegment } from './types/path.js';
 export type IdField = string;
 export type IdFields = readonly IdField[];
 export type PlainObject = Record<string, unknown>;
+export interface TeamplayRuntimeConfig {
+    idFields?: IdFields | null;
+}
 export declare const DEFAULT_ID_FIELDS: readonly ["_id"];
+export declare const TEAMPLAY_RUNTIME_CONFIG_SYMBOL: unique symbol;
 export declare function getIdFieldsForSegments(segments: PathSegment[]): IdFields;
+export declare function configureTeamplay({ idFields }?: TeamplayRuntimeConfig): void;
+export declare function getTeamplayConfig(): Required<TeamplayRuntimeConfig>;
+export declare function getDefaultIdFields(): IdFields;
+export declare function setDefaultIdFields(idFields?: IdFields): void;
+export declare function __resetTeamplayConfigForTests(): void;
 export declare function isPlainObject(value: unknown): value is PlainObject;
 export declare function injectIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function normalizeIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function stripIdFields<TValue>(value: TValue, idFields: IdFields): TValue;
-export declare function resolveAddDocId(value: unknown, getDefaultId: () => string): PathSegment;
+export declare function resolveAddDocId(value: unknown, idFields: IdFields, getDefaultId: () => string): PathSegment;
 export declare function prepareAddPayload<TValue extends object>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function isPublicDocPath(segments: unknown): segments is [string, PathSegment];
 export declare function isIdFieldPath(segments: unknown, idFields: IdFields): segments is [string, PathSegment, string];

package/dist/orm/idFields.js

@@ -1,8 +1,42 @@
 import { findModel } from "./addModel.js";
 export const DEFAULT_ID_FIELDS = ['_id'];
+export const TEAMPLAY_RUNTIME_CONFIG_SYMBOL = Symbol.for('teamplay.runtimeConfig');
 export function getIdFieldsForSegments(segments) {
     const Model = findModel(segments);
-    return Model?.ID_FIELDS || DEFAULT_ID_FIELDS;
+    return Model?.ID_FIELDS || getDefaultIdFields();
+}
+export function configureTeamplay({ idFields } = {}) {
+    if (arguments.length === 0)
+        return;
+    const config = getGlobalRuntimeConfig(true);
+    const options = (arguments[0] || {});
+    if (Object.prototype.hasOwnProperty.call(options, 'idFields')) {
+        config.idFields = idFields == null
+            ? DEFAULT_ID_FIELDS
+            : normalizeIdFieldsConfig(idFields);
+    }
+}
+export function getTeamplayConfig() {
+    return {
+        idFields: getDefaultIdFields()
+    };
+}
+export function getDefaultIdFields() {
+    const config = getGlobalRuntimeConfig(false);
+    if (!config || !Object.prototype.hasOwnProperty.call(config, 'idFields')) {
+        return DEFAULT_ID_FIELDS;
+    }
+    if (config.idFields == null)
+        return DEFAULT_ID_FIELDS;
+    const normalized = normalizeIdFieldsConfig(config.idFields);
+    config.idFields = normalized;
+    return normalized;
+}
+export function setDefaultIdFields(idFields = DEFAULT_ID_FIELDS) {
+    getGlobalRuntimeConfig(true).idFields = normalizeIdFieldsConfig(idFields);
+}
+export function __resetTeamplayConfigForTests() {
+    delete getGlobalRuntimeConfigHolder()[TEAMPLAY_RUNTIME_CONFIG_SYMBOL];
 }
 export function isPlainObject(value) {
     if (!value || typeof value !== 'object')
@@ -52,26 +86,28 @@ export function stripIdFields(value, idFields) {
     }
     return next;
 }
-export function resolveAddDocId(value, getDefaultId) {
+export function resolveAddDocId(value, idFields, getDefaultId) {
     if (!value || typeof value !== 'object')
         throw Error('Signal.add() expects an object argument');
     const payload = value;
-    const hasId = payload.id != null;
-    const hasUnderscoreId = payload._id != null;
-    if (hasId && hasUnderscoreId && payload.id !== payload._id) {
-        throw Error(`Signal.add() got conflicting "id" (${JSON.stringify(payload.id)}) and "_id" (${JSON.stringify(payload._id)})`);
+    const entries = getAddIdEntries(payload, idFields);
+    const [firstEntry] = entries;
+    const conflictEntry = firstEntry && entries.find(entry => entry.value !== firstEntry.value);
+    if (firstEntry && conflictEntry) {
+        throw Error(`Signal.add() got conflicting "${firstEntry.field}" (${JSON.stringify(firstEntry.value)}) ` +
+            `and "${conflictEntry.field}" (${JSON.stringify(conflictEntry.value)}) id fields`);
     }
-    return payload.id ?? payload._id ?? getDefaultId();
+    return firstEntry?.value ?? getDefaultId();
 }
 export function prepareAddPayload(value, idFields, docId) {
     const payload = value;
-    if (idFields.includes('_id'))
-        payload._id = docId;
-    if (idFields.includes('id')) {
-        payload.id = docId;
-    }
-    else if (payload.id === docId) {
-        delete payload.id;
+    for (const field of idFields)
+        payload[field] = docId;
+    for (const field of LEGACY_ADD_ID_FIELDS) {
+        if (idFields.includes(field))
+            continue;
+        if (payload[field] === docId)
+            delete payload[field];
     }
     return value;
 }
@@ -93,3 +129,55 @@ export function isIdFieldPath(segments, idFields) {
     const last = segments[2];
     return typeof last === 'string' && idFields.includes(last);
 }
+function normalizeIdFieldsConfig(idFields) {
+    if (!Array.isArray(idFields)) {
+        throw Error('Teamplay idFields config must be an array of field names');
+    }
+    const normalized = [];
+    for (const field of idFields) {
+        if (typeof field !== 'string' || field.length === 0) {
+            throw Error('Teamplay idFields config must contain only non-empty string field names');
+        }
+        if (!normalized.includes(field))
+            normalized.push(field);
+    }
+    if (normalized.length === 0) {
+        throw Error('Teamplay idFields config must contain at least one field name');
+    }
+    return Object.freeze(normalized);
+}
+function getAddIdEntries(payload, idFields) {
+    const fields = uniqueFields([...LEGACY_ADD_ID_FIELDS, ...idFields]);
+    const entries = [];
+    for (const field of fields) {
+        const value = payload[field];
+        if (value == null)
+            continue;
+        entries.push({ field, value: value });
+    }
+    return entries;
+}
+function uniqueFields(fields) {
+    const result = [];
+    for (const field of fields) {
+        if (!result.includes(field))
+            result.push(field);
+    }
+    return result;
+}
+function getGlobalRuntimeConfig(create = true) {
+    const holder = getGlobalRuntimeConfigHolder();
+    let config = holder[TEAMPLAY_RUNTIME_CONFIG_SYMBOL];
+    if (config == null && create) {
+        config = {};
+        holder[TEAMPLAY_RUNTIME_CONFIG_SYMBOL] = config;
+    }
+    if (config != null && (!isPlainObject(config))) {
+        throw Error('Teamplay runtime config must be an object');
+    }
+    return config;
+}
+function getGlobalRuntimeConfigHolder() {
+    return globalThis;
+}
+const LEGACY_ADD_ID_FIELDS = ['id', '_id'];

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 export function createBackend(options?: {}): any;
-export function initConnection(backend: any, { fetchOnly, publicOnly, ...options }?: {
+export function initConnection(backend: any, { fetchOnly, publicOnly, idFields, ...options }?: {
     fetchOnly?: boolean | undefined;
     publicOnly?: boolean | undefined;
 }): {

package/dist/server.js

@@ -2,6 +2,7 @@ import createChannel from '@teamplay/channel/server';
 import backendCreateBackend from '@teamplay/backend';
 import { getModels } from "./orm/initModels.js";
 import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from "./orm/connection.js";
+import { configureTeamplay } from "./config.js";
 export { default as ShareDB } from 'sharedb';
 export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite, getRedis, Redis, getRedisOptions, redisPrefix, generateRedisPrefix } from '@teamplay/backend';
 export function createBackend(options = {}) {
@@ -16,11 +17,13 @@ export function createBackend(options = {}) {
     return backendCreateBackend(nextOptions);
 }
 export default createBackend;
-export function initConnection(backend, { fetchOnly = true, publicOnly = true, ...options } = {}) {
+export function initConnection(backend, { fetchOnly = true, publicOnly = true, idFields, ...options } = {}) {
     if (!backend)
         throw Error('backend is required');
     if (connection)
         throw Error('Connection already exists');
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     setConnection(backend.connect());
     setDefaultFetchOnly(fetchOnly);
     setPublicOnly(publicOnly);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.30",
+  "version": "0.5.0-alpha.31",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,11 @@
       "teamplay-ts": "./src/connect/index.js",
       "default": "./dist/connect/index.js"
     },
+    "./config": {
+      "teamplay-ts": "./src/config.ts",
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
     "./server": {
       "teamplay-ts": "./src/server.js",
       "types": "./dist/server.d.ts",
@@ -134,5 +139,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "f568bc4a6af329926d4265c542eb2994b365bc28"
+  "gitHead": "efb7d7215b571620de2f7348ba1cd80e0cff7024"
 }