@cloudnux/cli 0.1.0

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

@@ -0,0 +1,50 @@
+import { Context, S3Event,
+         APIGatewayProxyEventV2WithJWTAuthorizer,
+         ScheduledEvent
+} from "aws-lambda";
+
+import { createRouter, httpMatcher, scheduleMatcher } from "@anubis/cloud-provider";
+import { functions } from "@anubis/aws-cloud-provider";
+import { initialize } from "@anubis/datastore";
+import { logger } from "@anubis/utils";
+
+import * as src from "../../packages/components/<%=component%>/src";
+
+type AWSEventType = S3Event | APIGatewayProxyEventV2WithJWTAuthorizer | ScheduledEvent;
+
+const router = createRouter();
+<%_ for(var [key,entry] of Object.entries(entries)) { _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "http") { _%>
+router.add(httpMatcher("<%=entry.trigger.options.method%>", "<%=entry.trigger.options.route%>"), src["<%= entry.handler %>"])
+    <%_ } _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "schedule") { _%>
+router.add(scheduleMatcher("<%= key %>"), src["<%= entry.handler %>"])
+    <%_ } _%>
+<%_ } _%>
+
+export async function handler(event: AWSEventType, context: Context) {
+    logger.initialize("locations", context.awsRequestId);
+    logger.info("request started");
+    logger.debug({ event }, "Received event");
+
+    try {
+        await initialize();
+        let output = null;
+        if ("rawPath" in event) {
+            output = await router.run("Http", functions.httpAdapter, event, context);
+        }
+        else if ("source" in event) {
+            output = await router.run("Schedule", functions.scheduleAdapter, event, context);
+        }
+        else {
+            throw new Error("invalid handler");
+        }
+        logger.debug({ output }, "Response Sent");
+        logger.info("request completed");
+        return output;
+    }
+    catch (error) {
+        logger.error({ error }, "Error occurred");
+        throw error;
+    }
+}

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

@@ -0,0 +1,67 @@
+terraform {
+  backend "s3" {
+    key                  = "<%= component %>/terraform.state"
+    workspace_key_prefix = "state/<%= component %>"
+  }
+
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = ">= 4.0"
+    }
+  }
+
+  required_version = ">= 0.13.1"
+}
+
+data "aws_lambda_function" "this" {
+    function_name = "<%= component %>"
+}
+
+data "aws_apigatewayv2_apis" "this" {
+   tags = {
+     application = "anubis"
+   }
+}
+
+<% const httpEntries = Object.entries(entries).filter(([k,e]) => e.trigger.type.toLowerCase() === "http")  %>
+<% if(httpEntries.length > 0) { %>
+module "http_trigger_for_<%= component %>" {
+  source         = "../../.deploy/aws/http"
+  api_gateway_id = sort(data.aws_apigatewayv2_apis.this.ids)[0]
+  lambda_arn     = data.aws_lambda_function.this.arn
+  lambda_name    =   "<%= component %>"
+  entrypoints = {
+  <% for(const [key,entry] of httpEntries){ %>
+    "<%= key %>" = {
+      description        = "<% entry.trigger.options.description %>"
+      method             = "<%= entry.trigger.options.method %>"
+      path               = "<%= entry.trigger.options.route %>"
+    }
+    <% } %>
+  }
+}
+
+<% } %>
+
+<% const scheduleEntries = Object.entries(entries).filter(([k,e]) => e.trigger.type.toLowerCase() === "schedule") %>
+<% if(scheduleEntries.length > 0) { %>
+module "schedule_trigger_for_<%= component %>" {
+   source              = "../../.deploy/aws/scheduler"
+   component           = "<%= component %>"
+   target_arn          = data.aws_lambda_function.this.arn
+   schedules = {
+   <% for(const [key,entry] of scheduleEntries) { %>
+     "<%= key %>" = {
+       name     = "<%= key %>"
+       pattern  = "<%= entry.trigger.options.pattern %>"
+       timezone = "UTC"
+       state    = "DISABLED"
+       retry_policy = {
+         maximum_retry_attempts = 3
+       }
+     }
+   <% } %>
+ }
+}
+<% } %>

package/dist/templates/develop.ts.ejs

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+import Fastify, { FastifyInstance } from "fastify";
+import { initialize } from "@anubis/datastore";
+import { logger } from "@anubis/utils";
+
+<% for(const component of components){ %>
+import <%=component%>Entries from "./<%=component%>/entrypoint.ts"  <% }
+%>
+
+async function docs(app: FastifyInstance) {
+    const docsBuildPath = path.resolve("../../../.dist/docs");
+
+    app.get("/index.js", function (request, reply) {
+        const stream = fs.createReadStream(path.resolve(docsBuildPath, "index.js"));
+        reply.type("text/javascript").send(stream);
+    });
+
+    app.get("/index.js.map", function (request, reply) {
+        const stream = fs.createReadStream(path.resolve(docsBuildPath, "index.js.map"));
+        reply.type("text/javascript").send(stream);
+    });
+
+    app.get("/index.css", function (request, reply) {
+        const stream = fs.createReadStream(path.resolve(docsBuildPath, "index.css"));
+        reply.type("text/javascript").send(stream);
+    });
+
+    app.get("*", function (request, reply) {
+        const filePath = path.resolve(docsBuildPath, "index.html");
+        const stream = fs.createReadStream(filePath);
+        reply.type("text/html").send(stream);
+    });
+}
+
+const fastify = Fastify({ 
+    maxParamLength : 1000,
+    logger: {  
+        transport: {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'HH:MM:ss Z',
+                ignore: 'pid,hostname',
+            },
+        }
+    }  
+});
+
+// Register the fastify-raw-body plugin
+fastify.register(require('fastify-raw-body'), {
+  field: 'rawBody',
+  encoding: 'utf8',
+});
+
+fastify.register(docs, { prefix: "docs" });
+<% for(const component of components){ %>
+fastify.register(<%=component%>Entries, { prefix: "api" });
+<%}%>
+fastify.listen({ port: 3000, host : "::" }).then((address) => {
+    logger.setLogger(fastify.log as any);
+    initialize();
+});

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

@@ -0,0 +1,50 @@
+import { Context, S3Event,
+         APIGatewayProxyEventV2WithJWTAuthorizer,
+         ScheduledEvent
+} from "aws-lambda";
+
+import { createRouter, httpMatcher, scheduleMatcher } from "@anubis/cloud-provider";
+import { functions } from "@anubis/aws-cloud-provider";
+import { initialize } from "@anubis/datastore";
+import { logger } from "@anubis/utils";
+
+import * as src from "../../packages/components/<%=component%>/src";
+
+type AWSEventType = S3Event | APIGatewayProxyEventV2WithJWTAuthorizer | ScheduledEvent;
+
+const router = createRouter();
+<%_ for(var [key,entry] of Object.entries(entries)) { _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "http") { _%>
+router.add(httpMatcher("<%=entry.trigger.options.method%>", "<%=entry.trigger.options.route%>"), src["<%= entry.handler %>"])
+    <%_ } _%>
+    <%_ if(entry.trigger.type.toLowerCase() === "schedule") { _%>
+router.add(scheduleMatcher("<%= key %>"), src["<%= entry.handler %>"])
+    <%_ } _%>
+<%_ } _%>
+
+export async function handler(event: AWSEventType, context: Context) {
+    logger.initialize("locations", context.awsRequestId);
+    logger.info("request started");
+    logger.debug({ event }, "Received event");
+
+    try {
+        await initialize();
+        let output = null;
+        if ("rawPath" in event) {
+            output = await router.run("Http", functions.httpAdapter, event, context);
+        }
+        else if ("source" in event) {
+            output = await router.run("Schedule", functions.scheduleAdapter, event, context);
+        }
+        else {
+            throw new Error("invalid handler");
+        }
+        logger.debug({ output }, "Response Sent");
+        logger.info("request completed");
+        return output;
+    }
+    catch (error) {
+        logger.error({ error }, "Error occurred");
+        throw error;
+    }
+}

package/dist/templates/entrypoint-develop.ts.ejs

@@ -0,0 +1,120 @@
+import { FastifyInstance } from "fastify";
+import chalk from "chalk";
+import consola from "consola";
+import logSymbols from "log-symbols";
+import { AddressInfo } from "net";
+const querystring = require('querystring'); 
+
+import {
+  HTTPAuth,
+  HttpMethod,
+  createHttpContext,
+  createScheduleContext,
+} from "@anubis/cloud-provider";
+import { env } from "@anubis/utils";
+
+import * as src from "../../packages/components/<%=component%>/src";
+
+<%_
+  const convertRouteParamstoFastifyRouteTemplate = (route) => {
+      return route.replace(/{(.*?)}/g, (sub) => ":" + sub.slice(1, -1))
+  }
+_%>
+function logEntryURL(method: string, routePath: string){
+  const bgcolors = {
+    PUT : chalk.bold.bgYellow.white,
+    POST : chalk.bold.bgGreen.white,
+    DELETE : chalk.bold.bgRed.white,
+    GET : chalk.bold.bgBlue.white,
+    PATCH :  chalk.bold.bgGreenBright.white
+  };
+  const colors = {
+    PUT : chalk.bold.yellow,
+    POST : chalk.bold.green,
+    DELETE : chalk.bold.red,
+    GET : chalk.bold.blue,
+    PATCH :  chalk.bold.greenBright
+  };
+
+  const prefix = new Array(Math.floor((6 - method.length) / 2)).fill(" ").join("");
+  const postfix = new Array(6 - method.length - prefix.length).fill(" ").join("");
+
+  consola.log(
+    logSymbols.info + bgcolors[method](`[${prefix}${method}${postfix}]`) + colors[method](` http://localhost:3000/api${routePath}`)
+  );
+}
+
+async function entries(app: FastifyInstance) {
+  consola.log(chalk.underline(`\n\rUrls you have in`, chalk.bold(`<%=component%>`), `component:`));
+  let routePath;
+  <%_ for (const [name, entry] of Object.entries(entries)) { _%>
+  <%_ if (entry.trigger.type === "http") { _%>
+  
+  routePath = `/http<%= convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`;
+  logEntryURL('<%= entry.trigger.options.method %>',routePath);
+  app.route({
+      method: "<%= entry.trigger.options.method %>" as any,
+      url: routePath,
+      handler: async function (request, reply) {
+
+        const rawBody = request.rawBody as string;
+        const baseAddress = app.server.address() as AddressInfo;
+        const isAuth = env("DEV_IDENTITY")
+        const ctx = createHttpContext({
+            body: rawBody,
+            headers: request.headers,
+            method: request.method as HttpMethod,
+            url: `http://localhost:${baseAddress!.port}/api${routePath}`,
+            matchingKey: "<%= entry.trigger.options.route %>",
+            params: request.params as Record<string, string>,
+            rawQueryString : querystring.stringify(request.query),
+            host: request.hostname
+          }, isAuth ? {
+            appId: env("DEV_APP_ID"),
+            memberId: env("DEV_MEMBER_ID"),
+            customerId: env("DEV_CUSTOMER_ID"),
+            identity: env("DEV_IDENTITY") as HTTPAuth["identity"],
+            token: "",
+            claims: {
+              app_id: env("DEV_APP_ID"),
+              member_id: env("DEV_MEMBER_ID"),
+              customer_id: env("DEV_CUSTOMER_ID"),
+              identity: env("DEV_IDENTITY")
+            }
+          } : undefined);
+        try {
+          await src["<%= entry.handler %>"](ctx);
+          reply
+            .headers(ctx.response.headers || {})
+            .status(ctx.response.status)
+            .send(ctx.response.body);
+        }
+        catch(e){
+          reply.send(e);
+        }
+      }
+  });
+
+  <%_ } _%>
+  <%_ if (entry.trigger.type === "schedule") { _%>
+  logEntryURL('GET','/schedule/<%= name %>');
+  app.route({
+      method: "GET",
+      url: `/schedule/<%= name %>`,
+      handler: async function (request, reply) {
+        const ctx = createScheduleContext("<%= name %>");
+        try {
+          await src["<%= entry.handler %>"](ctx);
+          reply.status(200).send("success");
+        }
+        catch (e) {
+          reply.send(e);
+        }
+      }
+  });
+
+    <%_ } _%>
+  <%_ } _%>
+}
+
+export default entries;

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

@@ -0,0 +1,67 @@
+terraform {
+  backend "s3" {
+    key                  = "<%= component %>/terraform.state"
+    workspace_key_prefix = "state/<%= component %>"
+  }
+
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = ">= 4.0"
+    }
+  }
+
+  required_version = ">= 0.13.1"
+}
+
+data "aws_lambda_function" "this" {
+    function_name = "<%= component %>"
+}
+
+data "aws_apigatewayv2_apis" "this" {
+   tags = {
+     application = "anubis"
+   }
+}
+
+<% const httpEntries = Object.entries(entries).filter(([k,e]) => e.trigger.type.toLowerCase() === "http")  %>
+<% if(httpEntries.length > 0) { %>
+module "http_trigger_for_<%= component %>" {
+  source         = "../../.deploy/aws/http"
+  api_gateway_id = sort(data.aws_apigatewayv2_apis.this.ids)[0]
+  lambda_arn     = data.aws_lambda_function.this.arn
+  lambda_name    =   "<%= component %>"
+  entrypoints = {
+  <% for(const [key,entry] of httpEntries){ %>
+    "<%= key %>" = {
+      description        = "<% entry.trigger.options.description %>"
+      method             = "<%= entry.trigger.options.method %>"
+      path               = "<%= entry.trigger.options.route %>"
+    }
+    <% } %>
+  }
+}
+
+<% } %>
+
+<% const scheduleEntries = Object.entries(entries).filter(([k,e]) => e.trigger.type.toLowerCase() === "schedule") %>
+<% if(scheduleEntries.length > 0) { %>
+module "schedule_trigger_for_<%= component %>" {
+   source              = "../../.deploy/aws/scheduler"
+   component           = "<%= component %>"
+   target_arn          = data.aws_lambda_function.this.arn
+   schedules = {
+   <% for(const [key,entry] of scheduleEntries) { %>
+     "<%= key %>" = {
+       name     = "<%= key %>"
+       pattern  = "<%= entry.trigger.options.pattern %>"
+       timezone = "UTC"
+       state    = "DISABLED"
+       retry_policy = {
+         maximum_retry_attempts = 3
+       }
+     }
+   <% } %>
+ }
+}
+<% } %>

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

@@ -0,0 +1,106 @@
+import Fastify from "fastify";
+import pino from "pino";
+
+<%_ for(const module of moduleNames){ _%>
+import <%=module%>Entries from "./<%=module%>/index.ts"  
+<%_ } _%>
+
+// 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)
+    }
+});
+
+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();
+});
+
+fastify.addHook('onResponse', (request, reply, done) => {
+    sendMessage('RESPONSE', { id: request.id, status: reply.statusCode, body: reply.raw, time: new Date().toLocaleTimeString() });
+    done();
+});
+
+fastify.addHook('onError', (request, reply, error, done) => {
+    sendMessage('ERROR', {error, request, reply});
+    done();
+});
+
+// Register the fastify-raw-body plugin
+fastify.register(require('fastify-raw-body'), {
+  field: 'rawBody',
+  encoding: 'utf8',
+});
+
+<%_ for(const module of moduleNames){ _%>
+fastify.register(<%=module%>Entries, { prefix: "<%=module%>/" });
+<%_ } _%>
+
+fastify.listen({ port: 3000, host : "::" }).then((address) => {
+    // init in entrypoint
+});

package/dist/templates/local/module.ts.ejs

@@ -0,0 +1,77 @@
+<%# Template generated from a single entrypoint
+    input: 
+      - source : the main export of the package
+      - config: the full entrypoint object 
+%>
+import { AddressInfo } from "node:net";
+import querystring from "node:querystring"; 
+import jwt from "jsonwebtoken";
+
+import { FastifyInstance } from "fastify";
+
+import {
+  HTTPAuth,
+  HttpMethod,
+  createHttpContext,
+  createScheduleContext,
+} from "@@cloudcore";
+
+import * as src from "<%= source %>";
+
+const prefix = "DEV_IDENTITY_";
+function buildAuth(headers: { authorization?: any; }) {
+  try {
+    // Case 1: DEV_IDENTITY_TOKEN
+    const devToken = process.env[`${prefix}TOKEN`];
+    if (devToken) {
+      const claims = jwt.decode(devToken) as Record<string, unknown>;
+      return { token: devToken, ...claims };
+    }
+
+    // Case 2: DEV_IDENTITY_ variables
+    const devIdentityVars = Object.entries(process.env)
+      .filter(([key]) => key.startsWith(prefix) && key !== `${prefix}TOKEN`)
+      .reduce((acc, [key, value]) => {
+        const claimKey = key.replace(prefix, '').toLowerCase();
+        acc[claimKey] = value;
+        return acc;
+      }, {} as Record<string, unknown>);
+
+    if (Object.keys(devIdentityVars).length > 0) {
+      return { token: '', ...devIdentityVars };
+    }
+
+    // Case 3: Authorization header
+    const authHeader = headers.authorization;
+    if (authHeader?.startsWith('Bearer ')) {
+      const token = authHeader.substring(7);
+      const claims = jwt.decode(token) as Record<string, unknown>;
+      return { token, ...claims };
+    }
+
+    // Case 4: Nothing exists
+    return undefined;
+  } catch (error) {
+    console.error('Error processing identity token:', error);
+    return undefined;
+  }
+}
+
+async function entries(app: FastifyInstance) {
+  <%_ for (const [name, entry] of Object.entries(entries)) { _%>
+    <%_ if (entry.trigger.type === "http") { _%>
+      <%- include("triggers/http.ts.ejs", {
+        name,
+        entry
+      }) %>
+    <%_ } _%>
+    <%_ if (entry.trigger.type === "schedule") { _%>
+      <%- include("triggers/schedule.ts.ejs", {
+        name,
+        entry
+      }) %>
+    <%_ } _%>
+  <%_ } _%>
+}
+
+export default entries;

package/dist/templates/local/triggers/http.ts.ejs

@@ -0,0 +1,33 @@
+<%# Template generated a single endpoint entry
+    input: 
+      - entry : entry to be rendered
+%>
+    app.route({
+      method: "<%= entry.trigger.options.method %>" as any,
+      url: `/http<%= $$convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`,
+      handler: async function (request, reply) {
+        const baseAddress = app.server.address() as AddressInfo;
+        const routePath = `/http<%= $$convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`;
+        const ctx = createHttpContext({
+            body: request.rawBody as string,
+            headers: request.headers,
+            method: request.method as HttpMethod,
+            url: `http://${request.hostname}:${baseAddress!.port}/api${routePath}`,
+            matchingKey: "<%= entry.trigger.options.route %>",
+            params: request.params as Record<string, string>,
+            rawQueryString : querystring.stringify(request.query),
+            host: request.hostname
+          }, buildAuth(request.headers));
+
+        try {
+          await src["<%= entry.handler %>"](ctx);
+          reply
+            .headers(ctx.response.headers || {})
+            .status(ctx.response.status)
+            .send(ctx.response.body);
+        }
+        catch(e){
+          reply.send(e);
+        }
+      }
+  });

package/dist/templates/local/triggers/schedule.ts.ejs

@@ -0,0 +1,15 @@
+    logEntryURL('GET','/schedule/<%= name %>');
+    app.route({
+      method: "GET",
+      url: `/schedule/<%= name %>`,
+      handler: async function (request, reply) {
+        const ctx = createScheduleContext("<%= name %>");
+        try {
+          await src["<%= entry.handler %>"](ctx);
+          reply.status(200).send("success");
+        }
+        catch (e) {
+          reply.send(e);
+        }
+      }
+    });