novada-proxy-sdk 0.0.1

package/build/index.d.ts

@@ -0,0 +1,22 @@
+import { type ProxySuccessResponse } from "novada-proxy-core";
+import type { BatchFetchOptions, CrawlOptions, ExtractOptions, FetchOptions, MapOptions, NovadaProxyOptions, RenderOptions, ResearchOptions, SearchOptions, SessionOptions } from "./types.js";
+export type { BatchFetchOptions, CrawlOptions, ExtractOptions, FetchOptions, MapOptions, NovadaProxyOptions, RenderOptions, ResearchOptions, SearchOptions, SessionOptions, } from "./types.js";
+export type { ProxyAdapter, ProxyCredentials, ProxyErrorResponse, ProxyResponse, ProxySuccessResponse, } from "novada-proxy-core";
+export declare class NovadaProxy {
+    private readonly adapter;
+    private readonly credentials;
+    private readonly apiKey?;
+    private readonly browserWs?;
+    constructor(options?: NovadaProxyOptions);
+    static fromEnv(): NovadaProxy;
+    fetch(options: FetchOptions): Promise<ProxySuccessResponse>;
+    batchFetch(options: BatchFetchOptions): Promise<ProxySuccessResponse>;
+    search(options: SearchOptions): Promise<ProxySuccessResponse>;
+    extract(options: ExtractOptions): Promise<ProxySuccessResponse>;
+    map(options: MapOptions): Promise<ProxySuccessResponse>;
+    crawl(options: CrawlOptions): Promise<ProxySuccessResponse>;
+    research(options: ResearchOptions): Promise<ProxySuccessResponse>;
+    render(options: RenderOptions): Promise<ProxySuccessResponse>;
+    session(options: SessionOptions): Promise<ProxySuccessResponse>;
+    status(): Promise<ProxySuccessResponse>;
+}

package/build/index.js

@@ -0,0 +1,156 @@
+import { novadaProxyBatchFetch, novadaProxyCrawl, novadaProxyExtract, novadaProxyFetch, novadaProxyMap, novadaProxyRender, novadaProxyResearch, novadaProxySearch, novadaProxySession, novadaProxyStatus, resolveAdapter, validateBatchFetchParams, validateCrawlParams, validateExtractParams, validateFetchParams, validateMapParams, validateRenderParams, validateResearchParams, validateSearchParams, validateSessionParams, } from "novada-proxy-core";
+function parseResult(raw) {
+    return JSON.parse(raw);
+}
+function dropUndefined(value) {
+    for (const key of Object.keys(value)) {
+        if (value[key] === undefined)
+            delete value[key];
+    }
+    return value;
+}
+function configureEnv(options) {
+    if (options.user !== undefined)
+        process.env.NOVADA_PROXY_USER = options.user;
+    if (options.pass !== undefined)
+        process.env.NOVADA_PROXY_PASS = options.pass;
+    if (options.host !== undefined)
+        process.env.NOVADA_PROXY_HOST = options.host;
+    if (options.port !== undefined)
+        process.env.NOVADA_PROXY_PORT = String(options.port);
+    if (options.apiKey !== undefined)
+        process.env.NOVADA_API_KEY = options.apiKey;
+    if (options.browserWs !== undefined)
+        process.env.NOVADA_BROWSER_WS = options.browserWs;
+    if (options.provider !== undefined)
+        process.env.NOVADA_PROXY_PROVIDER = options.provider;
+}
+export class NovadaProxy {
+    adapter;
+    credentials;
+    apiKey;
+    browserWs;
+    constructor(options = {}) {
+        configureEnv(options);
+        const resolved = resolveAdapter(process.env);
+        if (!resolved) {
+            throw new Error("No proxy adapter resolved. Provide Novada proxy credentials or set NOVADA_PROXY_USER and NOVADA_PROXY_PASS.");
+        }
+        this.adapter = resolved.adapter;
+        this.credentials = resolved.credentials;
+        this.apiKey = options.apiKey ?? process.env.NOVADA_API_KEY;
+        this.browserWs = options.browserWs ?? process.env.NOVADA_BROWSER_WS;
+    }
+    static fromEnv() {
+        return new NovadaProxy({});
+    }
+    async fetch(options) {
+        const params = validateFetchParams(dropUndefined({
+            url: options.url,
+            country: options.country,
+            city: options.city,
+            session_id: options.sessionId,
+            format: options.format,
+            timeout: options.timeout,
+        }));
+        return parseResult(await novadaProxyFetch(params, this.adapter, this.credentials));
+    }
+    async batchFetch(options) {
+        const params = validateBatchFetchParams(dropUndefined({
+            urls: options.urls,
+            country: options.country,
+            session_id: options.sessionId,
+            format: options.format,
+            timeout: options.timeout,
+            concurrency: options.concurrency,
+        }));
+        return parseResult(await novadaProxyBatchFetch(params, this.adapter, this.credentials));
+    }
+    async search(options) {
+        if (!this.apiKey) {
+            throw new Error("NOVADA_API_KEY is required for search.");
+        }
+        const params = validateSearchParams(dropUndefined({
+            query: options.query,
+            engine: options.engine,
+            num: options.num,
+            country: options.country,
+            language: options.language,
+        }));
+        return parseResult(await novadaProxySearch(params, this.apiKey));
+    }
+    async extract(options) {
+        const params = validateExtractParams(dropUndefined({
+            url: options.url,
+            fields: options.fields,
+            schema: options.schema,
+            country: options.country,
+            city: options.city,
+            session_id: options.sessionId,
+            timeout: options.timeout,
+            render_fallback: options.renderFallback,
+        }));
+        return parseResult(await novadaProxyExtract(params, this.adapter, this.credentials, this.browserWs));
+    }
+    async map(options) {
+        const params = validateMapParams(dropUndefined({
+            url: options.url,
+            limit: options.limit,
+            include_external: options.includeExternal,
+            country: options.country,
+            timeout: options.timeout,
+        }));
+        return parseResult(await novadaProxyMap(params, this.adapter, this.credentials));
+    }
+    async crawl(options) {
+        const params = validateCrawlParams(dropUndefined({
+            url: options.url,
+            depth: options.depth,
+            limit: options.limit,
+            include_content: options.includeContent,
+            country: options.country,
+            timeout: options.timeout,
+            format: options.format,
+        }));
+        return parseResult(await novadaProxyCrawl(params, this.adapter, this.credentials));
+    }
+    async research(options) {
+        if (!this.apiKey) {
+            throw new Error("NOVADA_API_KEY is required for research.");
+        }
+        const params = validateResearchParams(dropUndefined({
+            query: options.query,
+            depth: options.depth,
+            country: options.country,
+            timeout: options.timeout,
+        }));
+        return parseResult(await novadaProxyResearch(params, this.adapter, this.credentials, this.apiKey));
+    }
+    async render(options) {
+        if (!this.browserWs) {
+            throw new Error("NOVADA_BROWSER_WS is required for render.");
+        }
+        const params = validateRenderParams(dropUndefined({
+            url: options.url,
+            format: options.format,
+            wait_for: options.waitFor,
+            timeout: options.timeout,
+        }));
+        return parseResult(await novadaProxyRender(params, this.browserWs));
+    }
+    async session(options) {
+        const params = validateSessionParams(dropUndefined({
+            session_id: options.sessionId,
+            url: options.url,
+            country: options.country,
+            city: options.city,
+            format: options.format,
+            timeout: options.timeout,
+            verify_sticky: options.verifySticky,
+        }));
+        return parseResult(await novadaProxySession(params, this.adapter, this.credentials));
+    }
+    async status() {
+        return parseResult(await novadaProxyStatus(this.adapter, this.credentials));
+    }
+}

package/build/types.d.ts

@@ -0,0 +1,79 @@
+export interface NovadaProxyOptions {
+    user?: string;
+    pass?: string;
+    host?: string;
+    port?: string | number;
+    apiKey?: string;
+    browserWs?: string;
+    provider?: string;
+}
+export interface FetchOptions {
+    url: string;
+    country?: string;
+    city?: string;
+    sessionId?: string;
+    format?: "raw" | "markdown";
+    timeout?: number;
+}
+export interface BatchFetchOptions {
+    urls: string[];
+    country?: string;
+    sessionId?: string;
+    format?: "raw" | "markdown";
+    timeout?: number;
+    concurrency?: number;
+}
+export interface SearchOptions {
+    query: string;
+    engine?: "google";
+    num?: number;
+    country?: string;
+    language?: string;
+}
+export interface ExtractOptions {
+    url: string;
+    fields: string[];
+    schema?: Record<string, string>;
+    country?: string;
+    city?: string;
+    sessionId?: string;
+    timeout?: number;
+    renderFallback?: boolean;
+}
+export interface MapOptions {
+    url: string;
+    limit?: number;
+    includeExternal?: boolean;
+    country?: string;
+    timeout?: number;
+}
+export interface CrawlOptions {
+    url: string;
+    depth?: number;
+    limit?: number;
+    includeContent?: boolean;
+    country?: string;
+    timeout?: number;
+    format?: "markdown" | "raw";
+}
+export interface ResearchOptions {
+    query: string;
+    depth?: "quick" | "standard" | "deep";
+    country?: string;
+    timeout?: number;
+}
+export interface RenderOptions {
+    url: string;
+    format?: "markdown" | "html" | "text";
+    waitFor?: string;
+    timeout?: number;
+}
+export interface SessionOptions {
+    sessionId: string;
+    url: string;
+    country?: string;
+    city?: string;
+    format?: "raw" | "markdown";
+    timeout?: number;
+    verifySticky?: boolean;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "novada-proxy-sdk",
+  "version": "0.0.1",
+  "description": "Novada Proxy SDK \u2014 residential proxy for TypeScript/JavaScript apps",
+  "type": "module",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "files": [
+    "build/**/*.js",
+    "build/**/*.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "novada-proxy-core": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}