@juspay/neurolink 9.41.0 → 9.42.1

package/dist/proxy/proxyConfig.js

@@ -198,33 +198,47 @@ export function validateProxyConfig(config) {
     if (cfg.version !== undefined && typeof cfg.version !== "number") {
         errors.push(`"version" must be a number, got ${typeof cfg.version}`);
     }
-    if (!cfg.accounts ||
-        typeof cfg.accounts !== "object" ||
-        Array.isArray(cfg.accounts)) {
+    const hasAccounts = !!cfg.accounts &&
+        typeof cfg.accounts === "object" &&
+        !Array.isArray(cfg.accounts);
+    const hasRouting = !!cfg.routing &&
+        typeof cfg.routing === "object" &&
+        !Array.isArray(cfg.routing);
+    if (cfg.routing !== undefined && !hasRouting) {
+        errors.push('"routing" must be an object');
+        return errors;
+    }
+    if (!hasAccounts && !hasRouting) {
+        errors.push('Config must contain at least one of "accounts" or "routing"');
+        return errors;
+    }
+    if (cfg.accounts !== undefined && !hasAccounts) {
         errors.push('"accounts" must be an object mapping provider names to account arrays');
         return errors;
     }
-    const accounts = cfg.accounts;
-    let totalAccounts = 0;
-    for (const [provider, list] of Object.entries(accounts)) {
-        if (!Array.isArray(list)) {
-            errors.push(`accounts.${provider} must be an array, got ${typeof list}`);
-            continue;
-        }
-        totalAccounts += list.length;
-        for (let i = 0; i < list.length; i++) {
-            const acct = list[i];
-            if (!acct || typeof acct !== "object") {
-                errors.push(`accounts.${provider}[${i}] must be an object`);
+    if (hasAccounts) {
+        const accounts = cfg.accounts;
+        let totalAccounts = 0;
+        for (const [provider, list] of Object.entries(accounts)) {
+            if (!Array.isArray(list)) {
+                errors.push(`accounts.${provider} must be an array, got ${typeof list}`);
                 continue;
             }
-            if (typeof acct.apiKey !== "string" || acct.apiKey.length === 0) {
-                errors.push(`accounts.${provider}[${i}].apiKey is required and must be a non-empty string`);
+            totalAccounts += list.length;
+            for (let i = 0; i < list.length; i++) {
+                const acct = list[i];
+                if (!acct || typeof acct !== "object") {
+                    errors.push(`accounts.${provider}[${i}] must be an object`);
+                    continue;
+                }
+                if (typeof acct.apiKey !== "string" || acct.apiKey.length === 0) {
+                    errors.push(`accounts.${provider}[${i}].apiKey is required and must be a non-empty string`);
+                }
             }
         }
-    }
-    if (totalAccounts === 0) {
-        errors.push('"accounts" must contain at least one account');
+        if (totalAccounts === 0 && !hasRouting) {
+            errors.push('"accounts" must contain at least one account');
+        }
     }
     return errors;
 }
@@ -422,8 +436,12 @@ export async function loadProxyConfig(filePath, options = {}) {
     const raw = parsed;
     const accounts = {};
     const rawAccounts = raw.accounts;
-    for (const [provider, list] of Object.entries(rawAccounts)) {
-        accounts[provider] = list.map((item) => applyAccountDefaults(item));
+    if (rawAccounts &&
+        typeof rawAccounts === "object" &&
+        !Array.isArray(rawAccounts)) {
+        for (const [provider, list] of Object.entries(rawAccounts)) {
+            accounts[provider] = list.map((item) => applyAccountDefaults(item));
+        }
     }
     // 7. Extract routing config
     const routing = parseRoutingConfig(raw.routing);
@@ -483,8 +501,12 @@ export async function parseProxyConfigString(content, options = {}) {
     const raw = parsed;
     const accounts = {};
     const rawAccounts = raw.accounts;
-    for (const [provider, list] of Object.entries(rawAccounts)) {
-        accounts[provider] = list.map((item) => applyAccountDefaults(item));
+    if (rawAccounts &&
+        typeof rawAccounts === "object" &&
+        !Array.isArray(rawAccounts)) {
+        for (const [provider, list] of Object.entries(rawAccounts)) {
+            accounts[provider] = list.map((item) => applyAccountDefaults(item));
+        }
     }
     const routing = parseRoutingConfig(raw.routing);
     const cloaking = validateCloakingConfig(raw.cloaking);

package/dist/proxy/proxyEnv.d.ts

@@ -0,0 +1,19 @@
+export type ProxyEnvSource = "cli" | "environment" | "default" | "none";
+export type ProxyEnvResolution = {
+    path?: string;
+    source: ProxyEnvSource;
+    required: boolean;
+};
+export type ProxyEnvLoadResult = {
+    loaded: boolean;
+    path?: string;
+    source: ProxyEnvSource;
+};
+type ProxyEnvOptions = {
+    explicitEnvFile?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+};
+export declare function resolveProxyEnvFile(options?: ProxyEnvOptions): ProxyEnvResolution;
+export declare function loadProxyEnvFile(options?: ProxyEnvOptions): Promise<ProxyEnvLoadResult>;
+export {};

package/dist/proxy/proxyEnv.js

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export function resolveProxyEnvFile(options = {}) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    if (options.explicitEnvFile?.trim()) {
+        return {
+            path: resolve(options.explicitEnvFile.trim()),
+            source: "cli",
+            required: true,
+        };
+    }
+    if (env.NEUROLINK_ENV_FILE?.trim()) {
+        return {
+            path: resolve(env.NEUROLINK_ENV_FILE.trim()),
+            source: "environment",
+            required: true,
+        };
+    }
+    const defaultPath = resolve(homeDir, ".neurolink", ".env");
+    if (existsSync(defaultPath)) {
+        return {
+            path: defaultPath,
+            source: "default",
+            required: false,
+        };
+    }
+    return {
+        source: "none",
+        required: false,
+    };
+}
+export async function loadProxyEnvFile(options = {}) {
+    const resolution = resolveProxyEnvFile(options);
+    const env = options.env ?? process.env;
+    if (!resolution.path) {
+        return {
+            loaded: false,
+            source: "none",
+        };
+    }
+    if (!existsSync(resolution.path)) {
+        if (resolution.required) {
+            throw new Error(`Proxy env file not found: ${resolution.path}`);
+        }
+        return {
+            loaded: false,
+            source: resolution.source,
+        };
+    }
+    try {
+        const { config } = await import("dotenv");
+        const result = config({
+            path: resolution.path,
+            override: true,
+            quiet: true,
+        });
+        if (result.error) {
+            throw result.error;
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load proxy env file ${resolution.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    env.NEUROLINK_ENV_FILE = resolution.path;
+    return {
+        loaded: true,
+        path: resolution.path,
+        source: resolution.source,
+    };
+}