@topgunbuild/server 0.4.0 → 0.6.0

package/dist/index.js

@@ -38,6 +38,7 @@ __export(index_exports, {
   ConnectionRateLimiter: () => ConnectionRateLimiter,
   DEFAULT_CLUSTER_COORDINATOR_CONFIG: () => DEFAULT_CLUSTER_COORDINATOR_CONFIG,
   DEFAULT_CONFLICT_RESOLVER_CONFIG: () => DEFAULT_CONFLICT_RESOLVER_CONFIG,
+  DEFAULT_INDEX_CONFIG: () => DEFAULT_INDEX_CONFIG,
   DEFAULT_JOURNAL_SERVICE_CONFIG: () => DEFAULT_JOURNAL_SERVICE_CONFIG,
   DEFAULT_LAG_TRACKER_CONFIG: () => DEFAULT_LAG_TRACKER_CONFIG,
   DEFAULT_SANDBOX_CONFIG: () => DEFAULT_SANDBOX_CONFIG,
@@ -48,6 +49,7 @@ __export(index_exports, {
   IteratorTasklet: () => IteratorTasklet,
   LagTracker: () => LagTracker,
   LockManager: () => LockManager,
+  MapFactory: () => MapFactory,
   MapTasklet: () => MapTasklet,
   MapWithResolver: () => MapWithResolver,
   MemoryServerAdapter: () => MemoryServerAdapter,
@@ -78,11 +80,13 @@ __export(index_exports, {
   getNativeStats: () => getNativeStats,
   logNativeStatus: () => logNativeStatus,
   logger: () => logger,
+  mergeWithDefaults: () => mergeWithDefaults,
   setGlobalBufferPool: () => setGlobalBufferPool,
   setGlobalEventPayloadPool: () => setGlobalEventPayloadPool,
   setGlobalMessagePool: () => setGlobalMessagePool,
   setGlobalRecordPool: () => setGlobalRecordPool,
-  setGlobalTimestampPool: () => setGlobalTimestampPool
+  setGlobalTimestampPool: () => setGlobalTimestampPool,
+  validateIndexConfig: () => validateIndexConfig
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -443,14 +447,70 @@ var QueryRegistry = class {
   /**
    * Processes a record change for all relevant subscriptions.
    * Calculates diffs and sends updates.
+   *
+   * For IndexedLWWMap: Uses StandingQueryRegistry for O(1) affected query detection.
+   * For regular maps: Falls back to ReverseQueryIndex.
    */
   processChange(mapName, map, changeKey, changeRecord, oldRecord) {
     const index = this.indexes.get(mapName);
     if (!index) return;
     const newVal = this.extractValue(changeRecord);
     const oldVal = this.extractValue(oldRecord);
+    if (map instanceof import_core2.IndexedLWWMap) {
+      this.processChangeWithStandingQuery(mapName, map, changeKey, newVal, oldVal);
+      return;
+    }
+    this.processChangeWithReverseIndex(mapName, map, changeKey, newVal, oldVal, index);
+  }
+  /**
+   * Process change using IndexedLWWMap's StandingQueryRegistry.
+   * O(1) detection of affected queries.
+   */
+  processChangeWithStandingQuery(mapName, map, changeKey, newVal, oldVal) {
+    const subs = this.subscriptions.get(mapName);
+    if (!subs || subs.size === 0) return;
+    const subsByQueryId = /* @__PURE__ */ new Map();
+    for (const sub of subs) {
+      subsByQueryId.set(sub.id, sub);
+    }
+    const standingRegistry = map.getStandingQueryRegistry();
+    let changes;
+    if (oldVal === null || oldVal === void 0) {
+      if (newVal !== null && newVal !== void 0) {
+        changes = standingRegistry.onRecordAdded(changeKey, newVal);
+      } else {
+        return;
+      }
+    } else if (newVal === null || newVal === void 0) {
+      changes = standingRegistry.onRecordRemoved(changeKey, oldVal);
+    } else {
+      changes = standingRegistry.onRecordUpdated(changeKey, oldVal, newVal);
+    }
+    for (const sub of subs) {
+      const coreQuery = this.convertToCoreQuery(sub.query);
+      if (!coreQuery) {
+        this.processSubscriptionFallback(sub, map, changeKey, newVal);
+        continue;
+      }
+      const queryHash = this.hashCoreQuery(coreQuery);
+      const change = changes.get(queryHash);
+      if (change === "added") {
+        sub.previousResultKeys.add(changeKey);
+        this.sendUpdate(sub, changeKey, newVal, "UPDATE");
+      } else if (change === "removed") {
+        sub.previousResultKeys.delete(changeKey);
+        this.sendUpdate(sub, changeKey, null, "REMOVE");
+      } else if (change === "updated") {
+        this.sendUpdate(sub, changeKey, newVal, "UPDATE");
+      }
+    }
+  }
+  /**
+   * Process change using legacy ReverseQueryIndex.
+   */
+  processChangeWithReverseIndex(mapName, map, changeKey, newVal, oldVal, index) {
     const changedFields = this.getChangedFields(oldVal, newVal);
-    if (changedFields !== "ALL" && changedFields.size === 0 && oldRecord && changeRecord) {
+    if (changedFields !== "ALL" && changedFields.size === 0 && oldVal && newVal) {
       return;
     }
     const candidates = index.getCandidates(changedFields, oldVal, newVal);
@@ -492,6 +552,103 @@ var QueryRegistry = class {
       sub.previousResultKeys = newResultKeys;
     }
   }
+  /**
+   * Fallback processing for subscriptions that can't use StandingQueryRegistry.
+   */
+  processSubscriptionFallback(sub, map, changeKey, newVal) {
+    const dummyRecord = {
+      value: newVal,
+      timestamp: { millis: 0, counter: 0, nodeId: "" }
+    };
+    const isMatch = newVal !== null && matchesQuery(dummyRecord, sub.query);
+    const wasInResult = sub.previousResultKeys.has(changeKey);
+    if (isMatch && !wasInResult) {
+      sub.previousResultKeys.add(changeKey);
+      this.sendUpdate(sub, changeKey, newVal, "UPDATE");
+    } else if (!isMatch && wasInResult) {
+      sub.previousResultKeys.delete(changeKey);
+      this.sendUpdate(sub, changeKey, null, "REMOVE");
+    } else if (isMatch && wasInResult) {
+      this.sendUpdate(sub, changeKey, newVal, "UPDATE");
+    }
+  }
+  /**
+   * Convert server Query format to core Query format.
+   */
+  convertToCoreQuery(query) {
+    if (query.predicate) {
+      return this.predicateToCoreQuery(query.predicate);
+    }
+    if (query.where) {
+      const conditions = [];
+      for (const [attribute, condition] of Object.entries(query.where)) {
+        if (typeof condition !== "object" || condition === null) {
+          conditions.push({ type: "eq", attribute, value: condition });
+        } else {
+          for (const [op, value] of Object.entries(condition)) {
+            const coreOp = this.convertOperator(op);
+            if (coreOp) {
+              conditions.push({ type: coreOp, attribute, value });
+            }
+          }
+        }
+      }
+      if (conditions.length === 0) return null;
+      if (conditions.length === 1) return conditions[0];
+      return { type: "and", children: conditions };
+    }
+    return null;
+  }
+  predicateToCoreQuery(predicate) {
+    if (!predicate || !predicate.op) return null;
+    switch (predicate.op) {
+      case "eq":
+      case "neq":
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte":
+        return {
+          type: predicate.op,
+          attribute: predicate.attribute,
+          value: predicate.value
+        };
+      case "and":
+      case "or":
+        if (predicate.children && Array.isArray(predicate.children)) {
+          const children = predicate.children.map((c) => this.predicateToCoreQuery(c)).filter((c) => c !== null);
+          if (children.length === 0) return null;
+          if (children.length === 1) return children[0];
+          return { type: predicate.op, children };
+        }
+        return null;
+      case "not":
+        if (predicate.children && predicate.children[0]) {
+          const child = this.predicateToCoreQuery(predicate.children[0]);
+          if (child) {
+            return { type: "not", child };
+          }
+        }
+        return null;
+      default:
+        return null;
+    }
+  }
+  convertOperator(op) {
+    const mapping = {
+      "$eq": "eq",
+      "$ne": "neq",
+      "$neq": "neq",
+      "$gt": "gt",
+      "$gte": "gte",
+      "$lt": "lt",
+      "$lte": "lte"
+    };
+    return mapping[op] || null;
+  }
+  hashCoreQuery(query) {
+    return JSON.stringify(query);
+  }
   extractValue(record) {
     if (!record) return null;
     if (Array.isArray(record)) {
@@ -9657,6 +9814,26 @@ var ServerCoordinator = class {
   }
   async executeLocalQuery(mapName, query) {
     const map = await this.getMapAsync(mapName);
+    const localQuery = { ...query };
+    delete localQuery.offset;
+    delete localQuery.limit;
+    if (map instanceof import_core15.IndexedLWWMap) {
+      const coreQuery = this.convertToCoreQuery(localQuery);
+      if (coreQuery) {
+        const entries = map.queryEntries(coreQuery);
+        return entries.map(([key, value]) => {
+          const record = map.getRecord(key);
+          return { key, value, timestamp: record?.timestamp };
+        });
+      }
+    }
+    if (map instanceof import_core15.IndexedORMap) {
+      const coreQuery = this.convertToCoreQuery(localQuery);
+      if (coreQuery) {
+        const results = map.query(coreQuery);
+        return results.map(({ key, value }) => ({ key, value }));
+      }
+    }
     const records = /* @__PURE__ */ new Map();
     if (map instanceof import_core15.LWWMap) {
       for (const key of map.allKeys()) {
@@ -9674,11 +9851,89 @@ var ServerCoordinator = class {
         }
       }
     }
-    const localQuery = { ...query };
-    delete localQuery.offset;
-    delete localQuery.limit;
     return executeQuery(records, localQuery);
   }
+  /**
+   * Convert server Query format to core Query format for indexed execution.
+   * Returns null if conversion is not possible (complex queries).
+   */
+  convertToCoreQuery(query) {
+    if (query.predicate) {
+      return this.predicateToCoreQuery(query.predicate);
+    }
+    if (query.where) {
+      const conditions = [];
+      for (const [attribute, condition] of Object.entries(query.where)) {
+        if (typeof condition !== "object" || condition === null) {
+          conditions.push({ type: "eq", attribute, value: condition });
+        } else {
+          for (const [op, value] of Object.entries(condition)) {
+            const coreOp = this.convertOperator(op);
+            if (coreOp) {
+              conditions.push({ type: coreOp, attribute, value });
+            }
+          }
+        }
+      }
+      if (conditions.length === 0) return null;
+      if (conditions.length === 1) return conditions[0];
+      return { type: "and", children: conditions };
+    }
+    return null;
+  }
+  /**
+   * Convert predicate node to core Query format.
+   */
+  predicateToCoreQuery(predicate) {
+    if (!predicate || !predicate.op) return null;
+    switch (predicate.op) {
+      case "eq":
+      case "neq":
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte":
+        return {
+          type: predicate.op,
+          attribute: predicate.attribute,
+          value: predicate.value
+        };
+      case "and":
+      case "or":
+        if (predicate.children && Array.isArray(predicate.children)) {
+          const children = predicate.children.map((c) => this.predicateToCoreQuery(c)).filter((c) => c !== null);
+          if (children.length === 0) return null;
+          if (children.length === 1) return children[0];
+          return { type: predicate.op, children };
+        }
+        return null;
+      case "not":
+        if (predicate.children && predicate.children[0]) {
+          const child = this.predicateToCoreQuery(predicate.children[0]);
+          if (child) {
+            return { type: "not", child };
+          }
+        }
+        return null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Convert server operator to core query type.
+   */
+  convertOperator(op) {
+    const mapping = {
+      "$eq": "eq",
+      "$ne": "neq",
+      "$neq": "neq",
+      "$gt": "gt",
+      "$gte": "gte",
+      "$lt": "lt",
+      "$lte": "lte"
+    };
+    return mapping[op] || null;
+  }
   finalizeClusterQuery(requestId, timeout = false) {
     const pending = this.pendingClusterQueries.get(requestId);
     if (!pending) return;
@@ -11603,6 +11858,249 @@ var MapWithResolver = class {
     return this.map.prune(olderThan);
   }
 };
+
+// src/config/IndexConfig.ts
+var DEFAULT_INDEX_CONFIG = {
+  autoIndex: false,
+  maxAutoIndexesPerMap: 10,
+  maps: [],
+  logStats: false,
+  statsLogInterval: 6e4
+};
+function validateIndexConfig(config) {
+  const errors = [];
+  if (config.maxAutoIndexesPerMap !== void 0) {
+    if (typeof config.maxAutoIndexesPerMap !== "number" || config.maxAutoIndexesPerMap < 1) {
+      errors.push("maxAutoIndexesPerMap must be a positive number");
+    }
+  }
+  if (config.statsLogInterval !== void 0) {
+    if (typeof config.statsLogInterval !== "number" || config.statsLogInterval < 1e3) {
+      errors.push("statsLogInterval must be at least 1000ms");
+    }
+  }
+  if (config.maps) {
+    const mapNames = /* @__PURE__ */ new Set();
+    for (const mapConfig of config.maps) {
+      if (!mapConfig.mapName || typeof mapConfig.mapName !== "string") {
+        errors.push("Each map config must have a valid mapName");
+        continue;
+      }
+      if (mapNames.has(mapConfig.mapName)) {
+        errors.push(`Duplicate map config for: ${mapConfig.mapName}`);
+      }
+      mapNames.add(mapConfig.mapName);
+      if (!Array.isArray(mapConfig.indexes)) {
+        errors.push(`Map ${mapConfig.mapName}: indexes must be an array`);
+        continue;
+      }
+      const attrNames = /* @__PURE__ */ new Set();
+      for (const indexDef of mapConfig.indexes) {
+        if (!indexDef.attribute || typeof indexDef.attribute !== "string") {
+          errors.push(`Map ${mapConfig.mapName}: index must have valid attribute`);
+          continue;
+        }
+        if (!["hash", "navigable"].includes(indexDef.type)) {
+          errors.push(
+            `Map ${mapConfig.mapName}: index type must be 'hash' or 'navigable'`
+          );
+        }
+        if (indexDef.comparator && !["number", "string", "date"].includes(indexDef.comparator)) {
+          errors.push(
+            `Map ${mapConfig.mapName}: comparator must be 'number', 'string', or 'date'`
+          );
+        }
+        const key = `${indexDef.attribute}:${indexDef.type}`;
+        if (attrNames.has(key)) {
+          errors.push(
+            `Map ${mapConfig.mapName}: duplicate ${indexDef.type} index on ${indexDef.attribute}`
+          );
+        }
+        attrNames.add(key);
+      }
+    }
+  }
+  return errors;
+}
+function mergeWithDefaults(userConfig) {
+  return {
+    ...DEFAULT_INDEX_CONFIG,
+    ...userConfig,
+    maps: userConfig.maps ?? DEFAULT_INDEX_CONFIG.maps
+  };
+}
+
+// src/config/MapFactory.ts
+var import_core19 = require("@topgunbuild/core");
+var MapFactory = class {
+  /**
+   * Create a MapFactory.
+   *
+   * @param config - Server index configuration
+   */
+  constructor(config) {
+    this.config = mergeWithDefaults(config ?? {});
+    this.mapConfigs = /* @__PURE__ */ new Map();
+    for (const mapConfig of this.config.maps ?? []) {
+      this.mapConfigs.set(mapConfig.mapName, mapConfig);
+    }
+  }
+  /**
+   * Create an LWWMap or IndexedLWWMap based on configuration.
+   *
+   * @param mapName - Name of the map
+   * @param hlc - Hybrid Logical Clock instance
+   * @returns LWWMap or IndexedLWWMap depending on configuration
+   */
+  createLWWMap(mapName, hlc) {
+    const mapConfig = this.mapConfigs.get(mapName);
+    if (!mapConfig || mapConfig.indexes.length === 0) {
+      return new import_core19.LWWMap(hlc);
+    }
+    const map = new import_core19.IndexedLWWMap(hlc);
+    for (const indexDef of mapConfig.indexes) {
+      this.addIndexToLWWMap(map, indexDef);
+    }
+    return map;
+  }
+  /**
+   * Create an ORMap or IndexedORMap based on configuration.
+   *
+   * @param mapName - Name of the map
+   * @param hlc - Hybrid Logical Clock instance
+   * @returns ORMap or IndexedORMap depending on configuration
+   */
+  createORMap(mapName, hlc) {
+    const mapConfig = this.mapConfigs.get(mapName);
+    if (!mapConfig || mapConfig.indexes.length === 0) {
+      return new import_core19.ORMap(hlc);
+    }
+    const map = new import_core19.IndexedORMap(hlc);
+    for (const indexDef of mapConfig.indexes) {
+      this.addIndexToORMap(map, indexDef);
+    }
+    return map;
+  }
+  /**
+   * Add an index to an IndexedLWWMap based on definition.
+   */
+  addIndexToLWWMap(map, indexDef) {
+    const attribute = this.createAttribute(indexDef.attribute);
+    if (indexDef.type === "hash") {
+      map.addHashIndex(attribute);
+    } else if (indexDef.type === "navigable") {
+      const navAttribute = attribute;
+      const comparator = this.createComparator(indexDef.comparator);
+      map.addNavigableIndex(navAttribute, comparator);
+    }
+  }
+  /**
+   * Add an index to an IndexedORMap based on definition.
+   */
+  addIndexToORMap(map, indexDef) {
+    const attribute = this.createAttribute(indexDef.attribute);
+    if (indexDef.type === "hash") {
+      map.addHashIndex(attribute);
+    } else if (indexDef.type === "navigable") {
+      const navAttribute = attribute;
+      const comparator = this.createComparator(indexDef.comparator);
+      map.addNavigableIndex(navAttribute, comparator);
+    }
+  }
+  /**
+   * Create an Attribute for extracting values from records.
+   * Supports dot notation for nested paths.
+   */
+  createAttribute(path) {
+    return (0, import_core19.simpleAttribute)(path, (record) => {
+      return this.getNestedValue(record, path);
+    });
+  }
+  /**
+   * Get a nested value from an object using dot notation.
+   *
+   * @param obj - Object to extract value from
+   * @param path - Dot-notation path (e.g., "user.email")
+   * @returns Value at the path or undefined
+   */
+  getNestedValue(obj, path) {
+    if (obj === null || obj === void 0) {
+      return void 0;
+    }
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === void 0 || current === null) {
+        return void 0;
+      }
+      if (typeof current !== "object") {
+        return void 0;
+      }
+      current = current[part];
+    }
+    return current;
+  }
+  /**
+   * Create a comparator function for navigable indexes.
+   */
+  createComparator(type) {
+    switch (type) {
+      case "number":
+        return (a, b) => {
+          const numA = typeof a === "number" ? a : parseFloat(String(a));
+          const numB = typeof b === "number" ? b : parseFloat(String(b));
+          return numA - numB;
+        };
+      case "date":
+        return (a, b) => {
+          const dateA = new Date(a).getTime();
+          const dateB = new Date(b).getTime();
+          return dateA - dateB;
+        };
+      case "string":
+        return (a, b) => {
+          const strA = String(a);
+          const strB = String(b);
+          return strA.localeCompare(strB);
+        };
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Check if a map should be indexed based on configuration.
+   *
+   * @param mapName - Name of the map
+   * @returns true if map has index configuration
+   */
+  hasIndexConfig(mapName) {
+    const config = this.mapConfigs.get(mapName);
+    return config !== void 0 && config.indexes.length > 0;
+  }
+  /**
+   * Get index configuration for a map.
+   *
+   * @param mapName - Name of the map
+   * @returns Map index config or undefined
+   */
+  getMapConfig(mapName) {
+    return this.mapConfigs.get(mapName);
+  }
+  /**
+   * Get all configured map names.
+   *
+   * @returns Array of map names with index configuration
+   */
+  getConfiguredMaps() {
+    return Array.from(this.mapConfigs.keys());
+  }
+  /**
+   * Get the full server index configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferPool,
@@ -11613,6 +12111,7 @@ var MapWithResolver = class {
   ConnectionRateLimiter,
   DEFAULT_CLUSTER_COORDINATOR_CONFIG,
   DEFAULT_CONFLICT_RESOLVER_CONFIG,
+  DEFAULT_INDEX_CONFIG,
   DEFAULT_JOURNAL_SERVICE_CONFIG,
   DEFAULT_LAG_TRACKER_CONFIG,
   DEFAULT_SANDBOX_CONFIG,
@@ -11623,6 +12122,7 @@ var MapWithResolver = class {
   IteratorTasklet,
   LagTracker,
   LockManager,
+  MapFactory,
   MapTasklet,
   MapWithResolver,
   MemoryServerAdapter,
@@ -11653,10 +12153,12 @@ var MapWithResolver = class {
   getNativeStats,
   logNativeStatus,
   logger,
+  mergeWithDefaults,
   setGlobalBufferPool,
   setGlobalEventPayloadPool,
   setGlobalMessagePool,
   setGlobalRecordPool,
-  setGlobalTimestampPool
+  setGlobalTimestampPool,
+  validateIndexConfig
 });
 //# sourceMappingURL=index.js.map