@evenicanpm/common-core 1.3.0 → 1.6.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.3.0",
+	"version": "1.6.0",
 	"description": "Common module for Headless Storefront and Admin panel",
 	"author": "Evenica",
 	"type": "module",
@@ -26,5 +26,5 @@
 	"devDependencies": {
 		"@types/node": "^24.0.13"
 	},
-	"gitHead": "074f33378006dfc21ceb49456806a18dbb6e91ad"
+	"gitHead": "9b18fe6294cc0e57332ec8703825a609ac7b73b2"
 }

package/src/lib/keyvault.ts

@@ -1,13 +1,15 @@
 import { DefaultAzureCredential } from "@azure/identity";
 import { SecretClient } from "@azure/keyvault-secrets";
 
-// The KeyVault information
+// 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();
+const secrets = new Map<string, Secret>();
+let initialized = false;
 
 // A Key and Secret class to Cache Secrets
 class Secret {
@@ -26,20 +28,33 @@ class Secret {
  * @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 (const secretProperties of client.listPropertiesOfSecrets()) {
-			const result = await client.getSecret(secretProperties.name);
-			secrets.set(
-				secretProperties.name,
-				new Secret(secretProperties.name, result.value),
-			);
-		}
+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();
+	}
 };
 
 /**
@@ -47,15 +62,26 @@ const initializeKeyVaultCache = async () => {
  * @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 => {
+const getSecret = async (key: string): Promise<string | undefined> => {
+	// Development: read from env
 	if (process.env.NODE_ENV !== "production") {
-		const fixedName = key.replace(/-/g, "_");
+		const fixedName = key.replaceAll("-", "_");
 		return process.env[fixedName];
-	} else {
-		const fixedName = key.replace(/_/g, "-");
-		const secret = secrets.get(fixedName).secret;
-		return secret;
 	}
+
+	// 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/setup.ts

@@ -15,7 +15,7 @@ import { registerOTel } from "@vercel/otel";
 /**
  * The configuration object passed to setupOtel function.
  */
-interface otelConfig {
+interface OtelConfig {
 	serviceName: string;
 	AzureEnabled?: boolean;
 	AzureMonitorKey?: string;
@@ -26,7 +26,7 @@ interface otelConfig {
  * admin and storefront. Config can be extended to support multiple
  * opentelemetry exports.
  */
-async function setupOtel(otelConfig?: otelConfig) {
+async function setupOtel(otelConfig?: OtelConfig) {
 	if (!process.env.OTELCOL_URL) {
 		throw new Error("Missing OTELCOL_URL environment variable.");
 	}