@cloudnux/cli 0.1.0 → 0.11.0

package/dist/schema/entrypoint.schema.json

@@ -45,6 +45,89 @@
                 "options"
             ]
         },
+        "FilterCondition": {
+            "oneOf": [
+                {
+                    "type": [
+                        "string",
+                        "number",
+                        "boolean",
+                        "null"
+                    ]
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "$eq": {},
+                        "$ne": {},
+                        "$gt": {
+                            "type": [
+                                "number",
+                                "string"
+                            ]
+                        },
+                        "$gte": {
+                            "type": [
+                                "number",
+                                "string"
+                            ]
+                        },
+                        "$lt": {
+                            "type": [
+                                "number",
+                                "string"
+                            ]
+                        },
+                        "$lte": {
+                            "type": [
+                                "number",
+                                "string"
+                            ]
+                        },
+                        "$in": {
+                            "type": "array"
+                        },
+                        "$nin": {
+                            "type": "array"
+                        },
+                        "$all": {
+                            "type": "array"
+                        },
+                        "$size": {
+                            "type": "number"
+                        },
+                        "$regex": {
+                            "type": "string"
+                        },
+                        "$startsWith": {
+                            "type": "string"
+                        },
+                        "$endsWith": {
+                            "type": "string"
+                        },
+                        "$contains": {
+                            "type": "string"
+                        },
+                        "$exists": {
+                            "type": "boolean"
+                        },
+                        "$type": {
+                            "type": "string",
+                            "enum": [
+                                "string",
+                                "number",
+                                "boolean",
+                                "object",
+                                "array",
+                                "null",
+                                "undefined"
+                            ]
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
         "ScheduleTrigger": {
             "type": "object",
             "properties": {
@@ -53,10 +136,191 @@
                     "properties": {
                         "pattern": {
                             "type": "string"
+                        },
+                        "name": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "pattern",
+                        "name"
+                    ],
+                    "additionalProperties": false
+                }
+            },
+            "required": [
+                "options"
+            ]
+        },
+        "EventTrigger": {
+            "type": "object",
+            "properties": {
+                "options": {
+                    "type": "object",
+                    "properties": {
+                        "source": {
+                            "type": "string"
+                        },
+                        "sourceType": {
+                            "type": "string"
+                        },
+                        "filter": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "oneOf": [
+                                    {
+                                        "type": [
+                                            "string",
+                                            "number",
+                                            "boolean",
+                                            "null"
+                                        ]
+                                    },
+                                    {
+                                        "type": "object",
+                                        "properties": {
+                                            "$eq": {},
+                                            "$ne": {},
+                                            "$gt": {
+                                                "type": [
+                                                    "number",
+                                                    "string"
+                                                ]
+                                            },
+                                            "$gte": {
+                                                "type": [
+                                                    "number",
+                                                    "string"
+                                                ]
+                                            },
+                                            "$lt": {
+                                                "type": [
+                                                    "number",
+                                                    "string"
+                                                ]
+                                            },
+                                            "$lte": {
+                                                "type": [
+                                                    "number",
+                                                    "string"
+                                                ]
+                                            },
+                                            "$in": {
+                                                "type": "array"
+                                            },
+                                            "$nin": {
+                                                "type": "array"
+                                            },
+                                            "$all": {
+                                                "type": "array"
+                                            },
+                                            "$size": {
+                                                "type": "number"
+                                            },
+                                            "$regex": {
+                                                "type": "string"
+                                            },
+                                            "$startsWith": {
+                                                "type": "string"
+                                            },
+                                            "$endsWith": {
+                                                "type": "string"
+                                            },
+                                            "$contains": {
+                                                "type": "string"
+                                            },
+                                            "$exists": {
+                                                "type": "boolean"
+                                            },
+                                            "$type": {
+                                                "type": "string",
+                                                "enum": [
+                                                    "string",
+                                                    "number",
+                                                    "boolean",
+                                                    "object",
+                                                    "array",
+                                                    "null",
+                                                    "undefined"
+                                                ]
+                                            }
+                                        },
+                                        "additionalProperties": false
+                                    },
+                                    {
+                                        "type": "object",
+                                        "properties": {
+                                            "$and": {
+                                                "type": "array",
+                                                "items": {
+                                                    "$ref": "#/definitions/FilterCondition"
+                                                }
+                                            }
+                                        },
+                                        "required": [
+                                            "$and"
+                                        ],
+                                        "additionalProperties": false
+                                    },
+                                    {
+                                        "type": "object",
+                                        "properties": {
+                                            "$or": {
+                                                "type": "array",
+                                                "items": {
+                                                    "$ref": "#/definitions/FilterCondition"
+                                                }
+                                            }
+                                        },
+                                        "required": [
+                                            "$or"
+                                        ],
+                                        "additionalProperties": false
+                                    }
+                                ]
+                            }
                         }
                     },
                     "required": [
-                        "pattern"
+                        "source",
+                        "sourceType"
+                    ],
+                    "additionalProperties": false
+                }
+            },
+            "required": [
+                "options"
+            ]
+        },
+        "WebSocketEvent": {
+            "enum": [
+                "connect",
+                "disconnect",
+                "message"
+            ]
+        },
+        "WebSocketTrigger": {
+            "type": "object",
+            "properties": {
+                "options": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string"
+                        },
+                        "event": {
+                            "$ref": "#/definitions/WebSocketEvent"
+                        },
+                        "route": {
+                            "type": "string"
+                        },
+                        "routeKey": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "path",
+                        "event"
                     ],
                     "additionalProperties": false
                 }
@@ -71,7 +335,9 @@
                 "type": {
                     "enum": [
                         "http",
-                        "schedule"
+                        "schedule",
+                        "event",
+                        "websocket"
                     ]
                 }
             },
@@ -99,6 +365,30 @@
                     "then": {
                         "$ref": "#/definitions/ScheduleTrigger"
                     }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "type": {
+                                "const": "event"
+                            }
+                        }
+                    },
+                    "then": {
+                        "$ref": "#/definitions/EventTrigger"
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "type": {
+                                "const": "websocket"
+                            }
+                        }
+                    },
+                    "then": {
+                        "$ref": "#/definitions/WebSocketTrigger"
+                    }
                 }
             ],
             "required": [

package/dist/schema/{epf.schema.json → nux.schema.json}

@@ -17,7 +17,7 @@
                 "workingDir": {
                     "type": "string",
                     "description": "Path to store the current environment build artifacts",
-                    "default": ".epf/<environment>"
+                    "default": ".nux/<environment>"
                 },
                 "title": {
                     "type": "string",
@@ -107,7 +107,7 @@
         "workingDir": {
             "type": "string",
             "description": "Path to store the build artifacts for all environments",
-            "default": "./.epf"
+            "default": "./.nux"
         },
         "environments": {
             "type": "object",

package/dist/templates/cloud/entrypoint-build.ts.ejs

@@ -1,53 +1,72 @@
-import { Context, S3Event,
-         APIGatewayProxyEventV2WithJWTAuthorizer,
-         ScheduledEvent
-} from "aws-lambda";
-
-import { createRouter, httpMatcher, scheduleMatcher } from "@@cloudcore";
-import { functions } from "@@cloud";
-//import { initialize } from "@@datastore";
-import { logger } from "@@utils";
+import { createRouter } from "@cloudnux/aws-cloud-provider/router";
+import { awsCloudProvider } from "@cloudnux/aws-cloud-provider";
+import {
+    httpHandler,
+    eventBrokerHandler,
+    scheduleHandler,
+    websocketHandler,
+    useCloudProvider,
+  } from "@cloudnux/cloud-sdk"; 
+import { initializeLogger, logger } from "@cloudnux/utils";
 
 import * as src from "../../../packages/modules/<%=module%>/src";
 
-type AWSEventType = S3Event | APIGatewayProxyEventV2WithJWTAuthorizer | ScheduledEvent;
+useCloudProvider(awsCloudProvider);
 
 const router = createRouter();
 <%_ for(var [key,entry] of Object.entries(entries)) { _%>
     <%_ if(entry.trigger.type.toLowerCase() === "http") { _%>
-        router.add({
-            matcher: httpMatcher("<%=entry.trigger.options.method%>", "<%=entry.trigger.options.route%>"),
-            createContext: functions.httpAdapter.input,
-            func: src["<%= entry.handler %>"]
-        });
-            <%_ } _%>
-            <%_ if(entry.trigger.type.toLowerCase() === "schedule") { _%>
-        router.add({
-            matcher: scheduleMatcher("<%= key %>"),
-            createContext: functions.scheduleAdapter.input,
-            func: src["<%= entry.handler %>"]
-        });
-            <%_ } _%>
+router.http(
+        "<%= entry.trigger.options.method %>",
+        "<%= entry.trigger.options.route %>",
+        (event, context) => {
+            return httpHandler(src["<%= entry.handler %>"], event, context);
+        }
+);
+    <%_ } _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "schedule") { _%>
+router.schedule(
+        "<%= entry.trigger.options.name %>",
+        "<%= entry.trigger.options.pattern %>",
+        (event, context) => {
+            return scheduleHandler(src["<%= entry.handler %>"], event, context);
+        }
+);
+    <%_ } _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "event") { _%>
+router.event(
+             "<%= entry.trigger.options.source %>",
+             "<%= entry.trigger.options.sourceType %>",
+             (event, context) => {
+                return eventBrokerHandler(src["<%= entry.handler %>"], event, context);
+            }
+); 
+    <%_ } _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "websocket") { _%>
+        <%_ const wsRouteKey = entry.trigger.options.event === "connect" ? "$connect" : entry.trigger.options.event === "disconnect" ? "$disconnect" : entry.trigger.options.route || "$default" _%>
+router.websocket(
+            "<%= wsRouteKey %>",
+            (event, context) => {
+                return websocketHandler(src["<%= entry.handler %>"],event,context);
+            }
+);
+    <%_ } _%>
 <%_ } _%>
 
-export async function handler(event: AWSEventType, context: Context) {
-    logger.initialize("locations", context.awsRequestId);
-    logger.info("request started");
-    logger.debug({ event }, "Received event");
-
+export async function handler(event, context) {
+    initializeLogger("<%=module%>",context.awsRequestId);
+    logger.info("request started", { requestId: context.awsRequestId });
+    logger.debug("Received event", { event, requestId: context.awsRequestId });
+   let response;
     try {
-        //await initialize();
-        const handlerType = "rawPath" in event ? "Http" : "source" in event ? "Schedule" : null;
-
-        if (!handlerType) {
-            throw new Error("Invalid handler type");
-        }
-        const output = await router.run(handlerType, functions[`${handlerType.toLowerCase()}Adapter`], event, context);
-        logger.debug({ output }, "Response Sent");
-        logger.info("request completed");
-        return output;
-    } catch (error) {
-        logger.error({ error }, "Error occurred");
+        response = await router.run(event, context);
+        return response;
+    }
+    catch (error) {
+        logger.error("Error occurred", { error, requestId: context.awsRequestId });
         throw error;
     }
+    finally {
+        logger.info("request finished", { response, requestId: context.awsRequestId });
+    }
 }

package/dist/templates/cloud/entrypoint-triggers.tf.ejs

@@ -64,4 +64,22 @@ module "schedule_trigger_for_<%= module %>" {
    <% } %>
  }
 }
+<% } %>
+
+<%_ const eventEntries = Object.entries(entries).filter(([k,e]) => e.trigger.type.toLowerCase() === "event" && e.trigger.options.sourceType?.toLowerCase() === "sqs") _%>
+<% if(eventEntries.length > 0) { %>
+module "sqs_trigger_for_<%= module %>" {
+  source      = "../.deploy/aws/sqs"
+  lambda_name = "<%= module %>"
+  event_sources = {
+  <% for(const [key,entry] of eventEntries) { %>
+    "<%= key %>" = {
+      queue_name  = "<%= entry.trigger.options.source %>"
+      enabled     = true
+      batch_size  = 10
+    }
+    <% } %>
+  }
+}
+
 <% } %>

package/dist/templates/local/dev-server.ts.ejs

@@ -1,106 +1,42 @@
-import Fastify from "fastify";
-import pino from "pino";
+import { useCloudProvider } from "@cloudnux/cloud-sdk";
+import { createRouter, localCloudProvider } from '@cloudnux/local-cloud-provider';
+import { queuesPlugin } from "@cloudnux/local-cloud-provider/queue-plugin";
+import { schedulerPlugin } from "@cloudnux/local-cloud-provider/schedule-plugin";
+import { devConsolePlugin } from "@cloudnux/local-cloud-provider/dev-console-plugin";
+import { websocketsPlugin } from "@cloudnux/local-cloud-provider/websocket-plugin";
+import { initializeLogger } from "@cloudnux/utils";
+
+useCloudProvider(localCloudProvider);
 
 <%_ for(const module of moduleNames){ _%>
-import <%=module%>Entries from "./<%=module%>/index.ts"  
+import <%=module%>Entries from "./<%=module%>"  
 <%_ } _%>
 
-// Create a custom logger
-const customLogger = pino({
-  level: 'info', // Set the log level (e.g., 'info', 'error', 'debug')
-  base: null, // Remove default metadata like pid and hostname
-  hooks: {
-    logMethod(args, method) {
-      // Intercept log messages and send them to the parent process
-      const [message, ...rest] = args;
-      const safePayload = JSON.stringify(message, getCircularReplacer());
-
-      sendMessage('LOG', { level: method.name, message:safePayload, additionalData: rest });
-      return method.apply(this, args);
-    },
-  },
-});
-
-// Function to send logs to the parent process
-function sendMessage(type: string, payload: any) {
-
-  if (process && process.send) {
-    process.send({ type, payload: payload });
-  } else {
-    console.log(`[${type}]`, payload); // Fallback for non-parent process
-  }
-}
-
-function getCircularReplacer() {
-  const seen = new WeakSet();
-  return (key: string, value: any) => {
-    if (typeof value === 'object' && value !== null) {
-      if (seen.has(value)) {
-        return '[Circular]';
-      }
-      seen.add(value);
-    }
-    return value;
-  };
-}
-
-const fastify = Fastify({ 
-    maxParamLength : 1000,
-    loggerInstance:customLogger,
-});
-
-// Add fastify hooks
-fastify.addHook('onRegister', async (instance, opts) => {
-    sendMessage("APP_REGISTERED", { prefix: instance.prefix, opts });
-});
-
-fastify.addHook('onRoute', (routeOptions) => {
-    sendMessage('ROUTE_REGISTERED', {
-        method: routeOptions.method,
-        url: routeOptions.url,
-        handler: routeOptions.handler.name,
-      });
-});
-
-fastify.addHook('onListen', function (done) {
-    try{
-        sendMessage('LISTENING', {
-            port: 3000,
-            host:"::"
-          });
-    }catch(err){
-        sendMessage('ERROR', {err});
-    }finally{
-        const err = null; // to be updated later to handle crash errors
-        done(err)
-    }
-});
+const router = createRouter({logger : true});
 
-fastify.addHook('preHandler', (request, reply, done) => {
-    sendMessage('REQUEST', { id: request.id, params: request.params, query: request.query, body: request.body, headers: request.headers, url: request.url, method:request.method, time: new Date().toLocaleTimeString() });
-    done();
-});
+router.register(queuesPlugin, { prefix: "queues" });
+router.register(schedulerPlugin, { prefix: "schedules" });
+router.register(devConsolePlugin, {  prefix: 'console' });
+router.register(websocketsPlugin, { prefix: "websockets" });
 
-fastify.addHook('onResponse', (request, reply, done) => {
-    sendMessage('RESPONSE', { id: request.id, status: reply.statusCode, body: reply.raw, time: new Date().toLocaleTimeString() });
-    done();
-});
+<%_ for(const module of moduleNames){ _%>
+  router.register(<%=module%>Entries, { prefix: "api" });
+<%_ } _%>
 
-fastify.addHook('onError', (request, reply, error, done) => {
-    sendMessage('ERROR', {error, request, reply});
-    done();
+router.addHook('onRequest', async (request, reply) => {
+  const [pathname] = request.url.split('?');
+  const match = pathname.match(/^\/api\/([^/]+)(?:\/([^/]+))?/);
+  initializeLogger(match?.[2] || "", request.id);
 });
-
-// Register the fastify-raw-body plugin
-fastify.register(require('fastify-raw-body'), {
-  field: 'rawBody',
-  encoding: 'utf8',
+router.addHook('onResponse', async () => {
+  initializeLogger("default", undefined);
 });
 
-<%_ for(const module of moduleNames){ _%>
-fastify.register(<%=module%>Entries, { prefix: "<%=module%>/" });
-<%_ } _%>
-
-fastify.listen({ port: 3000, host : "::" }).then((address) => {
-    // init in entrypoint
+router.listen({ port: 3000, host: "::" }, (err) => {
+  if (err) {
+    console.error('Error starting server:', err);
+    process.exit(1);
+  }
+  else
+    console.log(`Server listening on port ${router?.server?.address()?.port} ...`)
 });