@lowdefy/connection-elasticsearch 4.0.0-alpha.1

package/dist/connections/Elasticsearch/ElasticsearchIndex/ElasticsearchIndex.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { Client } from '@elastic/elasticsearch';
+async function elasticsearchIndex({ request , connection  }) {
+    const client = new Client(connection);
+    const body = {
+        ...request,
+        index: request.index || connection.index
+    };
+    const { body: response  } = await client.index(body);
+    return {
+        response,
+        id: response._id
+    };
+}
+export default elasticsearchIndex;

package/dist/connections/Elasticsearch/ElasticsearchIndex/ElasticsearchIndex.json

@@ -0,0 +1,100 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Lowdefy Request Schema - ElasticsearchIndex",
+    "type": "object",
+    "description": "Adds a JSON document to the specified data stream or index and makes it searchable. If the target is an index and the document already exists, the request updates the document and increments its version.",
+    "required": [
+        "body"
+    ],
+    "properties": {
+        "id": {
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "number"
+                }
+            ],
+            "description": "Unique identifier for the document."
+        },
+        "index": {
+            "type": "string",
+            "description": "The name of the index."
+        },
+        "if_seq_no": {
+            "type": "integer",
+            "description": "Only perform the operation if the document has this sequence number. See Optimistic concurrency control."
+        },
+        "if_primary_term": {
+            "type": "integer",
+            "description": "Only perform the operation if the document has this primary term. See Optimistic concurrency control."
+        },
+        "op_type": {
+            "type": "string",
+            "description": "Set to create to only index the document if it does not already exist (put if absent). If a document with the specified _id already exists, the indexing operation will fail. Same as using the <index>/_create endpoint. Valid values: index, create. If document id is specified, it defaults to index. Otherwise, it defaults to create. If the request targets a data stream, an op_type of create is required. See Add documents to a data stream.",
+            "enum": [
+                "index",
+                "create"
+            ],
+            "default": "create"
+        },
+        "pipeline": {
+            "type": "string",
+            "description": "ID of the pipeline to use to preprocess incoming documents."
+        },
+        "refresh": {
+            "type": "string",
+            "description": "If true, Elasticsearch refreshes the affected shards to make this operation visible to search, if wait_for then wait for a refresh to make this operation visible to search, if false do nothing with refreshes. Valid values: true, false, wait_for. Default: false.",
+            "enum": [
+                "true",
+                "false",
+                "wait_for"
+            ],
+            "default": false
+        },
+        "routing": {
+            "description": "Custom value used to route operations to a specific shard.",
+            "type": "string"
+        },
+        "timeout": {
+            "type": "string",
+            "description": "Period the request waits for the following operations:\n\nAutomatic index creation\nDynamic mapping updates\nWaiting for active shards\nDefaults to 1m (one minute). This guarantees Elasticsearch waits for at least the timeout before failing. The actual wait time could be longer, particularly when multiple waits occur.",
+            "default": "1m"
+        },
+        "version": {
+            "description": "Explicit version number for concurrency control. The specified version must match the current version of the document for the request to succeed.",
+            "type": "integer"
+        },
+        "version_type": {
+            "type": "string",
+            "description": "Specific version type: external, external_gte.",
+            "enum": [
+                "internal",
+                "external",
+                "external_gte"
+            ]
+        },
+        "wait_for_active_shard": {
+            "type": "string",
+            "description": "The number of shard copies that must be active before proceeding with the operation. Set to all or any positive integer up to the total number of shards in the index (number_of_replicas+1). Default: 1, the primary shard.",
+            "default": "1"
+        },
+        "require_alias": {
+            "type": "boolean",
+            "description": "If true, the destination must be an index alias. Defaults to false.",
+            "default": false
+        },
+        "body": {
+            "type": "object",
+            "description": "Request body contains the JSON source for the document data.",
+            "additionalProperties": true
+        }
+    },
+    "errorMessage": {
+        "type": "ElasticsearchIndex request properties should be an object.",
+        "required": {
+            "body": "ElasticsearchIndex request should have required property \"body\"."
+        }
+    }
+}

package/dist/connections/Elasticsearch/ElasticsearchIndex/index.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ export default {
+    import: {
+        path: 'connections/Elasticsearch/ElasticsearchIndex/ElasticsearchIndex.js',
+        schema: 'connections/Elasticsearch/ElasticsearchIndex/ElasticsearchIndex.json'
+    },
+    meta: {
+        checkRead: false,
+        checkWrite: true
+    }
+};

package/dist/connections/Elasticsearch/ElasticsearchSchema.json

@@ -0,0 +1,457 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Lowdefy Connection Schema - Elasticsearch",
+    "type": "object",
+    "properties": {
+        "node": {
+            "description": "The Elasticsearch endpoint to use. It can be a single string, an array of strings, or an object (or an array of objects) that represents the node",
+            "examples": [
+                "http://localhost:9200",
+                "https://your.node.company.tld:443"
+            ],
+            "anyOf": [
+                {
+                    "items": {
+                        "type": "string",
+                        "format": "uri",
+                        "pattern": "^(https?)://"
+                    },
+                    "type": "array"
+                },
+                {
+                    "$ref": "#/definitions/NodeOptions"
+                },
+                {
+                    "items": {
+                        "$ref": "#/definitions/NodeOptions"
+                    },
+                    "type": "array"
+                },
+                {
+                    "type": "string",
+                    "format": "uri",
+                    "pattern": "^(https?)://"
+                }
+            ]
+        },
+        "nodes": {
+            "description": "The Elasticsearch endpoint to use. It can be a single string, an array of strings, or an object (or an array of objects) that represents the node",
+            "examples": [
+                {
+                    "url": "http://localhost:9200",
+                    "ssl": "ssl options",
+                    "agent": "http agent options",
+                    "id": "custom node id",
+                    "headers": {
+                        "X-Foo": "Bar"
+                    },
+                    "roles": {
+                        "master": true,
+                        "data": true,
+                        "ingest": true,
+                        "ml": false
+                    }
+                },
+                "http://localhost:9200",
+                "https://your.node.company.tld:443"
+            ],
+            "anyOf": [
+                {
+                    "items": {
+                        "type": "string",
+                        "format": "uri",
+                        "pattern": "^(https?)://"
+                    },
+                    "type": "array"
+                },
+                {
+                    "$ref": "#/definitions/NodeOptions"
+                },
+                {
+                    "items": {
+                        "$ref": "#/definitions/NodeOptions"
+                    },
+                    "type": "array"
+                },
+                {
+                    "type": "string",
+                    "format": "uri",
+                    "pattern": "^(https?)://"
+                }
+            ]
+        },
+        "index": {
+            "description": "Default index to use for requests.",
+            "type": "string"
+        },
+        "auth": {
+            "description": "Your authentication data. You can use both basic authentication and ApiKey.",
+            "examples": [
+                {
+                    "username": "elastic",
+                    "password": "changeMe"
+                },
+                {
+                    "apiKey": "base64EncodedApiKey"
+                }
+            ],
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/ApiKeyAuth"
+                },
+                {
+                    "$ref": "#/definitions/BasicAuth"
+                }
+            ],
+            "errorMessage": {
+                "anyOf": "Elasticsearch connection property \"auth\" should be an object containing credentials"
+            }
+        },
+        "maxRetries": {
+            "description": "Max number of retries for each request.",
+            "type": "number",
+            "default": 3,
+            "minimum": 0
+        },
+        "requestTimeout": {
+            "description": "Max request timeout in milliseconds for each request.",
+            "type": "number",
+            "default": 30000,
+            "exclusiveMinimum": 0
+        },
+        "pingTimeout": {
+            "description": "Max ping request timeout in milliseconds for each request.",
+            "type": "number",
+            "default": 3000,
+            "exclusiveMinimum": 0
+        },
+        "sniffInterval": {
+            "description": "Perform a sniff operation every n milliseconds. Sniffing might not be the best solution for you, take a look here to know more: https://www.elastic.co/blog/elasticsearch-sniffing-best-practices-what-when-why-how",
+            "type": [
+                "number",
+                "boolean"
+            ],
+            "default": false
+        },
+        "sniffOnStart": {
+            "description": "Perform a sniff once the client is started. Sniffing might not be the best solution for you, take a look here to know more: https://www.elastic.co/blog/elasticsearch-sniffing-best-practices-what-when-why-how",
+            "type": "boolean"
+        },
+        "sniffEndpoint": {
+            "description": "Endpoint to ping during a sniff.",
+            "type": "string",
+            "default": "_nodes/_all/http"
+        },
+        "sniffOnConnectionFault": {
+            "description": "Perform a sniff on connection fault. Sniffing might not be the best solution for you, take a look here to know more: https://www.elastic.co/blog/elasticsearch-sniffing-best-practices-what-when-why-how",
+            "type": "boolean",
+            "default": false
+        },
+        "resurrectStrategy": {
+            "description": "Configure the node resurrection strategy.",
+            "enum": [
+                "none",
+                "optimistic",
+                "ping"
+            ],
+            "type": "string",
+            "default": "ping"
+        },
+        "suggestCompression": {
+            "description": "Adds accept-encoding header to every request.",
+            "type": "boolean",
+            "default": false
+        },
+        "compression": {
+            "description": "Enables gzip request body compression.",
+            "enum": [
+                "gzip"
+            ],
+            "type": [
+                "string",
+                "boolean"
+            ],
+            "default": false
+        },
+        "ssl": {
+            "$ref": "#/definitions/ConnectionOptions"
+        },
+        "proxy": {
+            "description": "If you are using an http(s) proxy, you can put its url here. The client will automatically handle the connection to it.",
+            "type": "string",
+            "format": "uri",
+            "pattern": "^(https?)://",
+            "examples": [
+                "http://localhost:8080",
+                "http://user:pwd@localhost:8080"
+            ],
+            "default": null
+        },
+        "agent": {
+            "description": "HTTP agent options. If you want to disable the HTTP agent use entirely (and disable the `keep-alive` feature), set the agent to `false`. See https://nodejs.org/api/http.html#http_new_agent_options.",
+            "default": null,
+            "examples": [
+                {
+                    "agent": "options"
+                },
+                {
+                    "agent": false
+                }
+            ],
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/AgentOptions"
+                },
+                {
+                    "enum": [
+                        false
+                    ],
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
+        },
+        "name": {
+            "description": "The name to identify the client instance in the events.",
+            "type": "string",
+            "default": "elasticsearch-js"
+        },
+        "opaqueIdPrefix": {
+            "description": "A string that will be use to prefix any X-Opaque-Id header. See https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/observability.html#x-opaque-id_support[X-Opaque-Id support] for more details.",
+            "default": null,
+            "type": "string"
+        },
+        "headers": {
+            "description": "A set of custom headers to send in every request.",
+            "examples": [
+                {
+                    "X-Foo": "Bar"
+                }
+            ],
+            "type": "object",
+            "default": { }
+        },
+        "context": {
+            "description": "A custom object that you can use for observability in your events. It will be merged with the API level context option.",
+            "type": "object",
+            "default": null
+        },
+        "enableMetaHeader": {
+            "description": "If true, adds an header named 'x-elastic-client-meta', containing some minimal telemetry data, such as the client and platform version.",
+            "type": "boolean",
+            "default": true
+        },
+        "cloud": {
+            "description": "Custom configuration for connecting to Elastic Cloud. See Authentication for more details: https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/auth-reference.html",
+            "examples": [
+                {
+                    "id": "name:bG9jYWxob3N0JGFiY2QkZWZnaA=="
+                }
+            ],
+            "properties": {
+                "id": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                },
+                "username": {
+                    "type": "string"
+                }
+            },
+            "type": "object",
+            "default": null
+        },
+        "disablePrototypePoisoningProtection": {
+            "description": "By the default the client will protect you against prototype poisoning attacks. If needed you can disable prototype poisoning protection entirely or one of the two checks. Read the `secure-json-parse` documentation to learn more: https://github.com/fastify/secure-json-parse",
+            "enum": [
+                "constructor",
+                false,
+                "proto",
+                true
+            ],
+            "default": false
+        },
+        "read": {
+            "type": "boolean",
+            "default": true,
+            "description": "Allow reads from the Elasticsearch index.",
+            "errorMessage": {
+                "type": "Elasticsearch connection property \"read\" should be a boolean."
+            }
+        },
+        "write": {
+            "type": "boolean",
+            "default": false,
+            "description": "Allow writes to the Elasticsearch index.",
+            "errorMessage": {
+                "type": "Elasticsearch connection property \"write\" should be a boolean."
+            }
+        }
+    },
+    "definitions": {
+        "AgentOptions": {
+            "description": "Set of configurable options to set on the agent.",
+            "properties": {
+                "keepAlive": {
+                    "description": "Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used.",
+                    "default": false,
+                    "type": "boolean"
+                },
+                "keepAliveMsecs": {
+                    "description": "When using the `keepAlive` option, specifies the initial delay for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`",
+                    "type": "number",
+                    "default": 1000
+                },
+                "maxFreeSockets": {
+                    "description": "Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`",
+                    "type": "number",
+                    "default": 256
+                },
+                "maxSockets": {
+                    "description": "Maximum number of sockets to allow per host. If the same host opens multiple concurrent connections, each request will use new socket until the `maxSockets` value is reached. If the host attempts to open more connections than `maxSockets`, the additional requests will enter into a pending request queue, and will enter active connection state when an existing connection terminates. This makes sure there are at most maxSockets active connections at any point in time, from a given host.",
+                    "type": "number",
+                    "default": "Infinity"
+                }
+            },
+            "type": "object"
+        },
+        "ApiKeyAuth": {
+            "description": "The apiKey parameter can be either a base64 encoded string or an object with the values that you can obtain from the create api key endpoint. If you provide both basic authentication credentials and the ApiKey configuration, the ApiKey takes precedence.",
+            "properties": {
+                "apiKey": {
+                    "anyOf": [
+                        {
+                            "properties": {
+                                "api_key": {
+                                    "type": "string"
+                                },
+                                "id": {
+                                    "type": "string"
+                                }
+                            },
+                            "type": "object"
+                        },
+                        {
+                            "type": "string"
+                        }
+                    ],
+                    "errorMessage": {
+                        "anyOf": "Elasticsearch API key should be specified as a string, or an object containing Elasticsearch cloud credentials"
+                    }
+                }
+            },
+            "required": [
+                "apiKey"
+            ],
+            "type": "object"
+        },
+        "BasicAuth": {
+            "properties": {
+                "password": {
+                    "type": "string"
+                },
+                "username": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "username"
+            ],
+            "type": "object",
+            "errorMessage": {
+                "required": "Elasticsearch basic auth credentials must consist of at least a username"
+            }
+        },
+        "ConnectionOptions": {
+            "description": "http.SecureContextOptions - See node.js SSL configuration: https://nodejs.org/api/tls.html",
+            "type": "object",
+            "default": null
+        },
+        "NodeOptions": {
+            "examples": [
+                {
+                    "url": "http://localhost:9200",
+                    "ssl": "ssl options",
+                    "agent": "http agent options",
+                    "id": "custom node id",
+                    "headers": {
+                        "X-Foo": "Bar"
+                    },
+                    "roles": {
+                        "master": true,
+                        "data": true,
+                        "ingest": true,
+                        "ml": false
+                    }
+                }
+            ],
+            "properties": {
+                "agent": {
+                    "$ref": "#/definitions/AgentOptions"
+                },
+                "headers": {
+                    "type": "object",
+                    "examples": [
+                        {
+                            "X-Foo": "Bar"
+                        }
+                    ]
+                },
+                "id": {
+                    "type": "string"
+                },
+                "roles": {
+                    "properties": {
+                        "data": {
+                            "type": "boolean"
+                        },
+                        "ingest": {
+                            "type": "boolean"
+                        },
+                        "master": {
+                            "type": "boolean"
+                        },
+                        "ml": {
+                            "type": "boolean"
+                        }
+                    },
+                    "type": "object"
+                },
+                "ssl": {
+                    "$ref": "#/definitions/ConnectionOptions"
+                },
+                "url": {
+                    "type": "string",
+                    "format": "uri",
+                    "pattern": "^(https?)://"
+                }
+            },
+            "type": "object"
+        }
+    },
+    "oneOf": [
+        {
+            "required": [
+                "node"
+            ]
+        },
+        {
+            "required": [
+                "nodes"
+            ]
+        }
+    ],
+    "errorMessage": {
+        "type": "Elasticsearch connection properties should be an object.",
+        "oneOf": "Elasticsearch connection should have required property \"node\" or \"nodes\".",
+        "properties": {
+            "maxRetries": "Elasticsearch connection \"maxRetries\" should be 0 or greater",
+            "requestTimeout": "Elasticsearch connection \"requestTimeout\" should be 1 or greater",
+            "pingTimeout": "Elasticsearch connection \"pingTimeout\" should be 1 or greater",
+            "index": "Elasticsearch connection property \"index\" should be a string"
+        }
+    }
+}

package/dist/connections/Elasticsearch/ElasticsearchSearch/ElasticsearchSearch.js

@@ -0,0 +1,54 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { Client } from '@elastic/elasticsearch';
+import { get } from '@lowdefy/helpers';
+import schema from './ElasticsearchSearch.json';
+async function elasticsearchSearch({ request , connection  }) {
+    const client = new Client(connection);
+    const { body: response  } = await client.search({
+        ...request,
+        index: request.index || connection.index
+    });
+    const rawHits = get(response, 'hits.hits', {
+        default: []
+    });
+    // Return the actual documents as hits.
+    // Map the documents to a more useful representation in our context:
+    // We return the results in the _source field as the main results
+    // and return all other fields in the _meta field.
+    const hits = rawHits.map((hit)=>{
+        const { _source , ..._meta } = hit;
+        return {
+            ..._source,
+            _meta
+        };
+    });
+    return {
+        response,
+        hits,
+        total: get(response, 'hits.total', {
+            default: {
+            }
+        }),
+        maxScore: get(response, 'hits.max_score', {
+            default: 0
+        }),
+        aggregations: get(response, 'aggregations', {
+            default: {
+            }
+        })
+    };
+}
+export default elasticsearchSearch;