webcrawlerapi-js 1.0.10 → 1.1.1

package/README.md

@@ -1,64 +1,190 @@
 # JS client for WebcrawlerAPI
 
-Official client for [WebcrawlerAPI](https://webcrawlerapi.com/).
+Official client for [WebcrawlerAPI](https://webcrawlerapi.com/). This SDK provides a robust and type-safe way to interact with WebcrawlerAPI's powerful web scraping capabilities, making it easy to extract structured data from any website.
 
-WebcrawlerAPI allows you to extract data from any website with just a simple API call.
+WebcrawlerAPI allows you to extract data from any website with just a simple API call. The service handles all the complexities of web scraping, including JavaScript rendering, proxy rotation, and rate limiting, so you can focus on using the data.
 
 ## Preparation
 1. Register to [dashboard|https://dash.webcrawlerapi.com/].
 2. Get an [Access Key](https://dash.webcrawlerapi.com/access).
 
+Our dashboard provides comprehensive analytics and monitoring tools to help you track your API usage and optimize your scraping operations.
+
 ## Installation
 Install WebcrawlerAPI js package:
 
 `npm i webcrawlerapi-js`
 
-## Request example
+The package is regularly updated with new features and improvements to ensure the best possible scraping experience.
+
+## JavaScript Examples
+
+### Synchronous Job
+In this mode, the promise will be resolved when all data is ready. Synchronous jobs are perfect for quick scraping tasks where you need immediate results and don't want to handle polling logic.
 
 ```javascript
-import { WebcrawlerClient } from "webcrawlerapi-js"
+import webcrawlerapi from "webcrawlerapi-js"
 
 async function main() {
     const client = new WebcrawlerClient(
         "YOUR API ACCESS KEY HERE",
     )
-    // sync way - promise will be resolved with the all the data
-    const syncJob = await client.crawl({
+
+    try {
+        const syncJob = await client.crawl({
             "items_limit": 10,
             "url": "https://stripe.com/",
             "scrape_type": "markdown"
-        }
-    )
-    for (const item of syncJob.job_items) {
-        item.getContent().then((content) => {
-            console.log(content.slice(0, 100));
         })
+        
+        for (const item of syncJob.job_items) {
+            const content = await item.getContent()
+            console.log(content.slice(0, 100))
+        }
+        console.log(syncJob)
+        
+    } catch (error) {
+        if (error instanceof webcrawlerapi.WebcrawlerApiError) {
+            console.error("Webcrawler error:", error.message)
+        }
+        return
     }
-    console.log(syncJob);
+}
+
+main().catch(console.error)
+```
+
+### Asynchronous Job
+In this mode, you get a job ID immediately and can poll for results. Asynchronous jobs are ideal for large-scale scraping operations where you want to process data in batches or handle long-running tasks efficiently.
 
-    // or async - get the job id and then poll the job status and get the data
+```javascript
+import webcrawlerapi from "webcrawlerapi-js"
 
-    const jobWithId = await client.crawlAsync({
+async function main() {
+    const client = new WebcrawlerClient(
+        "YOUR API ACCESS KEY HERE",
+    )
+
+    try {
+        // Get job ID immediately
+        const jobWithId = await client.crawlAsync({
             "items_limit": 10,
             "url": "https://stripe.com/",
             "scrape_type": "markdown"
+        })
+        
+        // Poll for job completion
+        const jobId = jobWithId.id
+        let asyncJob = await client.getJob(jobId)
+        
+        // Check job status
+        console.log("Job status:", asyncJob.status)
+        
+        // Once complete, access results
+        if (asyncJob.status === "completed") {
+            for (const item of asyncJob.job_items) {
+                const content = await item.getContent()
+                console.log(content.slice(0, 100))
+            }
         }
+    } catch (error) {
+        if (error instanceof webcrawlerapi.WebcrawlerApiError) {
+            console.error("Webcrawler error:", error.message)
+        }
+    }
+}
+
+main().catch(console.error)
+```
+
+## TypeScript Usage
+
+The SDK provides full TypeScript support with type safety and error handling. Our TypeScript integration ensures you catch potential issues at compile-time and provides excellent IDE support with autocompletion and inline documentation.
+
+```typescript
+import { WebcrawlerClient, WebcrawlerApiError } from "webcrawlerapi-js"
+
+async function main() {
+    const client = new WebcrawlerClient(
+        "YOUR_API_KEY",
+        // Optional base URL, defaults to production API
+        "http://localhost:8080" 
     )
-    // wait for job to complete
-    const jobId = jobWithId.id;
-    let asyncJob = await client.getJob(jobId);
 
-    console.log(asyncJob);
+    try {
+        // Basic crawl with markdown
+        const syncJob = await client.crawl({
+            "items_limit": 2,
+            "url": "https://books.toscrape.com/",
+            "scrape_type": "markdown"
+        })
+
+        // Type-safe status check
+        if (syncJob.status === "done") {
+            for (const item of syncJob.job_items) {
+                if (item.markdown_content_url) {
+                    // Access typed properties
+                    console.log("Status code:", item.page_status_code)
+                    console.log("Content URL:", item.markdown_content_url)
+                }
+            }
+        }
+
+        // Using specialized scraper
+        const scrapeJob = await client.scrape({
+            "crawler_id": "webcrawler/url-to-md",
+            "input": {
+                "url": "https://books.toscrape.com/"
+            }
+        })
+
+        if (scrapeJob.status === "done") {
+            const content = scrapeJob.getContent()
+            console.log("Scraped content:", content)
+        }
+
+    } catch (error) {
+        // Type-safe error handling
+        if (error instanceof WebcrawlerApiError) {
+            console.error("API Error:", error.errorCode, error.message)
+            // errorCode is typed and can be used for specific error handling
+            if (error.errorCode === "invalid_request") {
+                // Handle invalid request
+            }
+        }
+    }
 }
 
-main().catch(console.error);
+main().catch(console.error)
 ```
 
-## Response example
-```javascript
+### Error Handling
+
+The SDK provides typed error handling through the `WebcrawlerApiError` class. Our error handling system is designed to provide detailed, actionable feedback that helps you quickly identify and resolve issues in your scraping pipeline.
+
+```typescript
+try {
+    const syncJob = await client.crawl({
+        "items_limit": 2,
+        "url": "https://books.toscrape.com/",
+        // This will cause an error due to missing scrape_type
+    })
+} catch (error) {
+    if (error instanceof WebcrawlerApiError) {
+        // Typed error properties
+        console.error("Error code:", error.errorCode)
+        console.error("Error message:", error.message)
+    }
+}
+```
+
+## Response Structure
+
+Example of a job response. The response structure is carefully designed to provide comprehensive information about your scraping job, including detailed status updates, timing information, and resource usage metrics.
+
+```json
 {
   id: '49c4942b-b7d9-4d62-94b5-b54a3016ac51',
-  org_id: 'clxsnorta00075wuuqxgzzvxm',
   url: 'https://stripe.com/',
   scrape_type: 'markdown',
   whitelist_regexp: '',

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "webcrawlerapi-js",
-  "version": "1.0.10",
+  "version": "1.1.1",
 
   "description": "JS client for WebcrawlerAPI",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/api.js",
+  "types": "./dist/@types/api.d.ts",
   "scripts": {
     "build": "tsc --outDir dist/"
   },

package/{api.ts → src/api.ts}

@@ -1,11 +1,14 @@
 import {CrawlRequest, Job, JobId, ScrapeRequest, ScrapeResponse} from "./model";
 import { JobStatus } from "./constants";
-import { WebcrawlerApiError, createErrorFromResponse } from "./errors";
+import { WebcrawlerApiError, createErrorFromResponse, ErrorResponse } from "./errors";
 
 const BASE_PATH = "https://api.webcrawlerapi.com"
 const initialPullDelayMs = 2000
 const MaxPullRetries = 100
 
+export { WebcrawlerApiError, JobStatus };
+export * from "./model";
+
 export class WebcrawlerClient {
     protected apiVersion: string = "v1";
     protected apiKey: string
@@ -206,7 +209,7 @@ export class WebcrawlerClient {
 
         if (!response.ok) {
             try {
-                const errorData = await response.json();
+                const errorData = await response.json() as ErrorResponse;
                 throw createErrorFromResponse(response, errorData);
             } catch (e) {
                 if (e instanceof WebcrawlerApiError) {

package/tsconfig.json

@@ -1,15 +1,21 @@
 {
   "compilerOptions": {
-    "declaration": true,
-    "target": "es6",
+    "lib": [
+      "es2021"
+    ],
     "module": "commonjs",
-    "noImplicitAny": true,
+    "target": "es2021",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
     "outDir": "dist",
-    "rootDir": ".",
-    "typeRoots": [
-      "node_modules/@types"
-    ]
+    "declarationDir": "dist/@types",
+    "declaration": true
   },
+  "include": [
+    "src/**/*"
+  ],
   "exclude": [
     "dist",
     "node_modules"

package/dist/api.d.ts

@@ -1,15 +0,0 @@
-import { CrawlRequest, Job, JobId, ScrapeRequest, ScrapeResponse } from "./model";
-export declare class WebcrawlerClient {
-    protected apiVersion: string;
-    protected apiKey: string;
-    protected basePath: string;
-    constructor(apiKey: string, basePath?: string, apiVersion?: string);
-    scrapeAsync(scrapeRequest: ScrapeRequest): Promise<JobId>;
-    scrapeWithMeta(scrapeRequest: ScrapeRequest, maxPollingRetries?: number): Promise<ScrapeResponse>;
-    scrape(scrapeRequest: ScrapeRequest, maxPollingRetries?: number): Promise<any>;
-    getScrapeResult(scrapeID: string): Promise<ScrapeResponse>;
-    crawl(crawlRequest: CrawlRequest): Promise<Job>;
-    crawlAsync(crawlRequest: CrawlRequest): Promise<JobId>;
-    getJob(jobID: string): Promise<Job>;
-    private sendRequest;
-}

package/dist/configuration.d.ts

@@ -1,16 +0,0 @@
-export interface ConfigurationParameters {
-    apiKey?: string;
-    basePath?: string;
-    apiVersion?: string;
-}
-export declare class Configuration {
-    /**
-     * Base options for http call
-     */
-    baseOptions?: any;
-    /**
-     * API version, for example: "v1"
-     */
-    apiVersion: string;
-    constructor(param?: ConfigurationParameters);
-}

package/dist/configuration.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Configuration = void 0;
-const packageJson = require("../package.json");
-class Configuration {
-    constructor(param = {}) {
-        /**
-         * API version, for example: "v1"
-         */
-        this.apiVersion = "v1";
-        this.apiVersion = param.apiVersion;
-        if (!this.baseOptions) {
-            this.baseOptions = {};
-        }
-        this.baseOptions = {
-            headers: Object.assign({ 'User-Agent': `webcrawlerapi-js/${packageJson.version}`, 'Content-Type': 'application/json' }, this.baseOptions.headers)
-        };
-    }
-}
-exports.Configuration = Configuration;

package/dist/constants.d.ts

@@ -1,13 +0,0 @@
-export declare const JobStatus: {
-    readonly IN_PROGRESS: "in_progress";
-    readonly NEW: "new";
-    readonly DONE: "done";
-};
-export declare const HttpStatus: {
-    readonly OK: 200;
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly INTERNAL_SERVER_ERROR: 500;
-};

package/dist/constants.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpStatus = exports.JobStatus = void 0;
-exports.JobStatus = {
-    IN_PROGRESS: 'in_progress',
-    NEW: 'new',
-    DONE: 'done'
-};
-exports.HttpStatus = {
-    OK: 200,
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500
-};

package/dist/errors.d.ts

@@ -1,12 +0,0 @@
-export declare class WebcrawlerApiError extends Error {
-    errorCode: string;
-    errorMessage: string;
-    statusCode?: number;
-    constructor(errorCode: string, errorMessage: string, statusCode?: number);
-}
-export interface ErrorResponse {
-    error_code?: string;
-    error_message?: string;
-    error?: string;
-}
-export declare function createErrorFromResponse(response: Response, data: ErrorResponse): WebcrawlerApiError;

package/dist/errors.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebcrawlerApiError = void 0;
-exports.createErrorFromResponse = createErrorFromResponse;
-class WebcrawlerApiError extends Error {
-    constructor(errorCode, errorMessage, statusCode) {
-        super(errorMessage);
-        this.name = 'WebcrawlerApiError';
-        this.errorCode = errorCode;
-        this.errorMessage = errorMessage;
-        this.statusCode = statusCode;
-    }
-}
-exports.WebcrawlerApiError = WebcrawlerApiError;
-function createErrorFromResponse(response, data) {
-    const errorCode = data.error_code || 'unknown_error';
-    const errorMessage = data.error_message || data.error || 'Unknown error';
-    return new WebcrawlerApiError(errorCode, errorMessage, response.status);
-}

package/dist/model.d.ts

@@ -1,62 +0,0 @@
-export interface ScrapeRequest {
-    input: any;
-    crawler_id: string;
-    max_retries?: number;
-    debug?: boolean;
-    omit_cache?: boolean;
-}
-export interface JobId {
-    id: string;
-}
-export interface ScrapeResponse {
-    id: string;
-    url: string;
-    status: any;
-    page_status_code: number;
-    created_at: string;
-    structured_data: any;
-    recommended_pull_delay_ms: number;
-}
-export interface CrawlRequest {
-    url: string;
-    items_limit?: number;
-    scrape_type?: string;
-    whitelist_regexp?: string;
-    blacklist_regexp?: string;
-    allow_subdomains?: boolean;
-    webhook_url?: string;
-}
-export interface Job {
-    id: string;
-    org_id: string;
-    url: string;
-    status: string;
-    scrape_type: string;
-    whitelist_regexp: string;
-    blacklist_regexp: string;
-    allow_subdomains: boolean;
-    items_limit: number;
-    created_at: string;
-    finished_at: string;
-    updated_at: string;
-    webhook_url: string;
-    recommended_pull_delay_ms: number;
-    job_items: JobItem[];
-}
-export interface JobItem {
-    id: string;
-    job_id: string;
-    original_url: string;
-    page_status_code: number;
-    markdown_content_url: string;
-    status: string;
-    title: string;
-    last_error: string;
-    created_at: string;
-    updated_at: string;
-    cost: number;
-    referred_url: string;
-    raw_content_url?: string;
-    cleaned_content_url?: string;
-    getContent(): Promise<string | null>;
-}

package/dist/model.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/index.ts

@@ -1,4 +0,0 @@
-export * from "./api";
-export * from "./model";
-export * from "./constants";
-export * from "./errors";