@toxplanet/pegasus-sdk 1.0.1 → 1.1.0

package/lib/elasticsearch.js

@@ -0,0 +1,404 @@
+class ElasticsearchService {
+  constructor(connection) {
+    this.connection = connection;
+    this.indexRoutes = new Map();
+  }
+
+  /**
+   * Returns an Elasticsearch client interface that routes operations through registered handlers.
+   * This method provides compatibility with legacy elasticsearch client usage patterns.
+   * @returns {ElasticsearchService} The service instance itself, which implements the client interface
+   */
+  client() {
+    return this;
+  }
+
+  registerIndexRoute(indexPattern, handler) {
+    this.indexRoutes.set(indexPattern, handler);
+  }
+
+  getRouteHandler(indexName) {
+    for (const [pattern, handler] of this.indexRoutes.entries()) {
+      if (typeof pattern === 'string' && indexName === pattern) {
+        return handler;
+      }
+      if (pattern instanceof RegExp && pattern.test(indexName)) {
+        return handler;
+      }
+    }
+    return null;
+  }
+
+
+  // example flow:
+  // external application
+    // 1. initialize the sdk
+    // 2. call elastic search search
+    // 3. sdk will call the appropriate handler based on the index name
+    // 4. handler will be called with the appropriate parameters
+    // 5. handler will return the result
+    // 6. sdk will return the result to the external application
+
+  async search(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.search) {
+      return await handler.search(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async msearch(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.msearch) {
+      return await handler.msearch(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async index(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.index) {
+      return await handler.index(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async bulk(params) {
+    const operations = params.body || params.operations;
+    if (!Array.isArray(operations) || operations.length === 0) {
+      throw new Error('Bulk operations must be a non-empty array');
+    }
+
+    const firstOp = operations[0];
+    const indexName = firstOp?.index?._index || firstOp?.index?.index || firstOp?.create?._index || firstOp?.create?.index || params.index;
+    
+    if (!indexName) {
+      throw new Error('Could not determine index from bulk operations');
+    }
+
+    const handler = this.getRouteHandler(indexName);
+    if (handler && handler.bulk) {
+      return await handler.bulk(params);
+    }
+    throw new Error(`No handler registered for index: ${indexName}`);
+  }
+
+  async get(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.get) {
+      return await handler.get(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async mget(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.mget) {
+      return await handler.mget(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async update(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.update) {
+      return await handler.update(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async updateByQuery(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.updateByQuery) {
+      return await handler.updateByQuery(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async delete(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.delete) {
+      return await handler.delete(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async deleteByQuery(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.deleteByQuery) {
+      return await handler.deleteByQuery(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async exists(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.exists) {
+      return await handler.exists(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async count(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.count) {
+      return await handler.count(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async scroll(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.scroll) {
+      return await handler.scroll(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async clearScroll(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.clearScroll) {
+      return await handler.clearScroll(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async reindex(params) {
+    const sourceIndex = params.body?.source?.index;
+    const destIndex = params.body?.dest?.index;
+    
+    const handler = this.getRouteHandler(destIndex || sourceIndex);
+    if (handler && handler.reindex) {
+      return await handler.reindex(params);
+    }
+    throw new Error(`No handler registered for index: ${destIndex || sourceIndex}`);
+  }
+
+  indices() {
+    return {
+      create: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.create) {
+          return await handler.indices.create(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      delete: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.delete) {
+          return await handler.indices.delete(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      exists: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.exists) {
+          return await handler.indices.exists(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      refresh: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.refresh) {
+          return await handler.indices.refresh(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      flush: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.flush) {
+          return await handler.indices.flush(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putMapping: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putMapping) {
+          return await handler.indices.putMapping(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getMapping: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getMapping) {
+          return await handler.indices.getMapping(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putSettings: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putSettings) {
+          return await handler.indices.putSettings(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getSettings: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getSettings) {
+          return await handler.indices.getSettings(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      stats: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.stats) {
+          return await handler.indices.stats(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      get: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.get) {
+          return await handler.indices.get(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putAlias) {
+          return await handler.indices.putAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      deleteAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.deleteAlias) {
+          return await handler.indices.deleteAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getAlias) {
+          return await handler.indices.getAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      analyze: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.analyze) {
+          return await handler.indices.analyze(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      close: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.close) {
+          return await handler.indices.close(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      open: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.open) {
+          return await handler.indices.open(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      }
+    };
+  }
+
+  cat() {
+    return {
+      indices: async (params) => {
+        throw new Error('cat.indices not implemented');
+      },
+      health: async (params) => {
+        throw new Error('cat.health not implemented');
+      },
+      count: async (params) => {
+        throw new Error('cat.count not implemented');
+      },
+      aliases: async (params) => {
+        throw new Error('cat.aliases not implemented');
+      }
+    };
+  }
+
+  cluster() {
+    return {
+      health: async (params) => {
+        throw new Error('cluster.health not implemented');
+      },
+      stats: async (params) => {
+        throw new Error('cluster.stats not implemented');
+      },
+      putSettings: async (params) => {
+        throw new Error('cluster.putSettings not implemented');
+      },
+      getSettings: async (params) => {
+        throw new Error('cluster.getSettings not implemented');
+      }
+    };
+  }
+
+  async ping() {
+    return true;
+  }
+
+  async info() {
+    return {
+      name: 'pegasus-sdk',
+      version: '1.0.0',
+      cluster_name: 'pegasus'
+    };
+  }
+
+  async explain(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.explain) {
+      return await handler.explain(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async termvectors(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.termvectors) {
+      return await handler.termvectors(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async mtermvectors(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.mtermvectors) {
+      return await handler.mtermvectors(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async searchTemplate(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.searchTemplate) {
+      return await handler.searchTemplate(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async renderSearchTemplate(params) {
+    throw new Error('renderSearchTemplate not implemented');
+  }
+
+  async fieldCaps(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.fieldCaps) {
+      return await handler.fieldCaps(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async rankEval(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.rankEval) {
+      return await handler.rankEval(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async scriptsPainlessExecute(params) {
+    throw new Error('scriptsPainlessExecute not implemented');
+  }
+}
+
+module.exports = ElasticsearchService;