syntro-js-client 1.0.0

package/index.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const BASE_URL = process.env.SYNTRO_API_URL || 'https://api.syntro.fun';
+
+class Syntro {
+    constructor(apiKey) {
+        if (!apiKey) throw new Error('Syntro: apiKey is required');
+        this.apiKey = apiKey;
+        this._token = null;
+    }
+
+    async _request(method, path, body, useJwt = false) {
+        const headers = { 'Content-Type': 'application/json' };
+
+        if (useJwt && this._token) {
+            headers['Authorization'] = `Bearer ${this._token}`;
+        } else {
+            headers['x-api-key'] = this.apiKey;
+        }
+
+        const response = await fetch(`${BASE_URL}/api/v1${path}`, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+
+        const data = await response.json();
+
+        if (!response.ok) {
+            const error = new Error(data.message || 'Syntro API error');
+            error.statusCode = response.status;
+            error.data = data;
+            throw error;
+        }
+
+        return data;
+    }
+
+    async login(email, password) {
+        const result = await this._request('POST', '/auth/login', { email, password });
+        this._token = result.accessToken;
+        return result;
+    }
+
+    async register(email, password, extra = {}) {
+        return this._request('POST', '/auth/register', { email, password, ...extra });
+    }
+
+    async socialLogin(provider) {
+        const supported = ['google', 'github'];
+        if (!supported.includes(provider)) {
+            throw new Error(`Syntro: unsupported provider "${provider}". Supported: ${supported.join(', ')}`);
+        }
+        return { redirectUrl: `${BASE_URL}/api/v1/auth/social/${provider}?apiKey=${this.apiKey}` };
+    }
+
+    async forgotPassword(email) {
+        return this._request('POST', '/auth/forgot-password', { email });
+    }
+
+    async resetPassword(token, password) {
+        return this._request('POST', '/auth/reset-password', { token, password });
+    }
+
+    async me() {
+        return this._request('GET', '/auth/me', null, true);
+    }
+
+    async createBilling(name, description, amount, methods = ['card'], options = {}) {
+        return this._request('POST', '/billing/create', {
+            name,
+            description,
+            amount,
+            currency: options.currency || 'usd',
+            methods,
+            successUrl: options.successUrl,
+            cancelUrl: options.cancelUrl,
+        });
+    }
+
+    async trackEvent(type, payload = {}) {
+        return this._request('POST', '/events', { type, payload });
+    }
+
+    async getEvents(params = {}) {
+        const qs = new URLSearchParams(params).toString();
+        return this._request('GET', `/events${qs ? '?' + qs : ''}`);
+    }
+
+    async getStats() {
+        return this._request('GET', '/stats');
+    }
+
+    async updateStat(metric, value) {
+        return this._request('PUT', '/stats', { metric, value });
+    }
+}
+
+module.exports = { Syntro };

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "syntro-js-client",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for Syntro — plug-and-play auth, billing, and analytics for your SaaS.",
+  "main": "index.js",
+  "keywords": [
+    "syntro",
+    "auth",
+    "billing",
+    "analytics",
+    "saas"
+  ],
+  "author": "Syntro",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  }
+}

package/react.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const React = require('react');
+
+const SyntroContext = React.createContext(null);
+
+const SyntroProvider = ({ client, children }) => {
+    const [user, setUser] = React.useState(null);
+    const [loading, setLoading] = React.useState(true);
+
+    React.useEffect(() => {
+        if (!client) {
+            setLoading(false);
+            return;
+        }
+
+        // Check if token exists or check local storage
+        client.me()
+            .then(data => setUser(data))
+            .catch(() => setUser(null))
+            .finally(() => setLoading(false));
+    }, [client]);
+
+    const value = React.useMemo(() => ({ user, loading, client }), [user, loading, client]);
+
+    return React.createElement(SyntroContext.Provider, { value }, children);
+};
+
+const useSyntro = () => {
+    const context = React.useContext(SyntroContext);
+    if (!context) {
+        throw new Error('useSyntro must be used within a SyntroProvider');
+    }
+    return context;
+};
+
+const SyntroProtected = ({ fallback = null, redirectTo = null, children }) => {
+    const { user, loading } = useSyntro();
+
+    React.useEffect(() => {
+        if (!loading && !user && redirectTo) {
+            if (typeof window !== 'undefined') {
+                window.location.href = redirectTo;
+            }
+        }
+    }, [user, loading, redirectTo]);
+
+    if (loading) return null;
+
+    if (!user) {
+        return fallback;
+    }
+
+    return children;
+};
+
+module.exports = {
+    SyntroProvider,
+    useSyntro,
+    SyntroProtected
+};