@evenicanpm/common-core 1.2.0 → 1.4.0

package/cms/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,186 @@
+/// <reference types="node" />
+
+import type { Blob } from 'buffer'
+import type { ReadableStream, WritableStream } from 'stream/web'
+import type { MessagePort } from 'worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: Error
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}
+
+interface WebSocketStreamOptions {
+  protocols?: string | string[]
+  signal?: AbortSignal
+}
+
+interface WebSocketCloseInfo {
+  closeCode: number
+  reason: string
+}
+
+interface WebSocketStream {
+  closed: Promise<WebSocketCloseInfo>
+  opened: Promise<{
+    extensions: string
+    protocol: string
+    readable: ReadableStream
+    writable: WritableStream
+  }>
+  url: string
+}
+
+export declare const WebSocketStream: {
+  prototype: WebSocketStream
+  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
+}
+
+interface WebSocketError extends Event, WebSocketCloseInfo {}
+
+export declare const WebSocketError: {
+  prototype: WebSocketError
+  new (type: string, init?: WebSocketCloseInfo): WebSocketError
+}
+
+export declare const ping: (ws: WebSocket, body?: Buffer) => void

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@evenicanpm/common-core",
-	"version": "1.2.0",
+	"version": "1.4.0",
 	"description": "Common module for Headless Storefront and Admin panel",
 	"author": "Evenica",
 	"type": "module",
@@ -10,10 +10,21 @@
 	},
 	"dependencies": {
 		"@azure/identity": "^4.10.1",
-		"@azure/keyvault-secrets": "^4.10.0"
+		"@azure/keyvault-secrets": "^4.10.0",
+		"@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.32",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.206.0",
+		"@opentelemetry/exporter-trace-otlp-http": "^0.206.0",
+		"@opentelemetry/host-metrics": "^0.36.2",
+		"@opentelemetry/sdk-logs": "^0.206.0",
+		"@opentelemetry/sdk-metrics": "^2.1.0",
+		"@opentelemetry/sdk-trace-node": "^2.1.0",
+		"@strapi/client": "^1.5.0",
+		"@vercel/otel": "^2.0.1",
+		"strapi-sdk-js": "^3.0.0"
 	},
 	"devDependencies": {
 		"@types/node": "^24.0.13"
 	},
-	"gitHead": "6a95e9f84f48a7e1e96bfdf4ee1a766a7d8808b6"
+	"gitHead": "0614726ec6b7ce9564706514a6b756b390a13e96"
 }

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from "./keyvault";

package/src/lib/keyvault.ts

@@ -0,0 +1,87 @@
+import { DefaultAzureCredential } from "@azure/identity";
+import { SecretClient } from "@azure/keyvault-secrets";
+
+// Key Vault configuration
+const vaultName = process.env.KEYVAULT_NAME;
+const vaultEndpoint = process.env.KEYVAULT_ENDPOINT;
+
+const url = `https://${vaultName}.${vaultEndpoint}`;
+
+// Initialize local secrets cache object
+const secrets = new Map<string, Secret>();
+let initialized = false;
+
+// A Key and Secret class to Cache Secrets
+class Secret {
+	key: string;
+	secret: string | undefined;
+	initTime: Date;
+
+	constructor(key: string, secret: string | undefined) {
+		this.key = key;
+		this.secret = secret;
+		this.initTime = new Date();
+	}
+}
+
+/**
+ * @description - Check for all available secret names in the KeyVault, and then get their secrets,
+ * set all secrets in the "secrets" map binding which is exported from this module.
+ */
+const initializeKeyVaultCache = async (): Promise<Map<string, Secret>> => {
+	if (initialized) {
+		return secrets;
+	}
+
+	if (process.env.NODE_ENV !== "production") {
+		initialized = true;
+		return secrets;
+	}
+
+	const credential = new DefaultAzureCredential();
+	const client = new SecretClient(url, credential);
+
+	for await (const props of client.listPropertiesOfSecrets()) {
+		const result = await client.getSecret(props.name);
+		secrets.set(props.name, new Secret(props.name, result.value));
+	}
+
+	initialized = true;
+	return secrets;
+};
+
+// Ensure Key Vault is initialized before access
+const ensureInitialized = async () => {
+	if (!initialized) {
+		await initializeKeyVaultCache();
+	}
+};
+
+/**
+ * @description - Gets Secret from .env variables if development environment or secretVault if production
+ * @param {string} key - Unique key to identify the secret, the secret name in Azure KeyVault
+ * @returns Returns the secret string.
+ */
+const getSecret = async (key: string): Promise<string | undefined> => {
+	// Development: read from env
+	if (process.env.NODE_ENV !== "production") {
+		const fixedName = key.replaceAll("-", "_");
+		return process.env[fixedName];
+	}
+
+	// Production: Key Vault
+	await ensureInitialized();
+
+	const fixedName = key.replaceAll("_", "-");
+	const entry = secrets.get(fixedName);
+
+	if (!entry) {
+		throw new Error(
+			`KeyVault secret not found or not initialized: ${fixedName}`,
+		);
+	}
+
+	return entry.secret;
+};
+
+export { getSecret, initializeKeyVaultCache, secrets };

package/src/otel/README.md

@@ -0,0 +1,44 @@
+# Using Opentelemetry in e4
+
+- `setup.ts` has two main paths:
+  1. Azure Not Enabled - Will setup OLTP and @vercel/otel Registration for auto instrumentation with nextjs
+  2. Azure Enabled - Does the above AND Azure monitoring for metrics, logs, and traces
+
+## Using a Tracer Example
+
+From https://opentelemetry.io/docs/languages/js/instrumentation/
+
+```ts
+import opentelemetry from "@opentelemetry/api";
+//...
+
+const tracer = opentelemetry.trace.getTracer(
+  "instrumentation-scope-name",
+  "instrumentation-scope-version",
+);
+
+// You can now use a 'tracer' to do tracing!
+```
+
+## Starting a Span
+
+```ts
+return tracer.startActiveSpan("rollTheDice", (span: Span) => {
+  const result: number[] = [];
+  for (let i = 0; i < rolls; i++) {
+    result.push(rollOnce(min, max));
+  }
+  // Be sure to end the span!
+  span.end();
+  return result;
+});
+```
+
+## Using the Logger
+
+```ts
+import log from "@evenicanpm/common-core/src/otel/logger";
+
+const logger = log();
+logger.info("This is some e4 info!");
+```

package/src/otel/logger.ts

@@ -0,0 +1,54 @@
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+
+type LogAttriutes = Record<string, string | number | boolean | undefined>;
+
+/**
+ *
+ * Centralized logging using opentelemetry log emitter function.
+ *
+ */
+function logger() {
+	// Global logger is set in ./setup.ts
+	const log = logs.getLogger("storefront");
+	return {
+		info: (message: string, attributes?: LogAttriutes) => {
+			log.emit({
+				severityNumber: SeverityNumber.INFO,
+				body: message,
+				attributes,
+			});
+		},
+		debug: (message: string) => {
+			log.emit({
+				severityNumber: SeverityNumber.DEBUG,
+				body: message,
+			});
+		},
+		error: (message: string, error?: unknown, attributes?: LogAttriutes) => {
+			const err =
+				error instanceof Error
+					? {
+							name: error.name,
+							message: error.message,
+							stack: error.stack,
+						}
+					: undefined;
+			log.emit({
+				severityNumber: SeverityNumber.ERROR,
+				body: message,
+				attributes: {
+					...attributes,
+					...(err && { error: err }),
+				},
+			});
+		},
+		warn: (message: string) => {
+			log.emit({
+				severityNumber: SeverityNumber.WARN,
+				body: message,
+			});
+		},
+	};
+}
+
+export default logger;

package/src/otel/setup.ts

@@ -0,0 +1,99 @@
+import { metrics } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import {
+	BatchLogRecordProcessor,
+	LoggerProvider,
+} from "@opentelemetry/sdk-logs";
+import {
+	MeterProvider,
+	PeriodicExportingMetricReader,
+} from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { registerOTel } from "@vercel/otel";
+
+/**
+ * The configuration object passed to setupOtel function.
+ */
+interface OtelConfig {
+	serviceName: string;
+	AzureEnabled?: boolean;
+	AzureMonitorKey?: string;
+}
+
+/**
+ * The core setup for Azure Insights and opentelemetry for
+ * admin and storefront. Config can be extended to support multiple
+ * opentelemetry exports.
+ */
+async function setupOtel(otelConfig?: OtelConfig) {
+	if (!process.env.OTELCOL_URL) {
+		throw new Error("Missing OTELCOL_URL environment variable.");
+	}
+
+	const { serviceName, AzureEnabled, AzureMonitorKey } = otelConfig ?? {};
+
+	if (!AzureEnabled) {
+		return registerOTel({
+			serviceName: otelConfig?.serviceName,
+			spanProcessors: [
+				new BatchSpanProcessor(
+					new OTLPTraceExporter({ url: process.env.OTELCOL_URL }),
+				),
+			],
+		});
+	}
+
+	/** Azure Enabled */
+	if (!AzureMonitorKey)
+		throw new Error("No Azure Monitor Connection String Provided.");
+
+	const connectionString = AzureMonitorKey;
+	const config = { connectionString };
+
+	// Azure - Imports
+	const {
+		AzureMonitorMetricExporter,
+		AzureMonitorTraceExporter,
+		AzureMonitorLogExporter,
+	} = await import("@azure/monitor-opentelemetry-exporter");
+	const { HostMetrics } = await import("@opentelemetry/host-metrics");
+
+	// Azure - Monitor Exporters
+	const metricsExporter = new AzureMonitorMetricExporter(config);
+	const logExporter = new AzureMonitorLogExporter(config);
+	const traceExporter = new AzureMonitorTraceExporter(config);
+
+	// Azure - Logging
+	const logProcessor = new BatchLogRecordProcessor(logExporter, {
+		maxExportBatchSize: 100,
+	});
+	const loggerProvider = new LoggerProvider({ processors: [logProcessor] });
+	logs.setGlobalLoggerProvider(loggerProvider);
+
+	// Azure - Metrics
+	const metricReaderOptions = {
+		exporter: metricsExporter,
+	};
+	const metricReader = new PeriodicExportingMetricReader(metricReaderOptions);
+	const meterProvider = new MeterProvider({
+		readers: [metricReader],
+	});
+	metrics.setGlobalMeterProvider(meterProvider);
+	// OS level Metrics
+	const hostMetrics = new HostMetrics({ meterProvider });
+	hostMetrics.start();
+
+	/** NextJS Otel Registration */
+	registerOTel({
+		serviceName: serviceName,
+		spanProcessors: [
+			new BatchSpanProcessor(traceExporter),
+			new BatchSpanProcessor(
+				new OTLPTraceExporter({ url: process.env.OTELCOL_URL }),
+			),
+		],
+	});
+}
+
+export { setupOtel };

package/tsconfig.json

@@ -10,10 +10,11 @@
 		"moduleResolution": "node",
 		"resolveJsonModule": true,
 		"outDir": "./dist",
-		"baseUrl": "../../../../storefront/",
+		"baseUrl": "./",
 		"jsx": "preserve",
+		"typeRoots": ["../../../../storefront/node_modules/@types"],
 		"paths": {
-			"*": ["../../../../storefront/node_modules/"]
+			"*": ["../../../../storefront/node_modules/*"]
 		}
 	},
 	"include": ["./"]

package/keyvault.ts

@@ -1,61 +0,0 @@
-import { DefaultAzureCredential } from "@azure/identity";
-import { SecretClient } from "@azure/keyvault-secrets";
-
-// The KeyVault information
-const vaultName = process.env.KEYVAULT_NAME;
-const vaultEndpoint = process.env.KEYVAULT_ENDPOINT;
-const url = `https://${vaultName}.${vaultEndpoint}`;
-
-// Initialize local secrets cache object
-let secrets = new Map();
-
-// A Key and Secret class to Cache Secrets
-class Secret {
-	key: string;
-	secret: string | undefined;
-	initTime: Date;
-
-	constructor(key: string, secret: string | undefined) {
-		this.key = key;
-		this.secret = secret;
-		this.initTime = new Date();
-	}
-}
-
-/**
- * @description - Check for all available secret names in the KeyVault, and then get their secrets,
- * set all secrets in the "secrets" map binding which is exported from this module.
- */
-const initializeKeyVaultCache = async () => {
-	if (process.env.NODE_ENV == "production") {
-		const credential = new DefaultAzureCredential();
-		const client = new SecretClient(url, credential);
-
-		for await (let secretProperties of client.listPropertiesOfSecrets()) {
-			const result = await client.getSecret(secretProperties.name);
-			secrets.set(
-				secretProperties.name,
-				new Secret(secretProperties.name, result.value),
-			);
-		}
-		return secrets;
-	}
-};
-
-/**
- * @description - Gets Secret from .env variables if development environment or secretVault if production
- * @param {string} key - Unique key to identify the secret, the secret name in Azure KeyVault
- * @returns Returns the secret string.
- */
-const getSecret = (key: string): string | undefined => {
-	if (process.env.NODE_ENV != "production") {
-		const fixedName = key.replace(/-/g, "_");
-		return process.env[fixedName];
-	} else {
-		const fixedName = key.replace(/_/g, "-");
-		const secret = secrets.get(fixedName).secret;
-		return secret;
-	}
-};
-
-export { getSecret, initializeKeyVaultCache, secrets };