# JavaScript Projects

### Prerequisites

* Node.js environment (for backend) or modern web browser (for frontend)
* npm or yarn package manager
* SunLicense API credentials

### Integration Steps

#### 1. Backend Implementation (Node.js)

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

class SunLicenseValidator {
    constructor(licenseKey, productId, version = '1.0.0') {
        this.licenseKey = licenseKey;
        this.productId = productId;
        this.version = version;
        this.apiUrl = 'YOUR_API_URL/api/v1/validate';
    }

    async validate() {
        try {
            const payload = {
                licenseKey: this.licenseKey,
                productId: this.productId,
                productVersion: this.version,
                hwid: this.getHWID(), // Optional
                operatingSystem: process.platform,
                operatingSystemVersion: process.version
            };

            const response = await axios.post(this.apiUrl, payload, {
                headers: { 'Content-Type': 'application/json' }
            });

            return response.status === 200;
        } catch (error) {
            throw new Error(`License validation failed: ${error.message}`);
        }
    }

    getHWID() {
        // Implement your HWID generation logic here
        return 'YOUR-HWID';
    }
}

// Usage example
const validator = new SunLicenseValidator('YOUR-LICENSE-KEY', YOUR_PRODUCT_ID);
validator.validate()
    .then(() => console.log('License valid!'))
    .catch(error => console.error(error));
```

#### 2. Frontend Implementation (Browser)

```javascript
class SunLicenseValidator {
    constructor(licenseKey, productId, version = '1.0.0') {
        this.licenseKey = licenseKey;
        this.productId = productId;
        this.version = version;
        this.apiUrl = 'YOUR_API_URL/api/v1/validate';
    }

    async validate() {
        try {
            const payload = {
                licenseKey: this.licenseKey,
                productId: this.productId,
                productVersion: this.version,
                operatingSystem: navigator.platform,
                operatingSystemVersion: navigator.userAgent
            };

            const response = await fetch(this.apiUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(payload)
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            return true;
        } catch (error) {
            throw new Error(`License validation failed: ${error.message}`);
        }
    }
}
```

#### 3. Integration with Popular Frameworks

**Express.js Middleware**

```javascript
function licensingMiddleware(licenseKey, productId) {
    const validator = new SunLicenseValidator(licenseKey, productId);
    
    return async (req, res, next) => {
        try {
            await validator.validate();
            next();
        } catch (error) {
            res.status(403).json({ error: 'Invalid license' });
        }
    };
}

// Usage in Express app
app.use(licensingMiddleware('YOUR-LICENSE-KEY', YOUR_PRODUCT_ID));
```

**React Component**

```javascript
import React, { useState, useEffect } from 'react';

function LicenseProtectedApp({ licenseKey, productId, children }) {
    const [isValid, setIsValid] = useState(false);
    const [error, setError] = useState(null);

    useEffect(() => {
        const validator = new SunLicenseValidator(licenseKey, productId);
        validator.validate()
            .then(() => setIsValid(true))
            .catch(err => setError(err.message));
    }, [licenseKey, productId]);

    if (error) return <div>License Error: {error}</div>;
    if (!isValid) return <div>Validating license...</div>;
    return children;
}
```

### Best Practices

1. **Security**
   * Never expose license key in frontend code
   * Implement server-side validation
   * Use secure communication (HTTPS)
2. **Error Handling**
   * Implement proper error handling
   * Show user-friendly error messages
   * Log validation failures
3. **Performance**
   * Cache validation results
   * Implement retry mechanisms
   * Handle offline scenarios

### Common Issues and Solutions

1. **CORS Issues**
   * Configure proper CORS headers
   * Use proxy for API requests
   * Handle preflight requests
2. **Network Problems**
   * Implement timeout handling
   * Add retry logic
   * Cache validation results