@nxcode/sdk 1.0.0

package/dist/nxcode.esm.js

@@ -0,0 +1,635 @@
+/**
+ * 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;
+}
+
+export { Nxcode, Nxcode as default };
+//# sourceMappingURL=nxcode.esm.js.map