@kumologica/sdk 3.4.0 → 3.5.0-beta2

package/src/app/lib/ai/prompt.txt

@@ -0,0 +1,583 @@
+
+
+As a software developer, your task is to produce a kumologica flow app implementation from a description given by the user at the end.
+The specification of kumologica will be defined as a markdown in a series of rules enclosed by "---" delimiter as follows:
+
+---
+# Specification
+
+
+
+# FLOW RULES
+
+- A kumologica flow app is implemented as a valid json document. Specifically is an array of nodes objects.
+- A kumologica flow app consists of a number of flows, aka "api flows" or simply "api".
+- An api is a collection of nodes connected to each other to form a logic DAG.
+- An api is defined as one node acting as an entry point that will listen for an http request, and an ending node writing an http response. Between the entry and end node, there may be a number of connected nodes.
+- The entry point node of an api is called EventListener, and the ending node is called EventListenerEnd.
+- The EventListener node will filter an http request and it will output a kumologica message.
+- The EventListenerEnd node will accept a kumologica message and it will write an http response.
+- Any other node will accept and emit a kumologica message.
+- A `msg` will visit one node and the message will be send to the node reference in the `wires` property.
+- If not set otherwise, a node will have a maximum number of wires of 1.
+- If more wires is required a `Switch` node must be used. 
+- If a node thrown an error, the error will be set in the msg object and send it to a `Catch` node.
+
+# EXECUTION CONTEXT
+
+- There are three context variables that are available to all nodes: `msg`, `vars`, and `env`. These are all mutable and can be used to store and retrieve temporary data by each node.
+- These variables are encoded as json objects.
+- The following is an example of a `msg` object. Specifically is the structure of the message that an EventListener node will send to the next node in the flow:
+
+```
+{
+    "type": "object"
+    "properties": {
+        "_msgid": {
+            "type": "string",
+                "description": "Unique identifier for each execution of an api within a  kumologica flow app"
+        },
+        "header": {
+            "type": "object",
+            "description": "An object encapsulating the triggering `event` and the `context`,
+            "properties": {
+                "event": {
+                    "type": "object",
+                        "properties": {
+                        "Records": {
+                            "type": "array",
+                                "items": {
+                                "type": "object",
+                                    "properties": {
+                                    "headers": {
+                                        "type": "object",
+                                            "description": "the key-value pairs of an standard http request from nodeJS"
+                                    },
+                                    "httpMethod": {
+                                        "type": "string"
+                                    },
+                                    "path": {
+                                        "type": "string"
+                                    },
+                                    "queryStringParameters": {
+                                        "type": "object"
+                                    }
+                                },
+                                "required": ["headers", "httpMethod", "path", "queryStringParameters"]
+                            }
+                        }
+                    },
+                    "required": ["Records"]
+                },
+                "context": {
+                    "type": "object",
+                        "description": "The execution context depending on the platform that runs the kumologica flow app"
+                }
+
+            }
+        },
+        "payload": {
+            "type": "object",
+                "description": "If available, it will contain the http request body"
+        }
+    }
+}
+```
+
+
+# NODES
+
+- A node can be seen as a partial function, that is defined by a set of properties, and during runtime, it will take a `msg` as input and it will return a `msg` as output.
+
+## PROPERTIES
+
+- Node properties can be of type string, number, array, or dynamic expression.
+- A dynamic expression is a jsonata expression that takes the context variables: `msg`, `vars`, and `env` as bindings. 
+- Valid examples of dynamic expressions are: `msg.payload`, `'Hello ' & vars.name`
+
+## TABS
+
+ - Nodes are arranged in tabs when editing a flow. Each tab is a collection of nodes that are logically grouped together.
+ - A tab will be defined as a special element of the application flow, defined as:
+```
+
+    {
+        "type": "object",
+        "properties": {
+            "id": {
+                "type": "string",
+                "description": "Unique identifier for all nodes within this tab. If not specified use the default: "main.flow"
+            },
+            "type": {
+                "type": "string",
+                "description": "Identifies the node type. Value is "tab"
+            },
+            "label": {
+                "type": "string",
+                "description": "Human readable short label that references this tab and its purpose"
+            },
+            "disabled": {
+                "type": "boolean",
+                "description": "If true, the tab will be disabled. Default value is false"
+            },
+            "info": {
+                "type": "string",
+                "description": "Human readable description of the tab. Not used"
+            }
+        }
+```
+
+- An example of a tab named main would be as follows: 
+```
+
+    {
+        "id": "main.flow",
+        "type": "tab",
+        "label": "main",
+        "disabled": false,
+        "info": ""
+    }
+```
+
+- All nodes in the flow within this tab, will be connected by setting the value of `z` to `main.flow`
+
+
+
+
+## SCHEMA
+
+- The following is a common schema shared by all nodes:
+
+```
+{
+    "type": "object",
+        "properties": {
+        "id": {
+            "type": "string",
+                "description": "Unique identifier for each instance of the node within a flow. This will be autogenerated using UUID".
+        },
+        "type": {
+            "type": "string",
+                "description": "Identifies the node type. It will be defined on each node schema"
+        },
+        "name": {
+            "type": "string",
+                "description": "Human readable short label that references this node and its purpose"
+        },
+        "z": {
+            "type": "string",
+            "description": "the id of the tab where this node is located. If not specified, it will be set to the default tab"
+        }
+        "wires: {
+            "type": "array",
+            "description": "Number of outputs of this node may have. If not specified, the maximum length of this array will be 1"
+            "items": {
+                "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+ }
+```
+
+- kumologica provides an out of the box set of nodes that form the core library.
+- Kumologica allows to third party contributors to implement their own nodes. Each node is a npm project that will follow the convention: `{ account } /kumologica-contrib-{nodeName}`
+
+
+
+# Node Library
+
+Kumologica core library consist of the following nodes:
+
+## General
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node is responsible to listen to an API HTTP request, and filter the incoming event based on the 'method' and 'url' and transform the request into a kumologica message",
+    "properties": {
+      "type": "EventListener",
+      "provider": {
+        "type": "string",
+        "enum": [
+          "aws",
+          "nodejs"
+        ],
+        "description": "what target platform this flow will be deployed. Default: `nodejs`"
+      },
+      "napiMethod": {
+        "type": "string",
+        "enum": [
+          "any",
+          "get",
+          "post",
+          "delete",
+          "patch",
+          "put"
+        ],
+        "description": "The http method that will be implemented. This property is only applicable when provider is `nodejs`"
+      },
+      "apiMethod": {
+        "type": "string",
+        "enum": [
+          "any",
+          "get",
+          "post",
+          "delete",
+          "patch",
+          "put"
+        ],
+        "description": "The http method that will be implemented. This property is only applicable when provider is `aws`"
+      },
+      "apiUrl": {
+        "type": "string",
+        "description": "The path url that this flow will be listening to. This property is only applicable when provider is set to `aws`"
+      },
+      "napiUrl": {
+        "type": "string",
+        "description": "The path url that this flow will be listening to. This property is only applicable when provider is set to `nodejs`"
+      }
+    }
+  },
+  {
+    "type": "object",
+    "description": "This node is responsible to send a http response back to the caller.\n                        The `wires` property will be always set to []",
+    "properties": {
+      "type": "EventListener-End",
+      "statusCode": {
+        "type": "string",
+        "description": "A valid HTTP status code to indicate the outcome of the client's request. JSONata expression is acceptable"
+      },
+      "headers": {
+        "type": "object",
+        "description": "A key-value pair of strings that will be sent with the http response"
+      },
+      "payload": {
+        "type": "string",
+        "description": "this value corresponds with the body section of an http response, JSONata expression is acceptable, but not JS code"
+      }
+    }
+  }
+]
+```
+
+## Transformation
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node executes native nodejs code. Useful when no other node in the core library can be used to produce the output or step desired, or the complexity of configuring a node is too complex compare with js code",
+    "properties": {
+      "type": "Function",
+      "query": {
+        "type": "string",
+        "description": "\nJavascript (nodeJs) code that will be executed.It will take one input: `msg` object, and it will return a `msg` or it will throw an error.\nTo return a `msg` you can type: `node.send(msg)`, and to throw an error: `node.sendError(Error, msg)`;\nthe following variables will be available in the execution context: `msg` (the message received), `vars` (the variable context), and `env` (key-value pair of the environment variables)\nLogging can be added within this property by calling the methods: node.log(\"message\")\nYou can import external libraries with commonJS format.\nFor top level await, the following code needs to be included: \n`(async () => {\n    function delay(ms) {\n        return new Promise(resolve => setTimeout(resolve, ms));\n    }\n    try {\n        await delay(2000);\n        node.send(msg);\n    } catch (error) {\n        node.sendError(error, msg);\n    }\n})(); `\n\nA call to node.sendError will follow the execution to a Catch node, otherwise the flow will terminate with an unhandled error\n\nIf external dependencies are used. Make sure in the final output, they are highlighted following the implementation of the kumologica flow app.\n",
+        "examples": [
+          "const currentTime = new Date();\n\n// Extract the time components\nconst hours = currentTime.getHours();\nconst minutes = currentTime.getMinutes();\nconst seconds = currentTime.getSeconds();\n\n// Format the time\nconst formattedTime = `${ hours }: ${ minutes }: ${ seconds }`;\n\nmsg.payload = formattedTime;\n\nnode.send(msg);\n"
+        ]
+      }
+    }
+  }
+]
+```
+
+## Validation
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node will validate a JSON object against a JSON schema. It uses the npm library Ajv. It will thrown an error `JSONSchemaValError` if the validation fails.\n                        Jumping the execution to a Catch node. This must have exactly one input and one output",
+    "properties": {
+      "type": "json-schema-validator",
+      "Property": {
+        "type": "string",
+        "description": "The json object that we want to validate. It supports a dynamic expression. Default value is \"msg.payload\""
+      },
+      "query": {
+        "type": "string",
+        "description": "The JSON schema used to validate the `Property` json object. \n                AJV formats plugin is not included so any custom format must be implemented using the pattern property\n                Example below check a property called `email` follows the format of a valid email address: \n                \"{\n                    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n                    \"type\": \"object\",\n                    \"properties\": {\n                        \"email\": {\n                            \"type\": \"string\",\n                            \"pattern\": \"^\\S+@\\S+\\.\\S+$\"\n                        }\n                    },\n                    \"required\": [\"email\"]\n                }\"\n            "
+      }
+    }
+  }
+]
+```
+
+## Logging
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node writes a message into the console, useful for debugging purposes or setting some useful information on the console",
+    "properties": {
+      "type": "Logger",
+      "level": {
+        "type": "string",
+        "description": "The level of logging",
+        "enum": [
+          "INFO",
+          "ERROR",
+          "WARN",
+          "DEBUG",
+          "TRACE"
+        ],
+        "default": "INFO"
+      },
+      "message": {
+        "type": "string",
+        "description": "The message to print on the console. If follows a JSONata expression",
+        "examples": [
+          "$sum(msg.payload.Account.Order.Product.(Price * Quantity))"
+        ]
+      }
+    }
+  }
+]
+```
+
+## Web
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node can be used to execute external http requests, any error will be thrown as a HTTPClientError.                         The response received will be place in the msg as follows:                         `msg.http.statusCode` the result code;                         `msg.http.headers` the response headers;                         `msg.http.cookies` the response cookies, and                         `msg.payload` will be the response body",
+    "properties": {
+      "type": "HTTP Req",
+      "method": {
+        "type": "string",
+        "description": "A valid http method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS"
+      },
+      "url": {
+        "type": "string",
+        "description": "The target url expressed as a dynamic expression. Supports dynamic expression"
+      },
+      "ret": {
+        "type": "string",
+        "enum": [
+          "txt",
+          "bin",
+          "obj"
+        ],
+        "description": "\"txt\" to be used if response needs to be encoded as a UTF- 8 string(default ), \"bin\" to treat response as a binary buffer. \"obj\" to parsed the response as a JSON object\""
+      },
+      "responseTimeout": {
+        "type": "string",
+        "description": "Optional, timeout of the http request, before throwing error"
+      },
+      "followRedirect": {
+        "type": "boolean",
+        "description": "Optional. It determines whether the library should automatically follow HTTP redirects. True by default"
+      },
+      "maxRedirects": {
+        "type": "string",
+        "description": "Number of maximum redirects allow before throwing an error"
+      },
+      "headers": {
+        "type": "object",
+        "description": "A key value pair of standard http headers"
+      },
+      "authtype": {
+        "type": "string",
+        "enum": [
+          "none",
+          "basic",
+          "bearer"
+        ],
+        "description": "Type of authentication required. \"none\" no authentication required. \"basic\" basic auth required. \"bearer\" bearer token required"
+      },
+      "secUser": {
+        "type": "string",
+        "description": "the username to be used if \"basic\" authType is selected. Supports dynamic expression"
+      },
+      "secPassword": {
+        "type": "string",
+        "description": "the password ot be used if \"basic\" authType is selected. Supports dynamic expression"
+      },
+      "secToken": {
+        "type": "string",
+        "description": "the token to be used if \"bearer\" authType is selected. Supports dynamic expression"
+      }
+    }
+  }
+]
+```
+
+## Exception
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node will receive all errors thrown by all nodes defined in the `scope` property. Othewise, the error will be cause an early termination of the kumologica flow\n                        The process works as follows:\n                          - A node throws an error.\n                          - An error object is created with the following properties:\n                            - name: The error name\n                            - message: The error message\n                            - source: {\n                                - id: The id of the node that caused the error\n                                - type: The type of the node that caused the error\n                                - name: The name of the node that caused the error\n                            }\n                            An example of the msg with an error on it would be as follows:\n                            ```json\n                            {\n                                \"_msgid\": \"e8fb91dc.46c24\",\n                                \"header\": {},\n                                \"payload\": \"{}\",\n                                \"error: {\n                                    \"name\": \"Error\",\n                                    \"message\": \"Cannot read property 'name' of undefined\",\n                                    \"source\": {\n                                        \"id\": \"a2b2c3d4\",\n                                        \"type\": \"function\",\n                                        \"name\": \"Get Name\",\n                                        \"count\": 1\n                                    }\n                                }\n                            }\n\n        ",
+    "properties": {
+      "type": "catch",
+      "scope": {
+        "type": "array",
+        "description": "The list of node ids that you want to catch the error from.  \n                if value is `null` the catch node will catch all errors thrown by nodes within the same tab, i.e. the same `z` property\"\n                otherwise it will catch only errors thrown by nodes with an id that matches the value of any of the elements in the array"
+      }
+    }
+  }
+]
+```
+
+## Routing
+
+```
+[
+  {
+    "type": "object",
+    "description": "This node will start an iteration over an array of items, each item will be placed on the `msg.payload` and it will be passed to the next node.                         The node will also add some useful metadata of the iteration to the `msg[\"_forEach\"]`                         let iterator = {                             id: App.util.generateId(),                             count: elements.length,                             index: i,                             type: 'array',                             break: false,                             skip: false                         }                         `msg[\"_forEach\"][iterator.id] = iterator;                         `msg[\"_forEach\"]['stack'].push(iterator.id);",
+    "properties": {
+      "type": "ForEach",
+      "array": {
+        "type": "string",
+        "description": "The array that you want to iterate. It supports dynamic expression. Default value is \"msg.payload\" log"
+      }
+    }
+  },
+  {
+    "type": "object",
+    "description": "This node will end the iteration over the forEach. Referring always to the last iterator in the stack.                         If all iterations have been completed, the node will pass in the msg.payload the array of all the msg.payload from each iteration.                         The following code will help to determine the current loop iterator:                         ```javascript                             let stack = msg[\"_foreach\"]['stack']                             let latestIteratorId = stack[stack.length -1]                             return latestIteratorId;                         ```",
+    "properties": {
+      "type": "ForEachEnd"
+    }
+  },
+  {
+    "type": "object",
+    "description": "This node will be found always enclosed between a ForEach and a ForEachEnd node. When encounter the current iterator will be deleted and it will terminate the looping by passing the msg to its connected node. ",
+    "properties": {
+      "type": "ForEachBreak"
+    }
+  },
+  {
+    "type": "object",
+    "description": "This node will be used to create conditional routes, based on predicate. Unlike other nodes, the number of outputs (aka. wires) will depend on the number of different conditional routes defined",
+    "properties": {
+      "type": "Switch",
+      "outputs": {
+        "type": "number",
+        "description": "number of rules defined on the property `rules`"
+      },
+      "property": {
+        "type": "string",
+        "description": "The condition predicated encoded as a dynamic expression to be evaluated."
+      },
+      "rules": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "description": "Each item correspond with a possible route or condition that the predicate will be matched",
+          "properties": {
+            "t": {
+              "type": "string",
+              "enum": [
+                "eq",
+                "neq",
+                "lt",
+                "lte",
+                "gt",
+                "gte",
+                "btwn",
+                "cont",
+                "regex",
+                "true",
+                "false",
+                "null",
+                "nnull",
+                "isType",
+                "empty",
+                "nempty",
+                "else"
+              ],
+              "description": "\nThe predicate operators. Each one will be evaluated in a nodejs environment as per the following implementation: In all cases, `a` corresponds with the value of the evaluated expression of `property`, and `b`, if present, with the value of the rule property: `v` ```javascript     eq: function(a, b) { return a === b; },     neq: function (a, b) { return a !== b; },     lt: function (a, b) { return a < b; },     lte: function (a, b) { return a <= b; },     gt: function (a, b) { return a > b; },     gte: function (a, b) { return a >= b; },     btwn: function (a, b, c) { return a >= b && a <= c; },     cont: function (a, b) { return (a + '').indexOf(b) != -1; },     regex: function (a, b, c, d) { return (a + '').match(new RegExp(b, d ? 'i' : '')); },     true: function (a) { return a === true; },     false: function (a) { return a === false; },     null: function (a) { return typeof a == 'undefined' || a === null; },     nnull: function (a) { return typeof a != 'undefined' && a !== null; },     empty: function (a) { return isEmpty(a); },     nempty: function (a) { return !isEmpty(a); },     istype: function (a, b) { \n        if (b === 'array') { \n            return Array.isArray(a); \n        } else if (b === 'buffer') {\n            return Buffer.isBuffer(a);\n        } else if (b === 'json') {\n            try {\n                JSON.parse(a);\n                return true;\n            } catch (e) {\n                // or maybe ??? a !== null; }\n                return false;\n            }\n        } else if (b === 'null') {\n            return a === null;\n        } else {\n            return (\n                typeof a === b &&\n                !Array.isArray(a) &&\n                !Buffer.isBuffer(a) &&\n                a !== null\n            );\n        }\n    },\n    else: function (a) { return a === true; }\n```\n"
+            },
+            "v": {
+              "type": "string",
+              "description": "The value that you want to compare in the predicate function"
+            },
+            "vt": {
+              "type": "string",
+              "enum": [
+                "str",
+                "num",
+                "camsg",
+                "cavars",
+                "caenv"
+              ],
+              "description": "the type of the value `v`. if `str` it will be treated as a string, if `num` it will be converted to a js number before executing the predicate, if `camsg`, `cavars`, or `caenv` it will interpolate first the value from the context variables: `msg`, `vars` and `env` respectively"
+            }
+          }
+        }
+      }
+    }
+  }
+]
+```
+
+# Examples
+
+For better understanding, here are some examples of how the flow should be implemented.
+
+```
+[
+  {
+    "prompt": "Create a service that listens to /hello. and responds with a \"hello {user}\". Given user is passed as a query parameter.",
+    "completion": {
+      "flow": "[{\"id\":\"main.flow\",\"type\":\"tab\",\"label\":\"main\",\"disabled\":false,\"info\":\"\"},{\"id\":\"eacbb9ef.69d5c8\",\"type\":\"EventListener\",\"z\":\"main.flow\",\"name\":\"GET /hello\",\"provider\":\"aws\",\"eventSource\":\"api\",\"apiMethod\":\"get\",\"apiUrl\":\"/hello\",\"wires\":[[\"b5fc6ccd.17dd7\"]]},{\"id\":\"b5fc6ccd.17dd7\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Success\",\"statusCode\":\"200\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain \"},\"payload\":\"'Hello ' & msg.header.event.Records[0].queryStringParameters.name\",\"wires\":[]}]"
+    }
+  },
+  {
+    "prompt": "Create a service that listens to /uuid, and it returns a json with a random uuid in the property \"id\".",
+    "completion": {
+      "flow": "[{\"id\":\"main.flow\",\"type\":\"tab\",\"label\":\"main\",\"disabled\":false,\"info\":\"\"},{\"id\":\"eacbb9ef.69d5c8\",\"type\":\"EventListener\",\"z\":\"main.flow\",\"name\":\"GET /uuid\",\"provider\":\"nodejs\",\"neventSource\":\"napi\",\"napiMethod\":\"get\",\"napiUrl\":\"/uuid\",\"wires\":[[\"d15f2025.71a9c\"]]},{\"id\":\"d15f2025.71a9c\",\"type\":\"Function\",\"z\":\"main.flow\",\"name\":\"UUID Gen\",\"query\":\"\\\"\\\\nconst currentTime = new Date();\\\\n// Extract the time components\\\\nconst hours = currentTime.getHours();\\\\nconst minutes = currentTime.getMinutes();\\\\nconst seconds = currentTime.getSeconds();\\\\n\\\\n// Format the time\\\\nconst formattedTime = ${hours}: ${minutes}: ${seconds};\\\\nmsg.payload = formattedTime;\\\\nnode.send(msg);\\\\n\\\"\",\"wires\":[[\"b5fc6ccd.17dd7\"]]},{\"id\":\"b5fc6ccd.17dd7\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Success\",\"statusCode\":\"200\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"application/json\"},\"payload\":\"{ \\\"id\\\": msg.payload }\",\"wires\":[]}]"
+    }
+  },
+  {
+    "prompt": "Create an api that takes the body of a post request, compress it and returns it in the responses body",
+    "completion": {
+      "flow": "[{\"id\":\"main.flow\",\"type\":\"tab\",\"label\":\"main\",\"disabled\":false,\"info\":\"\"},{\"id\":\"eacbb9ef.69d5c8\",\"type\":\"EventListener\",\"z\":\"main.flow\",\"name\":\"POST /compress\",\"provider\":\"nodejs\",\"neventSource\":\"napi\",\"napiMethod\":\"post\",\"napiUrl\":\"/compress\",\"wires\":[[\"c5b3b6a8.edecf8\"]]},{\"id\":\"c5b3b6a8.edecf8\",\"type\":\"Function\",\"z\":\"main.flow\",\"name\":\"Compress\",\"query\":\"const zlib = require('zlib');\\n\\n// Compress the message\\nzlib.deflate(msg.payload, (err, buffer) => {\\n    if (!err) {\\n        node.payload(buffer.toString('base64'));\\n    } else {\\n        node.sendError(err, msg)\\n    }\\n});\\n\\n\",\"wires\":[[\"b5fc6ccd.17dd7\"]]},{\"id\":\"b5fc6ccd.17dd7\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Success\",\"statusCode\":\"200\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain\"},\"payload\":\"msg.payload\",\"wires\":[]}]",
+      "dependencies": "zlib"
+    }
+  },
+  {
+    "prompt": "Create an API that may take an optional query parameter. If present returns the value in the body, otherwise return a 404 error message saying query parameter not present",
+    "completion": {
+      "flow": "[{\"id\":\"main.flow\",\"type\":\"tab\",\"label\":\"main\",\"disabled\":false,\"info\":\"\"},{\"id\":\"eacbb9ef.69d5c8\",\"type\":\"EventListener\",\"z\":\"main.flow\",\"name\":\"GET /exists\",\"provider\":\"nodejs\",\"neventSource\":\"napi\",\"napiMethod\":\"get\",\"napiUrl\":\"/exists\",\"wires\":[[\"c5b3b6a8.edecf8\"]]},{\"id\":\"c5b3b6a8.edecf8\",\"type\":\"Switch\",\"z\":\"main.flow\",\"name\":\"Check Query Param\",\"property\":\"msg.header.event.Records[0].queryStringParameters.name\",\"rules\":[{\"t\":\"nnull\"},{\"t\":\"else\"}],\"outputs\":2,\"wires\":[[\"b5fc6ccd.17dd7\"],[\"71be33d8.aaeccc\"]],\"caname\":\"switch\",\"category\":\"routing\"},{\"id\":\"b5fc6ccd.17dd7\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Success\",\"statusCode\":\"200\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain \"},\"payload\":\"msg.header.event.Records[0].queryStringParameters.name\",\"wires\":[]},{\"id\":\"71be33d8.aaeccc\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Fail\",\"statusCode\":\"404\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain \"},\"payload\":\"Query parameter not present\",\"wires\":[]}]"
+    }
+  },
+  {
+    "prompt": "create a lambda that takes a json object from the body with following mandatory properties:  name, age and email.  If any property is missing return a 404 saying validation error found, otherwise return ok saying all ok",
+    "completion": {
+      "flow": "[{\"id\":\"2f512264.34355e\",\"type\":\"EventListener\",\"z\":\"main.flow\",\"name\":\"POST validate\",\"provider\":\"aws\",\"eventSource\":\"api\",\"apiMethod\":\"post\",\"apiUrl\":\"/validate\",\"albMethod\":\"any\",\"wires\":[[\"9099c5aa.a663b8\"]]},{\"id\":\"9099c5aa.a663b8\",\"type\":\"json-schema-validator\",\"z\":\"main.flow\",\"name\":\"JSON Validator\",\"Property\":\"msg.payload\",\"query\":\"{\\n    \\\"type\\\": \\\"object\\\",\\n    \\\"required\\\": [\\\"name\\\", \\\"age\\\", \\\"email\\\"],\\n    \\\"properties\\\": {\\n        \\\"name\\\": {\\n            \\\"type\\\": \\\"string\\\"\\n        },\\n        \\\"age\\\": {\\n            \\\"type\\\": \\\"number\\\"\\n        },\\n        \\\"email\\\": {\\n            \\\"type\\\": \\\"string\\\"\\n        }\\n    }\\n}\",\"wires\":[[\"b008d04a.5a375\"]]},{\"id\":\"5947f75.b3fa708\",\"type\":\"catch\",\"z\":\"main.flow\",\"name\":\"catch\",\"scope\":null,\"uncaught\":false,\"wires\":[[\"717c3f8a.50186\"]]},{\"id\":\"b008d04a.5a375\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Return OK\",\"statusCode\":\"200\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain \"},\"payload\":\"All ok\",\"eventType\":\"success\",\"wires\":[]},{\"id\":\"717c3f8a.50186\",\"type\":\"EventListener-End\",\"z\":\"main.flow\",\"name\":\"Return Error\",\"statusCode\":\"404\",\"responseType\":\"http\",\"headers\":{\"Content-Type\":\"text/plain \"},\"payload\":\"Validation error found\",\"eventPayload\":\"\",\"eventType\":\"success\",\"wires\":[]}]"
+    }
+  }
+]
+```
+
+---
+
+Considering the above provided specification, generate a response with the following structure:
+{
+    "type": "object",
+    "properties": {
+        "flow": {
+            "type": "string",
+            "description": 'kumologica flow app in valid json format. Do not escape new lines or quotes '
+        },
+        "dependencies": {
+            "type": "string",
+            "description": "Comma separated list of external dependencies used in the flow. Optional"
+        },
+        "explanation": {
+            "type": "string",
+            "description": "Used when user asked specifically for an explanation. Optional"
+        }
+    }
+}
+

package/src/app/lib/aws/ca-cloudwatch-api.js

@@ -1,9 +1,7 @@
-const AWS = require('aws-sdk');
 
 class AWSCloudWatch {
 
-  constructor(log) {
-    this.cwLogs = new AWS.CloudWatchLogs();
+  constructor(config, log) {
     this.logger = log; 
   }
 
@@ -66,13 +64,7 @@ class AWSCloudWatch {
     }, 900000);
   }
 
-  async listLogGroups() {
-    var logs = await this.cwLogs.describeLogGroups({}).promise();
-    
-    return logs.logGroups.map(function(v) { 
-      return {id: v.arn, name: v.logGroupName, arn: v.arn};
-    });
-  }
+ 
 }
 
 module.exports = AWSCloudWatch;

package/src/app/lib/aws/ca-dynamodb-api.js

@@ -1,14 +1,9 @@
-const AWS = require('aws-sdk');
-
-/*
- * AWS JS API:
- * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html
- */
 class CADynamoDb {
   
-  constructor(log) {
+  constructor(config, log) {
     this.log = log; 
-    this.dynamodbstreams = new AWS.DynamoDBStreams();
+    const { DynamoDBStreamsClient } = require("@aws-sdk/client-dynamodb-streams"); 
+    this.dynamodbstreams = new DynamoDBStreamsClient(config);
   }
 
   /**
@@ -16,9 +11,10 @@ class CADynamoDb {
    */
   async listStreams() {
    
-    const streams = await this.dynamodbstreams.listStreams({}).promise();
+    const { ListStreamsCommand } = require("@aws-sdk/client-dynamodb-streams"); 
+    const streams = await this.dynamodbstreams.send(new ListStreamsCommand({}));
     
-    return streams.Streams.map(function(v) {   
+    return streams.Streams.map(v => {   
       return {id: v.StreamArn, name: v.TableName, arn: v.StreamArn};
     });
   }