@samanbayaka/core 0.0.1

package/helper/utility/file-handler.mjs

@@ -0,0 +1,121 @@
+import { fileURLToPath, pathToFileURL } from "url"
+import * as path from "path"
+import * as fs from "fs"
+import os from "os"
+import { createRequire } from 'module'
+import chokidar from "chokidar"
+
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const require = createRequire(import.meta.url)
+
+
+/** 
+ * Project absolute path
+ */
+export const ABSOLUTE_PATH = path.join(__filename.split('/samanbayaka/')[0], "samanbayaka")
+
+
+/**
+ * Demo services directory
+ * @type {path}
+ */
+export const DEMO_SERVICES_DIR = path.join(ABSOLUTE_PATH, 'services', 'demo')
+
+
+/**
+ * Feature services absolute path
+ */
+const SERVICES_DIR = process.cwd() 
+// /node_modules/.test(__dirname)
+//   ? __dirname.split('node_modules')[0]
+//   : __dirname.replace("/helper/utility","")
+
+console.log("=================================", process.cwd())
+
+/**
+ * Assets path
+ */
+export const absoluteAssetPath = (dirName) => {
+  return path
+    .join(
+      ABSOLUTE_PATH,
+      dirName,
+    )
+}
+
+
+/**
+ * Read package.json file and return object
+ * @param  {strig} filePath 
+ * @return {object} package object
+ */
+const readPkg = (filePath) => {
+  return JSON.parse(fs
+    .readFileSync(
+      path
+      .join(filePath, "package.json"), 
+      "utf8"
+    )
+  )
+}
+
+
+/**
+ * Read package.json of services and convert to object
+ * @type {object}
+ */
+const pkgService = readPkg(SERVICES_DIR)
+
+/**
+ * Getting service name
+ */
+export const serviceDtls = {
+  name: pkgService.name,
+  version: pkgService.version,
+  id: [pkgService.name, os.hostname(), process.pid].join("-"),
+  osPid: [os.hostname(), process.pid].join("-")
+}
+
+
+/**
+ * Read package.json of samanbayaka and convert to object
+ * @type {object}
+ */
+const pkgMain = readPkg(ABSOLUTE_PATH)
+
+
+/**
+ * Create and object of name and version
+ * @type {Object}
+ */
+export const pkgInfo = {
+  name: pkgMain.name.split('-')[0]
+  .split(" ")
+  .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+  .join(" "),
+  fullName: pkgMain.name,
+  version: pkgMain.version
+}
+
+
+/**
+ * File chage watcher in the service directory
+ */
+export const createFileWatcher = () => {
+  return chokidar.watch(SERVICES_DIR, {
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 2000, // wait 2000ms after last change
+      pollInterval: 50
+    },
+    ignored: [
+      /(^|[\/\\])\../,
+      /(^|[\/\\])node_modules([\/\\]|$)/,
+      /~$/,
+      /\.swp$/,
+      /\.tmp$/
+    ]
+  })
+}

package/helper/utility/global-configs-validator.mjs

@@ -0,0 +1,47 @@
+import * as errHdl from "./error-handler.mjs"
+
+export const validateGlobalConfigs = async(prefix) => {
+  try{
+    const nodeVer = errHdl.checkMinNoveVer()
+    const configHdl = await import("./config-handler.mjs")
+    const { serviceDtls, createFileWatcher } = await import("#hUti/file-handler.mjs")
+    const globalConfigs = await configHdl.getConfigAll(prefix)
+
+
+    const isServiceRemoved = (((await configHdl.getConfigs( `/config/sbk/members/${serviceDtls.name}` )) || "false") == "false")
+    if ( serviceDtls.name != "@samanbayaka/core" && isServiceRemoved ) {
+      throw new Error (`The service "${serviceDtls.name}" is disallowed by CONFIGADMIN.`)
+    }
+
+    return Object.freeze({
+      nodeVer,
+      configCred: configHdl.etcdCred,
+      maxL1TTL: errHdl.validateL1TTL(globalConfigs?.MAX_L1_TTL),
+      maxL2TTL: errHdl.validateL2TTL(globalConfigs?.MAX_L2_TTL),
+      logLevel: errHdl.validateLogLevel(globalConfigs?.LOG_LEVEL),
+      telemetry: errHdl.validateTelemetry(globalConfigs?.TELEMETRY),
+      configRevision: errHdl.validateConfRevision(globalConfigs?.REVISION),
+      serviceDtls,
+      createFileWatcher,
+      hostEntry: {
+        nats: await errHdl.validateHostEntry('nats'),
+        redis: await errHdl.validateHostEntry('redis'),
+        etcd: await errHdl.validateHostEntry('etcd'),
+        redpanda: await errHdl.validateHostEntry('redpanda', true),
+        openobserve: await errHdl.validateHostEntry('openobserve', true),
+      },     
+      namespaceTxt: errHdl.validateNamespace(globalConfigs.APP_ENV),
+    })
+  }
+  catch(err){
+    // console.error("\x1b[31m%s\x1b[0m", ` ❖❖ SBKERR ❖❖ \n ${errHdl.extractFileLines(err.stack)}`)
+    console.error("\x1b[31m%s\x1b[0m", ` ❖❖ SBKERR ❖❖ ${err.message}`)
+    process.exit(1)
+  }
+}
+
+
+/**
+ * Validate the Samanbayaka global configurations
+ */
+export const SBK_GLOBAL_CONFIGS = await validateGlobalConfigs("/config/sbk/global/envs/")

package/helper/utility/openapi-to-mol-params.mjs

@@ -0,0 +1,84 @@
+/**
+ * Generate Moleculer params definitions from the OpenAPI schema to enable request parameter validation using AJV
+ * @param  {object} schema
+ */
+export const openApiToMoleculerParams = (schema) => {
+  if( schema?.openapi?.parameters || schema?.openapi?.requestBody ){
+
+    /**
+     * Moleculer params schema for request validation
+     * @type {Object}
+     */
+    schema.params = {
+      type: "object",
+      properties: {
+        params: {
+          type: "object",
+          properties: {
+          },
+          required: [],
+          additionalProperties: false,
+        },
+        query: {
+          type: "object",
+          properties: {
+
+          },
+          required: [],
+        },
+        body: {}
+      },
+      required:[],
+      additionalProperties: false,
+    }
+          
+    /**
+     * Enforce the presence of a request body in the request based on OpenAPI schema definition
+     */
+    if( schema?.openapi?.requestBody?.required ){
+      schema.params.required.push("body")
+    }
+
+    /**
+     * Generate request body params from the OpenAPI schema definition.
+     */
+    if( schema?.openapi?.requestBody  && schema?.openapi?.requestBody?.content ){
+      schema.params.properties.body.anyOf = Object.entries(schema?.openapi?.requestBody?.content)
+        .map(el=>el[1].schema)
+
+    }
+
+    /**
+     * Generate request path & query params from the OpenAPI schema definition.
+     */
+    if( schema?.openapi?.parameters ) {
+      schema.params.properties.params.properties = schema?.openapi?.parameters
+        .filter(el=> el.in == "path")
+        .reduce((obj, item) => {
+          obj[item.name] = item.schema
+          return obj
+        }, {})
+      schema.params.properties.params.required = Object.keys(schema.params.properties.params.properties)
+
+      if( schema.params.properties.params.required.length > 0 ){
+        schema.params.required.push("params")
+      }
+
+      schema.params.properties.query.properties = schema?.openapi?.parameters
+      .filter(el=> el.in == "query").reduce((obj, item) => {
+        obj[item.name] = item.schema
+        return obj
+      }, {})
+
+      if( Object.keys(schema.params.properties.query.properties).length > 0 ){
+        schema.params.required.push("query")
+      }
+
+      schema.params.properties.query.required = schema?.openapi?.parameters
+      .filter(el=> el.in == "query")
+      .filter(el => el.required)
+      .map(el => el.name )
+    }
+  }
+
+}

package/helper/utility/sign-jwt.mjs

@@ -0,0 +1,35 @@
+import { createPublicKey, randomUUID } from "node:crypto"
+import { v5 as uuidv5 } from "uuid" 
+import jwt from "jsonwebtoken"
+
+import * as configHdl from '#hUti/config-handler.mjs'
+
+const privateKey = await configHdl.getConfigs(`/config/sbk/sys/certs/SERVER_KEY`)
+const cert = await configHdl.getConfigs(`/config/sbk/sys/certs/SERVER_CRT`)
+const publicKey = createPublicKey(cert).export({
+  type: "spki",
+  format: "pem",
+})
+
+const MY_NAMESPACE = randomUUID()
+const sub = uuidv5("samanbayaka", MY_NAMESPACE)
+const typ = "Bearer"
+
+export const signJWT = (data, expiresIn = "30s") => {
+  return jwt.sign(
+    { 
+      sub,
+      typ,
+      data,
+    },
+    privateKey, 
+    {
+      algorithm: 'RS256',
+      expiresIn
+    },
+  )
+}
+
+export const verifyJWT = (token) => {
+  return jwt.verify(token, publicKey)
+}

package/helper/utility/telemetry.mjs

@@ -0,0 +1,129 @@
+import { NodeSDK } from "@opentelemetry/sdk-node"
+import { resourceFromAttributes } from "@opentelemetry/resources"
+import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions"
+
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http"
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics"
+import { context, trace, metrics, SpanStatusCode } from "@opentelemetry/api"
+
+
+const resource = resourceFromAttributes({
+  [SemanticResourceAttributes.SERVICE_NAME]: "moleculer-sbk"
+})
+
+
+// import { ConsoleSpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base"
+// export const sdk = new NodeSDK({
+//   spanProcessors: [
+//     new SimpleSpanProcessor(new ConsoleSpanExporter())
+//   ]
+
+// })
+
+
+export const createOpenTelemetryExporters = (config) => {
+  const sdk = new NodeSDK({
+    resource,
+
+    traceExporter: new OTLPTraceExporter({
+      url: `http://${config.host}:${config.port}/api/default/v1/traces`,
+      headers: {
+        Authorization: config.token
+      }
+    }),
+
+    metricReaders: [new PeriodicExportingMetricReader({
+      exporter: new OTLPMetricExporter({
+        url: `http://${config.host}:${config.port}/api/default/v1/metrics`,
+        headers: {
+          Authorization: config.token
+        }
+      }),
+      exportIntervalMillis: 5000,
+      exportTimeoutMillis: 5000
+    })],
+
+    autoGeneratePropagators: true, // Recommended
+
+  })
+  sdk.start()
+  return sdk
+}
+
+
+const tracer = trace.getTracer("moleculer")
+
+export const OpenTelemetryMW = (isEnabled) => {
+  const meter = metrics.getMeter("moleculer")
+
+  const requestCounter = meter.createCounter("moleculer_requests_total", {
+    description: "Total number of requests"
+  })
+  const errorCounter = meter.createCounter("moleculer_errors_total", {
+    description: "Total number of errors"
+  })
+  const durationHistogram = meter.createHistogram("moleculer_request_duration_ms", {
+    description: "Request duration in ms"
+  })
+
+  return {
+    name: "otel",
+
+    localAction(next, action) {
+      if ( !isEnabled ) return next
+      return async (ctx) => {
+        const startTime = Date.now()
+
+        const span = tracer.startSpan(`action:${action.name}`, {
+          attributes: {
+            "moleculer.service": action.service.name,
+            "moleculer.action": action.name,
+            "moleculer.nodeID": ctx.nodeID
+          }
+        })
+
+        return context.with(trace.setSpan(context.active(), span), async () => {
+          try {
+            const result = await next(ctx)
+
+            /**
+             * Metrics
+             */
+            requestCounter.add(1, {
+              action: action.name,
+              service: action.service.name
+            })
+
+            durationHistogram.record(Date.now() - startTime, {
+              action: action.name
+            })
+
+            span.setStatus({ code: SpanStatusCode.OK })
+            return result
+
+          } catch (err) {
+            /**
+             * Metrics
+             */
+            errorCounter.add(1, {
+              action: action.name,
+              service: action.service.name
+            })
+
+            span.recordException(err)
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: err.message
+            })
+
+            throw err
+
+          } finally {
+            span.end()
+          }
+        })
+      }
+    }
+  }
+}