@joonweb/joonweb-sdk 1.0.0

package/src/Clients/BaseClient.js

@@ -0,0 +1,66 @@
+const axios = require('axios');
+
+class BaseClient {
+    constructor(accessToken = null, siteDomain = null) {
+        this.accessToken = accessToken;
+        this.siteDomain = siteDomain;
+        this.timeout = 30000;
+        this.apiVersion = process.env.JOONWEB_API_VERSION || '26.0';
+    }
+    
+    setAccessToken(token) {
+        this.accessToken = token;
+        return this;
+    }
+    
+    setSiteDomain(domain) {
+        this.siteDomain = domain;
+        return this;
+    }
+    
+    async request(endpoint, method = 'GET', data = null, params = {}) {
+        if (!this.siteDomain) {
+            throw new Error('Site domain is not set. Call setSiteDomain() first.');
+        }
+        
+        if (!this.accessToken) {
+            throw new Error('Access token is not set. Call setAccessToken() first.');
+        }
+        
+        const url = `https://${this.siteDomain}/api/admin/${this.apiVersion}${endpoint}`;
+        
+        const config = {
+            method: method.toLowerCase(),
+            url: url,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'X-JoonWeb-Access-Token': this.accessToken
+            },
+            timeout: this.timeout,
+            params: Object.keys(params).length > 0 ? params : undefined
+        };
+        
+        if (data && ['post', 'put', 'patch'].includes(config.method)) {
+            config.data = data;
+        }
+        
+        try {
+            const response = await axios(config);
+            return response.data;
+        } catch (error) {
+            if (error.response) {
+                const apiError = new Error(
+                    `JoonWeb API Error ${error.response.status}: ${JSON.stringify(error.response.data)}`
+                );
+                apiError.status = error.response.status;
+                apiError.data = error.response.data;
+                throw apiError;
+            } else {
+                throw new Error(`JoonWeb API Request Failed: ${error.message}`);
+            }
+        }
+    }
+}
+
+module.exports = BaseClient;

package/src/Context.js

@@ -0,0 +1,82 @@
+// src/Context.js
+const path = require('path');
+
+class Context {
+    static API_KEY = null;
+    static API_SECRET_KEY = null;
+    static API_VERSION = '26.0';
+    static IS_EMBEDDED_APP = true;
+    static SESSION_STORAGE = null;
+    static APP_NAME = 'JoonWeb App';
+    static HOST_SCHEME = 'https';
+    static HOST_NAME = null;
+    
+    // New: Storage configuration
+    static SESSION_STORAGE_TYPE = 'memory'; // 'memory', 'sqlite', 'mongodb', 'redis'
+    static SESSION_STORAGE_OPTIONS = {};
+
+    static init(options = {}) {
+        this.API_KEY = options.api_key || process.env.JOONWEB_API_KEY || this.API_KEY;
+        this.API_SECRET_KEY = options.api_secret || process.env.JOONWEB_API_SECRET || this.API_SECRET_KEY;
+        this.API_VERSION = options.api_version || process.env.JOONWEB_API_VERSION || this.API_VERSION;
+        this.IS_EMBEDDED_APP = options.is_embedded !== undefined ? options.is_embedded : this.IS_EMBEDDED_APP;
+        this.APP_NAME = options.app_name || process.env.APP_NAME || this.APP_NAME;
+        this.HOST_NAME = options.host_name || process.env.HOST_NAME || this.HOST_NAME;
+        
+        // Storage configuration
+        this.SESSION_STORAGE_TYPE = options.session_storage_type || 
+                                   process.env.JOONWEB_SESSION_STORAGE_TYPE || 
+                                   'memory';
+        this.SESSION_STORAGE_OPTIONS = options.session_storage_options || {};
+        
+        // Initialize session storage
+        this.initSessionStorage();
+    }
+
+    static initSessionStorage() {
+        try {
+            const { createStorageAdapter } = require('./Auth/session/storage');
+            const storageAdapter = createStorageAdapter(
+                this.SESSION_STORAGE_TYPE,
+                this.SESSION_STORAGE_OPTIONS
+            );
+            
+            const SessionManager = require('./SessionManager');
+            this.SESSION_STORAGE = new SessionManager(storageAdapter);
+            
+            console.log(`✅ Session storage initialized: ${this.SESSION_STORAGE_TYPE}`);
+        } catch (error) {
+            console.error('❌ Failed to initialize session storage:', error.message);
+            
+            // Fallback to memory storage
+            try {
+                const { MemoryStorage } = require('./Auth/session/storage');
+                const SessionManager = require('./Auth/SessionManager');
+                this.SESSION_STORAGE = new SessionManager(new MemoryStorage());
+                console.log('✅ Fallback to memory storage');
+            } catch (e) {
+                this.SESSION_STORAGE = null;
+            }
+        }
+    }
+
+    static throwIfUninitialized() {
+        if (!this.API_KEY || !this.API_SECRET_KEY) {
+            throw new Error('JoonWeb Context not initialized. Call Context::init() with api_key and api_secret.');
+        }
+    }
+
+    static isEmbeddedApp() {
+        return this.IS_EMBEDDED_APP;
+    }
+
+    // Get session storage instance
+    static getSessionStorage() {
+        if (!this.SESSION_STORAGE) {
+            throw new Error('Session storage not initialized. Call Context::init() first.');
+        }
+        return this.SESSION_STORAGE;
+    }
+}
+
+module.exports = Context;

package/src/Helper.js

@@ -0,0 +1,92 @@
+const crypto = require('crypto');
+
+class Helper {
+    /**
+     * Sanitize MyJoonWeb domain
+     */
+    static sanitizeDomain(domain) {
+        if (!domain) return null;
+        
+        domain = domain.trim();
+        
+        // Remove protocol
+        domain = domain.replace(/^https?:\/\//, '');
+        
+        // Remove trailing slash
+        domain = domain.replace(/\/$/, '');
+        
+        // Check if it's a JoonWeb domain
+        if (domain.match(/[a-zA-Z0-9][a-zA-Z0-9\-]*\.myjoonweb\.com/) ||
+            domain.match(/[a-zA-Z0-9][a-zA-Z0-9\-]*\.joonweb\.com/)) {
+            return domain;
+        }
+        
+        // If it's just a site name, append .myjoonweb.com
+        if (domain.match(/^[a-zA-Z0-9][a-zA-Z0-9\-]*$/)) {
+            return `${domain}.myjoonweb.com`;
+        }
+        
+        return null;
+    }
+
+    /**
+     * Verify HMAC 
+     */
+    static verifyHmac(params, secret) {
+        const hmac = params.hmac;
+        if (!hmac) return false;
+        
+        delete params.hmac;
+        
+        // Sort keys
+        const sortedParams = Object.keys(params)
+            .sort()
+            .map(key => `${key}=${params[key]}`)
+            .join('&');
+        
+        const calculatedHmac = crypto
+            .createHmac('sha256', secret)
+            .update(sortedParams)
+            .digest('hex');
+        
+        return crypto.timingSafeEqual(
+            Buffer.from(hmac),
+            Buffer.from(calculatedHmac)
+        );
+    }
+
+    /**
+     * Generate OAuth redirect URL
+     */
+    static getAuthorizationUrl(site, scopes, redirectUri, apiKey, nonce = null) {
+        const state = nonce || crypto.randomBytes(16).toString('hex');
+        const scope = Array.isArray(scopes) ? scopes.join(',') : scopes;
+        
+        const params = new URLSearchParams({
+            client_id: apiKey,
+            scope: scope,
+            redirect_uri: redirectUri,
+            state: state,
+            'grant_options[]': 'per-user'
+        });
+        
+        return {
+            url: `https://${site}/admin/oauth/authorize?${params.toString()}`,
+            state: state
+        };
+    }
+
+    /**
+     * Decode JWT session token (for embedded apps)
+     */
+    static decodeSessionToken(token) {
+        try {
+            const json = Buffer.from(token, 'base64').toString('utf8');
+            return JSON.parse(json);
+        } catch (e) {
+            return null;
+        }
+    }
+}
+
+module.exports = Helper;

package/src/JoonWebAPI.js

@@ -0,0 +1,81 @@
+const Product = require('./Resources/Product');
+const Order = require('./Resources/Order');
+const Customer = require('./Resources/Customer');
+const Webhook = require('./Resources/Webhook');
+const Site = require('./Resources/Site');
+const Theme = require('./Resources/Theme');
+
+class JoonWebAPI {
+    constructor(accessToken = null, siteDomain = null) {
+        this.accessToken = accessToken;
+        this.siteDomain = siteDomain;
+        
+        // Initialize resources
+        this.product = new Product(accessToken, siteDomain);
+        this.order = new Order(accessToken, siteDomain);
+        this.customer = new Customer(accessToken, siteDomain);
+        this.webhook = new Webhook(accessToken, siteDomain);
+        this.site = new Site(accessToken, siteDomain);
+        this.theme = new Theme(accessToken, siteDomain);
+    }
+    
+    setAccessToken(token) {
+        this.accessToken = token;
+        
+        // Update all resources
+        Object.values(this).forEach(resource => {
+            if (resource && typeof resource.setAccessToken === 'function') {
+                resource.setAccessToken(token);
+            }
+        });
+        
+        return this;
+    }
+    
+    setSiteDomain(domain) {
+        this.siteDomain = domain;
+        
+        // Update all resources
+        Object.values(this).forEach(resource => {
+            if (resource && typeof resource.setSiteDomain === 'function') {
+                resource.setSiteDomain(domain);
+            }
+        });
+        
+        return this;
+    }
+    
+    /**
+     * Exchange authorization code for access token
+     */
+    async exchangeCodeForToken(code, siteDomain) {
+        const apiVersion = process.env.JOONWEB_API_VERSION || '26.0';
+        const url = `https://${siteDomain}/api/admin/${apiVersion}/oauth/access_token`;
+        
+        // Use axios (already in dependencies)
+        const axios = require('axios');
+        
+        try {
+            const response = await axios.post(url, {
+                client_id: process.env.JOONWEB_CLIENT_ID,
+                client_secret: process.env.JOONWEB_CLIENT_SECRET,
+                code: code
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                }
+            });
+            
+            return response.data;
+        } catch (error) {
+            if (error.response) {
+                throw new Error(`Token exchange failed: HTTP ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            } else {
+                throw new Error(`Token exchange failed: ${error.message}`);
+            }
+        }
+    }
+}
+
+module.exports = JoonWebAPI;

package/src/Resources/BaseResource.js

@@ -0,0 +1,32 @@
+class BaseResource {
+    constructor(httpClient, resourcePath) {
+        this.httpClient = httpClient;
+        this.resourcePath = resourcePath;
+    }
+
+    async all(params = {}) {
+        return this.httpClient.get(this.resourcePath, params);
+    }
+
+    async get(id, params = {}) {
+        return this.httpClient.get(`${this.resourcePath}/${id}`, params);
+    }
+
+    async create(data) {
+        return this.httpClient.post(this.resourcePath, data);
+    }
+
+    async update(id, data) {
+        return this.httpClient.put(`${this.resourcePath}/${id}`, data);
+    }
+
+    async delete(id) {
+        return this.httpClient.delete(`${this.resourcePath}/${id}`);
+    }
+
+    async count(params = {}) {
+        return this.httpClient.get(`${this.resourcePath}/count`, params);
+    }
+}
+
+module.exports = BaseResource;

package/src/Resources/Customer.js

@@ -0,0 +1,34 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Customer extends BaseClient {
+    
+    async all(params = {}) {
+        return this.request('/customers.json', 'GET', null, params);
+    }
+    
+    async get(id) {
+        return this.request(`/customers/${id}.json`, 'GET');
+    }
+    
+    async create(customerData) {
+        return this.request('/customers.json', 'POST', { customer: customerData });
+    }
+    
+    async update(id, customerData) {
+        return this.request(`/customers/${id}.json`, 'PUT', { customer: customerData });
+    }
+    
+    async delete(id) {
+        return this.request(`/customers/${id}.json`, 'DELETE');
+    }
+    
+    async orders(id, params = {}) {
+        return this.request(`/customers/${id}/orders.json`, 'GET', null, params);
+    }
+    
+    async addresses(id, params = {}) {
+        return this.request(`/customers/${id}/addresses.json`, 'GET', null, params);
+    }
+}
+
+module.exports = Customer;

package/src/Resources/Order.js

@@ -0,0 +1,18 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Order extends BaseClient {
+    
+    async all(params = {}) {
+        return this.request('/orders.json', 'GET', null, params);
+    }
+    
+    async get(id) {
+        return this.request(`/orders/${id}.json`, 'GET');
+    }
+    
+    async count(params = {}) {
+        return this.request('/orders/count.json', 'GET', null, params);
+    }
+}
+
+module.exports = Order;

package/src/Resources/Product.js

@@ -0,0 +1,30 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Product extends BaseClient {
+    
+    async all(params = {}) {
+        return this.request('/products.json', 'GET', null, params);
+    }
+    
+    async get(id) {
+        return this.request(`/products/${id}.json`, 'GET');
+    }
+    
+    async create(productData) {
+        return this.request('/products.json', 'POST', { product: productData });
+    }
+    
+    async update(id, productData) {
+        return this.request(`/products/${id}.json`, 'PUT', { product: productData });
+    }
+    
+    async delete(id) {
+        return this.request(`/products/${id}.json`, 'DELETE');
+    }
+    
+    async count(params = {}) {
+        return this.request('/products/count.json', 'GET', null, params);
+    }
+}
+
+module.exports = Product;

package/src/Resources/Site.js

@@ -0,0 +1,11 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Site extends BaseClient {
+    
+    async get() {
+        // Just call the request method directly
+        return this.request('/site.json', 'GET');
+    }
+}
+
+module.exports = Site;

package/src/Resources/Theme.js

@@ -0,0 +1,7 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Theme extends BaseClient {
+    
+}
+
+module.exports = Theme;

package/src/Resources/Webhook.js

@@ -0,0 +1,30 @@
+const BaseClient = require('../Clients/BaseClient');
+
+class Webhook extends BaseClient {
+    
+    async all() {
+        return this.get('/webhooks.json');
+    }
+    
+    async create(webhookData) {
+        return this.post('/webhooks.json', { webhook: webhookData });
+    }
+    
+    async delete(id) {
+        return this.delete(`/webhooks/${id}.json`);
+    }
+    
+    async get(id) {
+        return this.get(`/webhooks/${id}.json`);
+    }
+    
+    async update(id, webhookData) {
+        return this.put(`/webhooks/${id}.json`, { webhook: webhookData });
+    }
+    
+    async count() {
+        return this.get('/webhooks/count.json');
+    }
+}
+
+module.exports = Webhook;