WURFL Microservice Client

https://github.com/wurfl/wurfl-microservice-client-nodejs
Admin
WURFL Microservice Client is a Node.js API for accessing the WURFL Microservice, enabling rapid and...
Tokens:6,762
Snippets:33
Trust Score:8.2
Update:7 months ago
Show doc for...
Tokens:
Raw
### Get All Versions for an OS (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Fetches all known versions for a specified operating system. This Node.js example uses the 'wmclient' library and includes error handling for the API request. The returned versions are sorted alphabetically.

```javascript
const wmclient = require('wmclient');

async function listOsVersions() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const osName = 'Android';

    try {
        const versions = await client.getAllVersionsForOS(osName);

        // Sort versions
        versions.sort();

        console.log(`${osName} versions:`, versions.length);
        console.log('Version list:');

        for (const version of versions) {
            console.log(' -', version);
        }
    } catch (error) {
        console.error(`Error listing versions for ${osName}:`, error.message);
    }
}
```

--------------------------------

### Node.js: Get WURFL Microservice Info (Callbacks - Pre v3.0.0)

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

Illustrates the older method of getting WURFL Microservice information using callbacks, as implemented in versions prior to 3.0.0. Applications using older versions will need to adapt to the new async/await pattern.

```javascript
client.getInfo(function (info, error) {
    // do something...
})
```

--------------------------------

### Node.js: Get WURFL Microservice Info (Async/Await)

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

Demonstrates how to retrieve information from the WURFL Microservice using the Node.js client with the async/await syntax. This method replaces the older callback-based approach introduced in version 3.0.0.

```javascript
let info = await client.getInfo()
// do something
```

--------------------------------

### Get All Devices for a Make (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Fetches all device models and marketing names for a specified brand. This function uses the 'wmclient' library and handles potential errors during the API call. The results are sorted by model name.

```javascript
const wmclient = require('wmclient');

async function listDevicesForMake() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const brandName = 'Apple';

    try {
        const devices = await client.getAllDevicesForMake(brandName);

        // Sort by model name
        devices.sort((a, b) => a.modelName.localeCompare(b.modelName));

        console.log(`Total ${brandName} devices:`, devices.length);
        console.log('Models:');

        for (const device of devices) {
            let name = ` - ${device.modelName}`;
            if (device.marketingName) {
                name += ` (${device.marketingName})`;
            }
            console.log(name);
        }
    } catch (error) {
        console.error('Error:', error.message);
    }
}
```

--------------------------------

### GET /v2/getinfo

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Retrieves metadata about the running WURFL Microservice instance, including API versions, data file information, and available capabilities.

```APIDOC
## GET /v2/getinfo

### Description
Returns information about the running WM server including WURFL API version, server version, WURFL data file info, and lists of available static and virtual capabilities.

### Method
GET

### Endpoint
/v2/getinfo

### Response
#### Success Response (200)
- **wurflAPIVersion** (string) - The version of the WURFL API.
- **wmVersion** (string) - The version of the WURFL Microservice server.
- **wurflInfo** (string) - Information about the loaded WURFL data file.
- **importantHeaders** (array) - List of HTTP headers used for detection.
- **staticCaps** (array) - List of available static capabilities.
- **virtualCaps** (array) - List of available virtual capabilities.

#### Response Example
{
  "wurflAPIVersion": "1.12.0.0",
  "wmVersion": "2.3.0",
  "wurflInfo": "wurfl-2024-09-01",
  "importantHeaders": ["User-Agent", "X-UCBrowser-UA"],
  "staticCaps": [...],
  "virtualCaps": [...]
}
```

--------------------------------

### Get All Operating Systems (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Retrieves a sorted list of all unique device operating systems available in the WURFL database. This function utilizes the 'wmclient' library to communicate with the WURFL microservice.

```javascript
const wmclient = require('wmclient');

async function listOperatingSystems() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const oses = await client.getAllOSes();

    // Sort alphabetically
    oses.sort();

    console.log('Total operating systems:', oses.length);
    console.log('OS list:');

    for (const os of oses) {
        console.log(' -', os);
    }
}
```

--------------------------------

### Configure Requested Capabilities in Node.js WURFL Client

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Sets specific static and virtual capabilities to be requested from the WURFL server, optimizing response size and performance. This example uses the 'wmclient' library and demonstrates how to check for capability availability before making a lookup.

```javascript
const wmclient = require('wmclient');

async function setCapabilities() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    // Set specific static capabilities to request
    client.setRequestedStaticCapabilities([
        'brand_name',
        'model_name',
        'device_os',
        'device_os_version',
        'resolution_width',
        'resolution_height'
    ]);

    // Set specific virtual capabilities to request
    client.setRequestedVirtualCapabilities([
        'is_smartphone',
        'is_mobile',
        'form_factor',
        'is_app',
        'is_full_desktop'
    ]);

    // Check if a capability exists before using
    if (client.hasStaticCapability('brand_name')) {
        console.log('brand_name capability is available');
    }

    if (client.hasVirtualCapability('is_smartphone')) {
        console.log('is_smartphone virtual capability is available');
    }

    // Now lookups will only return the specified capabilities
    const device = await client.lookupUserAgent('Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X)');
    console.log('Capabilities returned:', Object.keys(device.capabilities).length);
}

```

--------------------------------

### Get All Device Makes (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Retrieves a sorted list of all unique device manufacturer/brand names from the WURFL database. It requires the 'wmclient' library and connects to a WURFL microservice instance.

```javascript
const wmclient = require('wmclient');

async function listDeviceMakes() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const deviceMakes = await client.getAllDeviceMakes();

    // Sort alphabetically
    deviceMakes.sort();

    console.log('Total device brands:', deviceMakes.length);
    console.log('First 20 brands:');

    for (let i = 0; i < Math.min(20, deviceMakes.length); i++) {
        console.log(' -', deviceMakes[i]);
    }
}
```

--------------------------------

### Integrate WURFL Device Detection into Node.js HTTP Server

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

This Node.js code snippet illustrates how to integrate WURFL device detection into a standard HTTP server. It initializes the WURFL client once and then uses it to detect devices from incoming requests, returning detection results as JSON. The example also includes a graceful shutdown mechanism.

```javascript
const wmclient = require('wmclient');
const http = require('http');
const url = require('url');

let client;

async function startServer() {
    // Initialize client once at startup
    try {
        client = await wmclient.create('http:', 'localhost', '8080', '');
        client.setCacheSize(50000);
        console.log('WURFL client initialized');
    } catch (error) {
        console.error('Failed to initialize WURFL client:', error.message);
        process.exit(1);
    }

    const server = http.createServer(async (req, res) => {
        try {
            // Detect device from incoming request
            const device = await client.lookupRequest(req);

            const result = {
                brand: device.capabilities['brand_name'],
                model: device.capabilities['model_name'],
                is_mobile: device.capabilities['is_mobile'],
                is_smartphone: device.capabilities['is_smartphone'],
                form_factor: device.capabilities['form_factor'],
                device_os: device.capabilities['device_os'],
                wurfl_id: device.capabilities['wurfl_id']
            };

            console.log('Detected:', result.brand, result.model);

            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(result, null, 2));

        } catch (error) {
            console.error('Detection error:', error.message);
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: error.message }));
        }

        // Graceful shutdown with ?shut=y parameter
        const query = url.parse(req.url, true).query;
        if (query.shut === 'y') {
            console.log('Shutting down server');
            process.exit(0);
        }
    });

    server.listen(19080, () => {
        console.log('Server running on http://localhost:19080');
    });
}

startServer();

```

--------------------------------

### Jest Configuration for Axios ESM (JSON)

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

This JSON configuration snippet is used within a Jest test setup to map the axios ES module to its CommonJS bundle. This resolves 'Unexpected token import' errors when Jest encounters the ESM build of axios.

```json
{
  "jest": {
    "moduleNameMapper": {
      "^axios$": "axios/dist/node/axios.cjs"
    }
  }
}
```

--------------------------------

### Set HTTP Timeout for WURFL Client (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

This Node.js example demonstrates how to configure the connection and transfer timeouts for HTTP requests made to the WURFL microservice. It shows setting a custom timeout value and retrieving the client API version. The minimum allowed timeout is 10,000 milliseconds.

```javascript
const wmclient = require('wmclient');

async function configureTimeout() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    // Set timeout to 30 seconds (default is 10 seconds)
    client.setHTTPTimeout(30000);

    // Get client API version
    const apiVersion = client.getApiVersion();
    console.log('Client API version:', apiVersion);
    // Output: Client API version: 3.2.2

    // Perform detection with configured timeout
    const device = await client.lookupUserAgent('Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X)');
    console.log('Detection successful:', device.capabilities['brand_name']);
}
```

--------------------------------

### Initialize and Use WURFL Microservice Client

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

Demonstrates how to instantiate the WURFL client, retrieve server metadata, perform device detection using HTTP request headers, and query device manufacturer/model lists.

```javascript
let wmclient = require('wmclient')
const http = require("http")

const example = async () => {
    let client = await wmclient.create('http:', 'localhost', '8080', '')
    
    // Get server info
    let info = await client.getInfo()
    console.log('WURFL API version: ' + info.wurflAPIVersion)

    // Perform device detection
    let req_headers = { 'user-agent': 'Mozilla/5.0...' }
    let options = { protocol: 'http:', host: 'localhost', port: '8080', method: 'POST', path: '/' }
    let req = http.request(options)
    req.headers = req_headers
    req.end()

    let device = await client.lookupRequest(req)
    console.log('WURFL device id ' + device.capabilities['wurfl_id'])

    // Get device manufacturers
    let deviceMakes = await client.getAllDeviceMakes()
    console.log("Brands: " + deviceMakes.length)

    // Get devices for specific brand
    let devsForMake = await client.getAllDevicesForMake("Apple")
}
```

--------------------------------

### Fetch and Print OS Names and Versions (Node.js)

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

This code snippet demonstrates how to fetch all operating system names and then retrieve and print all versions for a specific OS (e.g., Android) using the WURFL client. It includes error handling for version retrieval.

```javascript
    // Get all operative system names
    let oses = await client.getAllOSes()
    // Sort and print all OS names
    console.log("Print the list of OSes")
    oses.sort()
    for (let i = 0; i < oses.length; i++) {
        console.log(" - " + oses[i])
    }

    // Get all Android OS versions
    let os = 'Android'
    try {
        let versions = await client.getAllVersionsForOS(os)
        // Sort all os version numbers and print them.
        separate()
        console.log(`Print all versions for the ${os} OS`)
        versions.sort()
        for (var i = 0; i < versions.length; i++) {
            console.log(" - " + versions[i])
        }
    }
    catch (error){
        console.log(`Error listing versions for ${os}  OS: ${error.message}`)
    }
}
// Run the example
example().then().catch()
```

--------------------------------

### Perform Device Lookup and Info Retrieval using Promises

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Demonstrates how to initialize the WURFL client and chain operations to perform User-Agent lookups and retrieve API version information. This approach uses standard .then() and .catch() blocks to handle asynchronous results and potential errors.

```javascript
const wmclient = require('wmclient');

// Using promises instead of async/await
wmclient.create('http:', 'localhost', '8080', '')
    .then((client) => {
        const userAgent = 'Mozilla/5.0 (Linux; Android 10; GM1911) AppleWebKit/537.36 Chrome/83.0.4103.106 Mobile Safari/537.36';

        return client.lookupUserAgent(userAgent);
    })
    .then((device) => {
        console.log(`Detected: ${device.capabilities['brand_name']} ${device.capabilities['model_name']}`);
        // Output: Detected: OnePlus 7 Pro
    })
    .catch((error) => {
        console.error('ERROR:', error.message);
    });

// Chained promise operations
wmclient.create('http:', 'localhost', '8080', '')
    .then((client) => {
        return client.getInfo();
    })
    .then((info) => {
        console.log('WURFL API Version:', info.wurflAPIVersion);
        console.log('Server Version:', info.wmVersion);
    })
    .catch((error) => {
        console.error('Error:', error.message);
    });
```

--------------------------------

### Initialize WURFL Microservice Client

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Creates and configures a WmClient instance to connect to a WURFL Microservice server. The initialization process automatically fetches static and virtual capabilities from the server.

```javascript
const wmclient = require('wmclient');

async function initClient() {
    try {
        // Create client connected to local WM server
        const client = await wmclient.create('http:', 'localhost', '8080', '');

        console.log('Client created successfully');
        console.log('Static capabilities loaded:', client.staticCaps.length);
        console.log('Virtual capabilities loaded:', client.virtualCaps.length);

        return client;
    } catch (error) {
        console.error('Error creating WURFL Microservice client:', error.message);
        process.exit(1);
    }
}

// With base URI path
const clientWithPath = await wmclient.create('https:', 'wm.example.com', '443', 'api/v2');
```

--------------------------------

### Lookup Device using User Agent (Node.js Promises)

Source: https://github.com/wurfl/wurfl-microservice-client-nodejs/blob/master/README.md

This Node.js code snippet demonstrates how to use the WURFL client with Promises to look up device capabilities based on a user agent string. It shows how to create a client instance and handle the device lookup promise.

```javascript
const wmclient = require('wmclient')
const clientPromise = wmclient.create('http:', 'localhost','8080','')
clientPromise.then((client) => {
    let userAgent = 'Mozilla/5.0 (Linux; Android 10; GM1911 Build/QKQ1.190716.003; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.106 Mobile Safari/537.36 Instagram 146.0.0.27.125 Android (29/10; 560dpi; 1440x3064; OnePlus; GM1911; OnePlus7Pro; qcom; en_US; 221134037)'
    let device_promise = client.lookupUserAgent(userAgent)
    device_promise.then((device) => {
        console.log(`Detected device ${device.capabilities['brand_name']} ${device.capabilities['model_name']}`)
    }).catch((error) => {
        console.log('ERROR: ' + error.message)
    })
})
```

--------------------------------

### POST /v2/lookupuseragent

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Performs device detection by analyzing a provided User-Agent string against the WURFL device database.

```APIDOC
## POST /v2/lookupuseragent

### Description
Searches WURFL device data using a User-Agent string for detection. Returns device capabilities and identification data.

### Method
POST

### Endpoint
/v2/lookupuseragent

### Request Body
- **user_agent** (string) - Required - The User-Agent string to be analyzed.

### Request Example
{
  "user_agent": "Mozilla/5.0 (Linux; Android 10; GM1911...)"
}

### Response
#### Success Response (200)
- **capabilities** (object) - A map of detected device capabilities (e.g., brand_name, model_name, is_mobile).

#### Response Example
{
  "capabilities": {
    "wurfl_id": "oneplus_gm1911_ver1",
    "brand_name": "OnePlus",
    "model_name": "7 Pro",
    "is_mobile": true,
    "form_factor": "Smartphone"
  }
}
```

--------------------------------

### Detect Device from HTTP Request using Node.js

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Detects a device by analyzing a complete HTTP request object, including headers and proxy headers. This method leverages the 'wmclient' library and Node.js's built-in 'http' module. It requires the WURFL microservice to be running and accessible.

```javascript
const wmclient = require('wmclient');
const http = require('http');

async function detectFromRequest() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    // Simulated request headers (lowercase per Node.js standard)
    const req_headers = {
        'user-agent': 'Opera/9.80 (Android; Opera Mini/51.0.2254/184.121; U; en) Presto/2.12.423 Version/12.16',
        'device-stock-ua': 'Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/69.0.3497.100 Mobile Safari/537.36',
        'x-forwarded-for': '110.54.224.195, 82.145.210.235',
        'x-operamini-phone': 'Android #',
        'x-operamini-phone-ua': 'Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36'
    };

    const options = {
        protocol: 'http:',
        host: 'localhost',
        port: '8080',
        method: 'POST',
        path: '/'
    };

    const req = http.request(options);
    req.headers = req_headers;
    req.end();

    try {
        const device = await client.lookupRequest(req);

        console.log('WURFL ID:', device.capabilities['wurfl_id']);
        console.log('Brand & Model:', device.capabilities['brand_name'], device.capabilities['model_name']);

        if (device.capabilities['is_smartphone'] === 'true') {
            console.log('Device type: Smartphone');
        }

        // Print all capabilities
        for (const key in device.capabilities) {
            console.log(`${key}: ${device.capabilities[key]}`);
        }
    } catch (error) {
        console.error('Error detecting device:', error.message);
    }
}

```

--------------------------------

### Perform Device Detection via User-Agent

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Queries the WURFL Microservice using a specific User-Agent string to retrieve detailed device capabilities. Returns an object containing identification data such as brand, model, and OS information.

```javascript
const wmclient = require('wmclient');

async function detectByUserAgent() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const userAgent = 'Mozilla/5.0 (Linux; Android 10; GM1911 Build/QKQ1.190716.003; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.106 Mobile Safari/537.36 Instagram 146.0.0.27.125 Android';

    try {
        const device = await client.lookupUserAgent(userAgent);

        console.log('WURFL ID:', device.capabilities['wurfl_id']);
        console.log('Brand:', device.capabilities['brand_name']);
        console.log('Model:', device.capabilities['model_name']);
        console.log('Is Mobile:', device.capabilities['is_mobile']);
        console.log('Is Smartphone:', device.capabilities['is_smartphone']);
        console.log('Form Factor:', device.capabilities['form_factor']);
        console.log('Device OS:', device.capabilities['device_os']);
        console.log('Device OS Version:', device.capabilities['device_os_version']);
    } catch (error) {
        console.error('Detection error:', error.message);
    }
}
```

--------------------------------

### Lookup Device Information by WURFL Device ID using Node.js

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Retrieves WURFL device information by providing a known WURFL device ID. This function uses the 'wmclient' library and is useful when the device ID is already available. It requires a running WURFL microservice.

```javascript
const wmclient = require('wmclient');

async function detectByDeviceId() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    const wurflId = 'apple_iphone_ver14_subhw15promax';

    try {
        const device = await client.lookupDeviceID(wurflId);

        console.log('WURFL ID:', device.capabilities['wurfl_id']);
        console.log('Brand:', device.capabilities['brand_name']);
        console.log('Model:', device.capabilities['model_name']);
        console.log('Marketing Name:', device.capabilities['marketing_name']);
        console.log('Resolution Width:', device.capabilities['resolution_width']);
        console.log('Resolution Height:', device.capabilities['resolution_height']);

        // Output:
        // WURFL ID: apple_iphone_ver14_subhw15promax
        // Brand: Apple
        // Model: iPhone 15 Pro Max
    } catch (error) {
        console.error('Device ID lookup error:', error.message);
    }
}

```

--------------------------------

### Retrieve WURFL Server Information

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

Fetches metadata from the connected WURFL Microservice server, including API versions, data file information, and lists of available capabilities. This is useful for verifying server connectivity and configuration.

```javascript
const wmclient = require('wmclient');

async function getServerInfo() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    try {
        const info = await client.getInfo();

        console.log('WURFL API version:', info.wurflAPIVersion);
        console.log('WM server version:', info.wmVersion);
        console.log('WURFL file info:', info.wurflInfo);
        console.log('Important headers:', info.importantHeaders);
        console.log('Static capabilities:', info.staticCaps.length);
        console.log('Virtual capabilities:', info.virtualCaps.length);
        console.log('Last update time:', info.ltime);
    } catch (error) {
        console.error('Unable to load WURFL Info:', error.message);
    }
}
```

--------------------------------

### Configure LRU Cache for WURFL Device Detection (Node.js)

Source: https://context7.com/wurfl/wurfl-microservice-client-nodejs/llms.txt

This snippet shows how to enable and configure LRU caching for WURFL device detection in Node.js. It sets the cache size for User-Agent lookups, improving performance by storing recent detection results. The cache is automatically managed, but can also be cleared manually.

```javascript
const wmclient = require('wmclient');
const fs = require('fs');
const readline = require('readline');

async function massiveDetectionWithCache() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');

    // Enable cache with 100,000 entries for User-Agent cache
    // Device ID cache is automatically set to 20,000 entries
    client.setCacheSize(100000);

    const userAgentFile = './user-agents.txt';
    const start = Date.now();
    let count = 0;

    const reader = readline.createInterface({
        input: fs.createReadStream(userAgentFile),
        terminal: false
    });

    reader.on('line', async (line) => {
        try {
            // Cached lookups will be much faster
            const device = await client.lookupUserAgent(line);
            const brandModel = device.capabilities['brand_name'] + ' ' + device.capabilities['model_name'];
            console.log(`Detected: ${brandModel || 'GENERIC'}`);
            count++;
        } catch (error) {
            console.error('Detection error:', error.message);
        }
    });

    reader.on('close', () => {
        const elapsed = Date.now() - start;
        console.log(`Processed ${count} devices in ${elapsed}ms`);
    });
}

// Clear caches manually when needed
async function clearCache() {
    const client = await wmclient.create('http:', 'localhost', '8080', '');
    client.setCacheSize(50000);

    // Perform detections...

    // Clear all caches (User-Agent cache, Device ID cache, and internal maps)
    client.clearCaches();
}
```
Tokens:
Raw