@nxcode/sdk 1.0.0

package/dist/nxcode.js

@@ -0,0 +1,646 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Nxcode = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Nxcode SDK - Authentication Module
+     */
+    const STORAGE_KEY = 'nxcode_sdk_auth';
+    class NxcodeAuth {
+        constructor(apiEndpoint, appId) {
+            this.user = null;
+            this.token = null;
+            this.refreshToken = null;
+            this.expiresAt = null;
+            this.authCallbacks = [];
+            this.popupWindow = null;
+            this.messageHandler = null;
+            this.apiEndpoint = apiEndpoint;
+            this.appId = appId;
+            this.loadFromStorage();
+            this.setupMessageListener();
+        }
+        /**
+         * Initiate login flow via OAuth popup
+         */
+        async login(provider = 'google') {
+            return new Promise((resolve, reject) => {
+                // Open popup
+                const width = 500;
+                const height = 600;
+                const left = window.screenX + (window.outerWidth - width) / 2;
+                const top = window.screenY + (window.outerHeight - height) / 2;
+                const loginUrl = `${this.apiEndpoint}/api/sdk/auth/login?app_id=${this.appId}&provider=${provider}`;
+                this.popupWindow = window.open(loginUrl, 'nxcode_login', `width=${width},height=${height},left=${left},top=${top}`);
+                if (!this.popupWindow) {
+                    reject(new Error('Failed to open login popup. Please allow popups for this site.'));
+                    return;
+                }
+                // Set up timeout
+                const timeout = setTimeout(() => {
+                    this.popupWindow?.close();
+                    reject(new Error('Login timeout'));
+                }, 120000); // 2 minute timeout
+                // Wait for message from popup
+                const handleMessage = (event) => {
+                    if (event.data?.type !== 'NXCODE_SDK_AUTH')
+                        return;
+                    clearTimeout(timeout);
+                    window.removeEventListener('message', handleMessage);
+                    const result = event.data.payload;
+                    if (result.success && result.user && result.token) {
+                        this.setAuth(result);
+                        resolve(result.user);
+                    }
+                    else {
+                        reject(new Error(result.error || 'Login failed'));
+                    }
+                };
+                window.addEventListener('message', handleMessage);
+            });
+        }
+        /**
+         * Logout and clear session
+         */
+        async logout() {
+            try {
+                if (this.token) {
+                    await fetch(`${this.apiEndpoint}/api/sdk/auth/logout`, {
+                        method: 'POST',
+                        headers: this.getHeaders(),
+                    });
+                }
+            }
+            catch (error) {
+                console.warn('Logout request failed:', error);
+            }
+            this.clearAuth();
+        }
+        /**
+         * Get current user
+         */
+        getUser() {
+            return this.user;
+        }
+        /**
+         * Get current auth token
+         */
+        getToken() {
+            // Check if token is expired
+            if (this.expiresAt && new Date() > this.expiresAt) {
+                // Token is expired, need to refresh
+                // Start refresh in background but don't return the expired token
+                this.refreshSession().catch(console.error);
+                // Return null to force re-auth rather than using expired token
+                return null;
+            }
+            return this.token;
+        }
+        /**
+         * Get token, refreshing if needed (async version)
+         */
+        async getValidToken() {
+            if (this.expiresAt && new Date() > this.expiresAt) {
+                await this.refreshSession();
+            }
+            return this.token;
+        }
+        /**
+         * Register callback for auth state changes
+         */
+        onAuthStateChange(callback) {
+            this.authCallbacks.push(callback);
+            // Call immediately with current state
+            callback(this.user);
+            // Return unsubscribe function
+            return () => {
+                const index = this.authCallbacks.indexOf(callback);
+                if (index > -1) {
+                    this.authCallbacks.splice(index, 1);
+                }
+            };
+        }
+        /**
+         * Check if user is logged in
+         */
+        isLoggedIn() {
+            return this.user !== null && this.token !== null;
+        }
+        /**
+         * Refresh the current session
+         */
+        async refreshSession() {
+            if (!this.refreshToken) {
+                this.clearAuth();
+                return;
+            }
+            try {
+                const response = await fetch(`${this.apiEndpoint}/api/sdk/auth/refresh`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-App-Id': this.appId,
+                    },
+                    body: JSON.stringify({ refreshToken: this.refreshToken }),
+                });
+                if (!response.ok) {
+                    throw new Error('Refresh failed');
+                }
+                const data = await response.json();
+                this.setAuth({
+                    success: true,
+                    token: data.token,
+                    refreshToken: data.refreshToken,
+                    expiresAt: data.expiresAt,
+                    user: data.user,
+                });
+            }
+            catch (error) {
+                console.error('Session refresh failed:', error);
+                this.clearAuth();
+            }
+        }
+        /**
+         * Fetch current user info from server
+         */
+        async fetchUser() {
+            if (!this.token)
+                return null;
+            try {
+                const response = await fetch(`${this.apiEndpoint}/api/sdk/auth/me`, {
+                    headers: this.getHeaders(),
+                });
+                if (!response.ok) {
+                    if (response.status === 401) {
+                        await this.refreshSession();
+                        return this.user;
+                    }
+                    throw new Error('Failed to fetch user');
+                }
+                const user = await response.json();
+                this.user = user;
+                this.notifyAuthChange();
+                this.saveToStorage();
+                return user;
+            }
+            catch (error) {
+                console.error('Failed to fetch user:', error);
+                return null;
+            }
+        }
+        // ==================== Private Methods ====================
+        setAuth(result) {
+            if (result.success && result.user && result.token) {
+                this.user = result.user;
+                this.token = result.token;
+                this.refreshToken = result.refreshToken || null;
+                this.expiresAt = result.expiresAt ? new Date(result.expiresAt) : null;
+                this.saveToStorage();
+                this.notifyAuthChange();
+            }
+        }
+        clearAuth() {
+            this.user = null;
+            this.token = null;
+            this.refreshToken = null;
+            this.expiresAt = null;
+            localStorage.removeItem(`${STORAGE_KEY}_${this.appId}`);
+            this.notifyAuthChange();
+        }
+        saveToStorage() {
+            if (this.user && this.token) {
+                const data = {
+                    token: this.token,
+                    refreshToken: this.refreshToken || '',
+                    expiresAt: this.expiresAt?.toISOString() || '',
+                    user: this.user,
+                };
+                localStorage.setItem(`${STORAGE_KEY}_${this.appId}`, JSON.stringify(data));
+            }
+        }
+        loadFromStorage() {
+            try {
+                const stored = localStorage.getItem(`${STORAGE_KEY}_${this.appId}`);
+                if (stored) {
+                    const data = JSON.parse(stored);
+                    this.token = data.token;
+                    this.refreshToken = data.refreshToken;
+                    this.expiresAt = data.expiresAt ? new Date(data.expiresAt) : null;
+                    this.user = data.user;
+                    // Check if expired
+                    if (this.expiresAt && new Date() > this.expiresAt) {
+                        this.refreshSession().catch(() => this.clearAuth());
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Failed to load auth from storage:', error);
+            }
+        }
+        notifyAuthChange() {
+            for (const callback of this.authCallbacks) {
+                try {
+                    callback(this.user);
+                }
+                catch (error) {
+                    console.error('Auth callback error:', error);
+                }
+            }
+        }
+        setupMessageListener() {
+            // Already set up message handling in login()
+        }
+        getHeaders() {
+            const headers = {
+                'Content-Type': 'application/json',
+                'X-App-Id': this.appId,
+            };
+            if (this.token) {
+                headers['Authorization'] = `Bearer ${this.token}`;
+            }
+            return headers;
+        }
+    }
+
+    /**
+     * Nxcode SDK - Billing Module
+     */
+    class NxcodeBilling {
+        constructor(apiEndpoint, appId, getToken) {
+            this.apiEndpoint = apiEndpoint;
+            this.appId = appId;
+            this.getToken = getToken;
+        }
+        /**
+         * Get user's current balance
+         */
+        async getBalance() {
+            const token = this.getToken();
+            if (!token) {
+                throw new Error('Not authenticated. Please login first.');
+            }
+            const response = await fetch(`${this.apiEndpoint}/api/sdk/billing/balance`, {
+                headers: this.getHeaders(token),
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    throw new Error('Session expired. Please login again.');
+                }
+                throw new Error('Failed to fetch balance');
+            }
+            const data = await response.json();
+            return data.balance;
+        }
+        /**
+         * Open top-up page in new tab
+         */
+        topUp() {
+            const topUpUrl = `${this.apiEndpoint}/api/sdk/billing/topup?app_id=${this.appId}`;
+            window.open(topUpUrl, '_blank');
+        }
+        // ==================== Private Methods ====================
+        getHeaders(token) {
+            return {
+                'Content-Type': 'application/json',
+                'X-App-Id': this.appId,
+                'Authorization': `Bearer ${token}`,
+            };
+        }
+    }
+
+    /**
+     * Nxcode SDK - Payment Module
+     */
+    class NxcodePayment {
+        constructor(apiEndpoint, appId, getToken) {
+            this.apiEndpoint = apiEndpoint;
+            this.appId = appId;
+            this.getToken = getToken;
+        }
+        /**
+         * Process an in-app purchase
+         *
+         * @param options - Charge options
+         * @returns Charge result with transaction details
+         */
+        async charge(options) {
+            const token = this.getToken();
+            if (!token) {
+                return {
+                    success: false,
+                    error: 'Not authenticated. Please login first.',
+                };
+            }
+            try {
+                const response = await fetch(`${this.apiEndpoint}/api/sdk/payment/charge`, {
+                    method: 'POST',
+                    headers: this.getHeaders(token),
+                    body: JSON.stringify({
+                        amount: options.amount,
+                        description: options.description,
+                        metadata: options.metadata,
+                    }),
+                });
+                if (!response.ok) {
+                    if (response.status === 401) {
+                        return {
+                            success: false,
+                            error: 'Session expired. Please login again.',
+                        };
+                    }
+                    if (response.status === 402) {
+                        return {
+                            success: false,
+                            error: 'Insufficient balance. Please top up.',
+                        };
+                    }
+                    const errorData = await response.json().catch(() => ({}));
+                    return {
+                        success: false,
+                        error: errorData.detail || 'Payment failed',
+                    };
+                }
+                const result = await response.json();
+                return result;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Payment failed',
+                };
+            }
+        }
+        /**
+         * Get user's transaction history
+         *
+         * @param limit - Maximum number of transactions to return
+         * @param offset - Pagination offset
+         * @returns Array of transactions
+         */
+        async getTransactions(limit = 50, offset = 0) {
+            const token = this.getToken();
+            if (!token) {
+                throw new Error('Not authenticated. Please login first.');
+            }
+            const response = await fetch(`${this.apiEndpoint}/api/sdk/payment/transactions?limit=${limit}&offset=${offset}`, {
+                headers: this.getHeaders(token),
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    throw new Error('Session expired. Please login again.');
+                }
+                throw new Error('Failed to fetch transactions');
+            }
+            const data = await response.json();
+            return data.transactions;
+        }
+        // ==================== Private Methods ====================
+        getHeaders(token) {
+            return {
+                'Content-Type': 'application/json',
+                'X-App-Id': this.appId,
+                'Authorization': `Bearer ${token}`,
+            };
+        }
+    }
+
+    /**
+     * Nxcode SDK
+     *
+     * A lightweight SDK for integrating Nxcode authentication, billing,
+     * and payment features into web applications.
+     *
+     * Usage:
+     *   <script src="https://sdk.nxcode.io/v1/nxcode.js"></script>
+     *   <script>
+     *     const user = await Nxcode.auth.login();
+     *     console.log('Logged in:', user.email);
+     *   </script>
+     */
+    // API endpoint - auto-detect or use default
+    const DEFAULT_API_ENDPOINT = 'https://studio-api.nxcode.io';
+    class NxcodeSDK {
+        constructor() {
+            this.config = null;
+            this._auth = null;
+            this._billing = null;
+            this._payment = null;
+            this.initPromise = null;
+            this.apiEndpoint = this.detectApiEndpoint();
+            this.autoInit();
+        }
+        /**
+         * Auto-initialize SDK based on environment
+         */
+        async autoInit() {
+            if (this.initPromise)
+                return this.initPromise;
+            this.initPromise = this.init();
+            return this.initPromise;
+        }
+        /**
+         * Initialize SDK by fetching configuration
+         */
+        async init() {
+            try {
+                // Try to get config from server
+                const response = await fetch(`${this.apiEndpoint}/api/sdk/config`, {
+                    credentials: 'include',
+                });
+                if (response.ok) {
+                    this.config = await response.json();
+                    this.config.apiEndpoint = this.apiEndpoint;
+                    this.setupModules();
+                }
+            }
+            catch (error) {
+                console.warn('Nxcode SDK: Could not auto-detect app config. Call Nxcode.configure() manually.');
+            }
+        }
+        /**
+         * Manually configure SDK with app ID
+         */
+        configure(appId) {
+            this.config = {
+                appId,
+                name: '',
+                billingMode: 'creator_pays',
+                apiEndpoint: this.apiEndpoint,
+            };
+            this.setupModules();
+        }
+        /**
+         * Set up SDK modules after configuration
+         */
+        setupModules() {
+            if (!this.config)
+                return;
+            this._auth = new NxcodeAuth(this.config.apiEndpoint, this.config.appId);
+            this._billing = new NxcodeBilling(this.config.apiEndpoint, this.config.appId, () => this._auth?.getToken() || null);
+            this._payment = new NxcodePayment(this.config.apiEndpoint, this.config.appId, () => this._auth?.getToken() || null);
+        }
+        /**
+         * Detect API endpoint based on environment
+         */
+        detectApiEndpoint() {
+            if (typeof window !== 'undefined') {
+                const hostname = window.location.hostname;
+                // Development environment
+                if (hostname === 'localhost' || hostname === '127.0.0.1') {
+                    return 'http://localhost:8001';
+                }
+                // Check for dev environment
+                if (hostname.includes('.nxcode.dev') || hostname.includes('.nxcode.app')) {
+                    return 'https://studio-api.nxcode.io';
+                }
+            }
+            return DEFAULT_API_ENDPOINT;
+        }
+        /**
+         * Ensure SDK is initialized before operations
+         */
+        async ensureInitialized() {
+            if (this.initPromise) {
+                await this.initPromise;
+            }
+            if (!this.config) {
+                throw new Error('Nxcode SDK not configured. Add X-App-Id header or call Nxcode.configure(appId).');
+            }
+        }
+        // ==================== Auth Module ====================
+        get auth() {
+            const self = this;
+            return {
+                /**
+                 * Login via OAuth popup
+                 */
+                async login(provider = 'google') {
+                    await self.ensureInitialized();
+                    return self._auth.login(provider);
+                },
+                /**
+                 * Logout current user
+                 */
+                async logout() {
+                    await self.ensureInitialized();
+                    return self._auth.logout();
+                },
+                /**
+                 * Get current user
+                 */
+                getUser() {
+                    return self._auth?.getUser() || null;
+                },
+                /**
+                 * Get auth token for API calls
+                 */
+                getToken() {
+                    return self._auth?.getToken() || null;
+                },
+                /**
+                 * Register auth state change callback
+                 */
+                onAuthStateChange(callback) {
+                    if (!self._auth) {
+                        // Store the actual unsubscribe function when SDK initializes
+                        let actualUnsubscribe = null;
+                        let cancelled = false;
+                        // Queue callback until initialized
+                        self.ensureInitialized().then(() => {
+                            if (!cancelled && self._auth) {
+                                actualUnsubscribe = self._auth.onAuthStateChange(callback);
+                            }
+                        });
+                        // Return unsubscribe that handles both immediate and deferred cases
+                        return () => {
+                            cancelled = true;
+                            if (actualUnsubscribe) {
+                                actualUnsubscribe();
+                            }
+                        };
+                    }
+                    return self._auth.onAuthStateChange(callback);
+                },
+                /**
+                 * Check if user is logged in
+                 */
+                isLoggedIn() {
+                    return self._auth?.isLoggedIn() || false;
+                },
+            };
+        }
+        // ==================== Billing Module ====================
+        get billing() {
+            const self = this;
+            return {
+                /**
+                 * Get user's current balance
+                 */
+                async getBalance() {
+                    await self.ensureInitialized();
+                    return self._billing.getBalance();
+                },
+                /**
+                 * Open top-up page
+                 */
+                topUp() {
+                    self._billing?.topUp();
+                },
+            };
+        }
+        // ==================== Payment Module ====================
+        get payment() {
+            const self = this;
+            return {
+                /**
+                 * Process in-app purchase
+                 */
+                async charge(options) {
+                    await self.ensureInitialized();
+                    return self._payment.charge(options);
+                },
+                /**
+                 * Get transaction history
+                 */
+                async getTransactions(limit, offset) {
+                    await self.ensureInitialized();
+                    return self._payment.getTransactions(limit, offset);
+                },
+            };
+        }
+        // ==================== Utility Methods ====================
+        /**
+         * Get current configuration
+         */
+        getConfig() {
+            return this.config;
+        }
+        /**
+         * Check if SDK is ready
+         */
+        isReady() {
+            return this.config !== null && this._auth !== null;
+        }
+        /**
+         * Wait for SDK to be ready
+         */
+        async ready() {
+            await this.ensureInitialized();
+        }
+    }
+    // Create singleton instance
+    const Nxcode = new NxcodeSDK();
+    // Export for UMD (browser global)
+    if (typeof window !== 'undefined') {
+        window.Nxcode = Nxcode;
+    }
+
+    exports.Nxcode = Nxcode;
+    exports.default = Nxcode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=nxcode.js.map