@rebuy/rebuy 1.0.0-rc.3

package/README.md

@@ -0,0 +1 @@
+# Rebuy

package/api.js

@@ -0,0 +1,59 @@
+import { serialize } from './utilities.js';
+
+const config = {
+    key: null,
+    domain: 'https://rebuyengine.com',
+    cdnDomain: 'https://cdn.rebuyengine.com',
+    eventDomain: 'https://rebuyengine.com',
+};
+
+const makeCall = async (method, path, data, origin) => {
+    const url = `${origin}${path}`;
+    const requestUrl = new URL(url);
+
+    const requestData = {
+        key: config.key,
+    };
+
+    if (typeof data == 'object' && data != null) {
+        Object.assign(requestData, data);
+    }
+
+    const requestObject = {
+        method,
+    };
+
+    if (method == 'GET') {
+        requestUrl.search = serialize(requestData);
+    } else if (method == 'POST') {
+        requestObject.headers = {
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        };
+        requestObject.body = new URLSearchParams(requestData);
+    }
+
+    const request = await fetch(requestUrl, requestObject);
+    return await request.json();
+};
+
+export default class Api {
+    constructor(options) {
+        if (typeof options == 'string') {
+            config.key = options;
+        } else if (typeof options == 'object' && options != null) {
+            Object.assign(config, options);
+        }
+    }
+
+    async callEvent(method, path, data) {
+        return await makeCall(method, path, data, config.eventDomain);
+    }
+
+    async callCdn(method, path, data) {
+        return await makeCall(method, path, data, config.cdnDomain);
+    }
+
+    async callApi(method, path, data) {
+        return await makeCall(method, path, data, config.domain);
+    }
+}

package/client.js

@@ -0,0 +1,104 @@
+import { convertProductToStorefrontFormat } from './utilities.js';
+import Identity from './identity.js';
+import Api from './api.js';
+
+const config = {
+    key: null,
+    defaultParameters: null,
+    contextParameters: null,
+    api: null,
+    identity: null,
+};
+
+const trackEvent = async (eventData) => {
+    if (config.identity.visitorId()) {
+        eventData.uuid = config.identity.visitorId();
+    }
+
+    return await config.api.callEvent('POST', '/api/v1/analytics/event', eventData);
+};
+
+const makeCall = async (endpoint, params, format) => {
+    const query = {};
+
+    if (config.defaultParameters != null) {
+        Object.assign(query, config.defaultParameters);
+    }
+
+    if (config.contextParameters != null) {
+        Object.assign(query, config.contextParameters);
+    }
+
+    if (typeof params == 'object' && params != null) {
+        Object.assign(query, params);
+    }
+
+    if (config.identity.visitorId()) {
+        query.uuid = config.identity.visitorId();
+    }
+
+    const response = await config.api.callApi('GET', endpoint, query);
+
+    if (response.data && format == 'storefront') {
+        for (let i = 0; i < response.data.length; i++) {
+            response.data[i] = convertProductToStorefrontFormat(response.data[i]);
+        }
+    }
+
+    return response;
+};
+
+export default class RebuyClient {
+    constructor(key, defaultParameters) {
+        if (typeof key == 'string') {
+            config.key = key;
+        }
+
+        if (typeof defaultParameters == 'object' && defaultParameters != null) {
+            config.defaultParameters = defaultParameters;
+        }
+
+        config.api = new Api(config.key);
+        config.identity = new Identity();
+    }
+
+    setDefaultParameters(defaultParameters) {
+        if (typeof defaultParameters == 'object' && defaultParameters != null) {
+            config.defaultParameters = defaultParameters;
+        }
+    }
+
+    setContextParameters(contextParameters) {
+        if (typeof contextParameters == 'object' && contextParameters != null) {
+            config.contextParameters = contextParameters;
+        }
+    }
+
+    async getData(endpoint, params) {
+        return await makeCall(endpoint, params);
+    }
+
+    async getStorefrontData(endpoint, params) {
+        return await makeCall(endpoint, params, 'storefront');
+    }
+
+    async trackProductViewed(data) {
+        const requiredKeys = ['shopify_product_id', 'shopify_product_handle'];
+
+        const defaultData = {
+            subject: 'user',
+            verb: 'viewed',
+            noun: 'product',
+        };
+
+        if (typeof data != 'undefined' && data != null) {
+            const dataKeys = Object.keys(data);
+            if (dataKeys.some((key) => requiredKeys.includes(key))) {
+                const payload = Object.assign(data, defaultData);
+                return await trackEvent(payload);
+            }
+        }
+
+        return null;
+    }
+}

package/cookie.js

@@ -0,0 +1,153 @@
+import { dataToString, stringToData, isBase64Encoded } from './utilities.js';
+
+export function get(name) {
+    if (typeof document == 'undefined') {
+        return null;
+    }
+
+    // Get cookie
+    const cookie = document.cookie.match('(^|;) ?' + decodeURIComponent(name) + '=([^;]*)(;|$)');
+
+    let value = null;
+
+    if (cookie != null) {
+        // Get data
+        const data = decodeURIComponent(cookie[2]);
+
+        // Auto decode
+        const decode = isBase64Encoded(data) ? true : false;
+
+        // Convert to data object
+        value = stringToData(data, decode);
+    }
+
+    return value;
+}
+
+export function getAll() {
+    const cookies = {};
+
+    if (document && document.cookie && document.cookie != '') {
+        const split = document.cookie.split(';');
+
+        for (let i = 0; i < split.length; i++) {
+            const pairs = split[i].split('=');
+
+            pairs[0] = pairs[0].replace(/^ /, '');
+
+            const key = decodeURIComponent(pairs[0]);
+            const value = decodeURIComponent(pairs[1]);
+
+            // Auto decode
+            const decode = isBase64Encoded(value) ? true : false;
+
+            cookies[key] = stringToData(value, decode);
+        }
+    }
+
+    return cookies;
+}
+
+export function set(name, value, config) {
+    if (typeof document == 'undefined') {
+        return null;
+    }
+
+    const attributes = ['path', 'domain', 'maxAge', 'expires', 'secure', 'sameSite'];
+    const convenienceTimes = ['seconds', 'minutes', 'hours', 'days', 'weeks', 'months', 'years'];
+
+    let cookieAttributes = {
+        path: '/',
+    };
+
+    if (typeof config != 'undefined' && Number.isInteger(config)) {
+        cookieAttributes['max-age'] = config;
+    } else if (typeof config === 'object' && config !== null) {
+        for (let key in config) {
+            if (attributes.includes(key)) {
+                if (key == 'maxAge') {
+                    cookieAttributes['max-age'] = config[key];
+                } else if (key == 'sameSite') {
+                    cookieAttributes['samesite'] = config[key];
+                } else if (key == 'expires') {
+                    cookieAttributes[key] = new Date(config[key]).toGMTString();
+                } else {
+                    cookieAttributes[key] = config[key];
+                }
+            } else if (convenienceTimes.includes(key)) {
+                let duration = config[key];
+
+                if (key == 'seconds') {
+                    duration = duration * 1;
+                } else if (key == 'minutes') {
+                    duration = duration * 60;
+                } else if (key == 'hours') {
+                    duration = duration * 60 * 60;
+                } else if (key == 'days') {
+                    duration = duration * 60 * 60 * 24;
+                } else if (key == 'weeks') {
+                    duration = duration * 60 * 60 * 24 * 7;
+                } else if (key == 'months') {
+                    duration = duration * 60 * 60 * 24 * 30;
+                } else if (key == 'years') {
+                    duration = duration * 60 * 60 * 24 * 365;
+                }
+
+                cookieAttributes['max-age'] = duration;
+            }
+        }
+    }
+
+    // Convert data to string
+    value = dataToString(value, config.encode);
+
+    // Define cookie
+    let cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+
+    // Add optional cookie attributes
+    for (let key in cookieAttributes) {
+        cookie += ';' + key + '=' + cookieAttributes[key];
+    }
+
+    // Write cookie
+    document.cookie = cookie;
+}
+
+export function find(name) {
+    const matches = [];
+    const cookies = getAll();
+
+    for (let key in cookies) {
+        if (key.includes(name)) {
+            matches.push({
+                name: key,
+                value: cookies[key],
+            });
+        }
+    }
+
+    return matches;
+}
+
+export function destroy(name) {
+    set(name, '', { seconds: 0 });
+}
+
+export function enabled() {
+    const test = {
+        key: '__cookie_test',
+        value: 1,
+    };
+
+    set(test.key, test.value);
+
+    const enabled = get(test.key) == test.value ? true : false;
+
+    if (enabled) {
+        destroy(test.key);
+    }
+
+    return enabled;
+}
+
+export default { get, set, getAll, find, destroy, enabled };

package/geolocation.js

@@ -0,0 +1,57 @@
+import Cookie from './cookie.js';
+import Api from './api.js';
+
+const config = {
+    key: null,
+    geolocation: null,
+    geolocationCookie: '_rebuyGeolocation',
+    geolocationDuration: {
+        minutes: 30,
+    },
+};
+
+const getGeolocation = async () => {
+    const api = new Api(config.key);
+    const response = await api.callApi('GET', '/api/v1/customers/geolocation');
+
+    if (response.data) {
+        // Update config with geolocation
+        config.geolocation = response.data;
+
+        // Write cookie with geolocation
+        const cookieOptions = {
+            secure: true,
+        };
+
+        // Merge cookie options with geolocation config
+        Object.assign(cookieOptions, config.geolocationDuration);
+
+        // Write cookie with geolocation
+        Cookie.set(config.geolocationCookie, config.geolocation, cookieOptions);
+    }
+
+    return config.geolocation;
+};
+
+export default class Geolocation {
+    constructor(key) {
+        if (typeof key == 'string') {
+            config.key = key;
+        }
+
+        config.geolocation = Cookie.get(config.geolocationCookie);
+
+        // Create a new geolocation (if needed)
+        if (config.geolocation === null) {
+            getGeolocation();
+        }
+    }
+
+    async geolocation() {
+        if (config.geolocation == null) {
+            await getGeolocation();
+        }
+
+        return config.geolocation;
+    }
+}

package/identity.js

@@ -0,0 +1,66 @@
+import { uuid } from './utilities.js';
+import Session from './session.js';
+import Cookie from './cookie.js';
+import Geolocation from './geolocation.js';
+
+const config = {
+    key: null,
+    visitorId: null,
+    visitorIdCookie: '_rebuyVisitorId',
+    visitorDuration: {
+        years: 1,
+    },
+    session: null,
+};
+
+export default class Identity {
+    constructor(key) {
+        if (typeof key == 'string') {
+            config.key = key;
+        }
+
+        config.visitorId = Cookie.get(config.visitorIdCookie);
+
+        // Create a new identifier (if needed)
+        if (config.visitorId === null) {
+            config.visitorId = uuid();
+        }
+
+        // Write cookie with visitor ID
+        const cookieOptions = {
+            secure: true,
+        };
+
+        // Merge cookie options with visitor config
+        Object.assign(cookieOptions, config.visitorDuration);
+
+        // Write cookie with session ID
+        Cookie.set(config.visitorIdCookie, config.visitorId, cookieOptions);
+
+        // Create visitor session
+        config.session = new Session();
+
+        // Create visitor geolocation
+        config.geolocation = new Geolocation(config.key);
+    }
+
+    visitorId() {
+        return config.visitorId;
+    }
+
+    sessionId() {
+        return config.session.sessionId();
+    }
+
+    sessionStart() {
+        return config.session.sessionStart();
+    }
+
+    sessionDuration() {
+        return config.session.sessionDuration();
+    }
+
+    async geolocation() {
+        return await config.geolocation.geolocation();
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "@rebuy/rebuy",
+    "description": "This is the default library for Rebuy",
+    "version": "1.0.0-rc.3",
+    "license": "MIT",
+    "author": "Rebuy, Inc.",
+    "type": "module",
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "**/*.js"
+    ],
+    "scripts": {
+        "lint": "eslint .",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@bitbucket.org/rebuyengine/npm-rebuy.git"
+    },
+    "bugs": {
+        "url": "https://bitbucket.org/rebuyengine/npm-rebuy/issues"
+    },
+    "homepage": "https://bitbucket.org/rebuyengine/npm-rebuy#readme",
+    "devDependencies": {
+        "@semantic-release/changelog": "^6.0.1",
+        "@semantic-release/commit-analyzer": "^9.0.2",
+        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/npm": "^9.0.1",
+        "@semantic-release/release-notes-generator": "^10.0.3",
+        "conventional-changelog-eslint": "^3.0.9",
+        "eslint": "^8.17.0",
+        "semantic-release": "^19.0.3"
+    }
+}

package/session.js

@@ -0,0 +1,46 @@
+import { sessionId } from './utilities.js';
+import Cookie from './cookie.js';
+
+const config = {
+    now: null,
+    sessionId: null,
+    sessionIdCookie: '_rebuySessionId',
+    sessionDuration: {
+        minutes: 30,
+    },
+};
+
+export default class Session {
+    constructor() {
+        config.now = new Date().getTime();
+        config.sessionId = Cookie.get(config.sessionIdCookie);
+
+        // Create a new session (if needed)
+        if (config.sessionId === null) {
+            config.sessionId = sessionId();
+        }
+
+        // Write cookie with session ID
+        const cookieOptions = {
+            secure: true,
+        };
+
+        // Merge cookie options with session config
+        Object.assign(cookieOptions, config.sessionDuration);
+
+        // Write cookie with session ID
+        Cookie.set(config.sessionIdCookie, config.sessionId, cookieOptions);
+    }
+
+    sessionId() {
+        return config.sessionId;
+    }
+
+    sessionStart() {
+        return Number(config.sessionId.split('.')[1]);
+    }
+
+    sessionDuration() {
+        return parseInt((config.now - this.sessionStart()) / 1000 / 60);
+    }
+}

package/utilities.js

@@ -0,0 +1,341 @@
+export function isBase64Encoded(str) {
+    const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+    return base64Regex.test(str) ? true : false;
+}
+
+export function stringToData(data, decode) {
+    let response = data;
+
+    // Base64 decode
+    if (decode == true) {
+        response = atob(response);
+    }
+
+    try {
+        response = JSON.parse(response);
+    } catch (e) {
+        // failure to parse cookie
+    }
+
+    return response;
+}
+
+export function dataToString(data, encode) {
+    let response = data;
+
+    if (typeof response != 'string') {
+        response = JSON.stringify(response);
+    }
+
+    // Base64 encode
+    if (encode == true) {
+        response = btoa(response);
+    }
+
+    return response;
+}
+
+export function stripHtml(str) {
+    return str.replace(/<(.|\n)*?>/g, '');
+}
+
+export function getIdFromGraphUrl(graphId, objectType) {
+    let id = null;
+
+    const regex = new RegExp(`gid://shopify/${objectType}/(.*)`);
+    const matches = graphId.match(regex);
+
+    if (matches != null) {
+        id = matches[1];
+
+        if (!isNaN(id)) {
+            id = Number(id);
+        }
+    }
+
+    return id;
+}
+
+export function variantAvailable(variant) {
+    return !(variant.inventory_management && variant.inventory_policy == 'deny' && variant.inventory_quantity <= 0);
+}
+
+export function firstAvailableVariant(product) {
+    // Select first variant
+    let selectedVariant = product.variants[0];
+
+    // Upgrade to first available
+    for (let i = 0; i < product.variants.length; i++) {
+        if (variantAvailable(product.variants[i])) {
+            selectedVariant = product.variants[i];
+            break;
+        }
+    }
+
+    return selectedVariant;
+}
+
+export function uuid() {
+    let d = new Date().getTime();
+    let d2 = (performance && performance.now && performance.now() * 1000) || 0;
+
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        let r = Math.random() * 16;
+        if (d > 0) {
+            r = (d + r) % 16 | 0;
+            d = Math.floor(d / 16);
+        } else {
+            r = (d2 + r) % 16 | 0;
+            d2 = Math.floor(d2 / 16);
+        }
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+}
+
+export function sessionId() {
+    const config = {
+        chars: '0123456789',
+        length: 12,
+    };
+
+    let sessionId = '';
+    let sessionStart = new Date().getTime();
+
+    for (let i = config.length; i > 0; i--) {
+        sessionId += config.chars[Math.floor(Math.random() * config.chars.length)];
+    }
+
+    return `REBUY.${sessionStart}.${sessionId}`;
+}
+
+export function convertProductToStorefrontFormat(product) {
+    let defaultVariant = firstAvailableVariant(product);
+    let minVariantPrice = variantMinMaxPriceObject(product, 'price', 'min');
+    let maxVariantPrice = variantMinMaxPriceObject(product, 'price', 'max');
+    let minVariantCompareAtPrice = variantMinMaxPriceObject(product, 'compare_at_price', 'min');
+    let maxVariantCompareAtPrice = variantMinMaxPriceObject(product, 'compare_at_price', 'max');
+    let selectedOptions = selectedVariantOptions(product, defaultVariant);
+
+    let variants = product.variants.map((variant) => convertVariantToStorefrontFormat(product, variant));
+
+    return {
+        id: `gid://shopify/Product/${product.id}`,
+        title: product.title,
+        handle: product.handle,
+        description: stripHtml(product.body_html),
+        descriptionHtml: product.body_html,
+        vendor: product.vendor,
+        featuredImage: productImageObject(product),
+        options: [
+            ...product.options.map((option) => {
+                return { name: option.name, values: option.values };
+            }),
+        ],
+        selectedOptions,
+        priceRange: {
+            minVariantPrice,
+            maxVariantPrice,
+        },
+        compareAtPriceRange: {
+            minVariantCompareAtPrice,
+            maxVariantCompareAtPrice,
+        },
+        variants: convertToNodes(variants),
+        images: null,
+        media: [],
+        metafields: [],
+        collections: null,
+        selectedSellingPlan: null,
+        selectedSellingPlanAllocation: null,
+        sellingPlanGroups: [],
+        seo: { title: null, description: null },
+    };
+}
+
+export function convertToNodes(arr) {
+    return {
+        edges: [
+            ...arr.map((node) => {
+                return { node };
+            }),
+        ],
+    };
+}
+
+export function convertVariantToStorefrontFormat(product, variant) {
+    let selectedOptions = selectedVariantOptions(product, variant);
+    let image = productImageObject(product, variant.image_id);
+
+    return {
+        id: `gid://shopify/ProductVariant/${variant.id}`,
+        availableForSale: variantAvailable(variant),
+        priceV2: variantPriceObject(variant, 'price'),
+        compareAtPriceV2: variantPriceObject(variant, 'compare_at_price'),
+        image: image,
+        selectedOptions: [selectedOptions],
+        sku: variant.sku,
+        title: variant.title,
+    };
+}
+
+export function variantMinMaxPriceObject(product, key = 'price', operator = 'min') {
+    let priceObject = variantPriceObject(product.variants[0], key);
+
+    for (let i = 0; i < product.variants.length; i++) {
+        const variantPrice = variantPriceObject(product.variants[i], key);
+
+        if (variantPrice != null) {
+            const variantPriceAmount = Number(variantPrice.amount);
+            const currentPriceAmount = priceObject != null ? Number(priceObject.amount) : null;
+
+            if (
+                currentPriceAmount == null ||
+                (operator == 'min' && variantPriceAmount < currentPriceAmount) ||
+                (operator == 'max' && variantPriceAmount > currentPriceAmount)
+            ) {
+                priceObject = variantPrice;
+            }
+        }
+    }
+
+    return priceObject;
+}
+
+export function variantPriceObject(variant, key = 'price') {
+    if (variant[key] != null) {
+        return {
+            amount: variant[key],
+            currencyCode: 'USD',
+        };
+    } else {
+        return null;
+    }
+}
+
+export function selectedVariantOptions(product, variant) {
+    let selectedOptions = {};
+
+    if (variant.option1 != null) {
+        selectedOptions[product.options[0].name] = variant.option1;
+    }
+
+    if (variant.option2 != null) {
+        selectedOptions[product.options[1].name] = variant.option2;
+    }
+
+    if (variant.option3 != null) {
+        selectedOptions[product.options[2].name] = variant.option3;
+    }
+
+    return selectedOptions;
+}
+
+export function productImageObject(product, id) {
+    let image = null;
+
+    if (product.image) {
+        image = {
+            id: `gid://shopify/ProductImage/${product.image.id}`,
+            url: product.image.src,
+            altText: product.image.alt,
+            width: product.image.width,
+            height: product.image.height,
+        };
+    }
+
+    if (product.images && product.images.length > 0 && id != null) {
+        const matchingImage = product.images.find((i) => i.id == id);
+
+        if (matchingImage) {
+            image = {
+                id: `gid://shopify/ProductImage/${matchingImage.id}`,
+                url: matchingImage.src,
+                altText: matchingImage.alt,
+                width: matchingImage.width,
+                height: matchingImage.height,
+            };
+        }
+    }
+
+    return image;
+}
+
+export function queryStringToObject(str) {
+    const params = new URLSearchParams(str);
+    return Object.fromEntries(params.entries());
+}
+
+export function utmObjectFromString(str) {
+    const utmKeys = ['utm_campaign', 'utm_medium', 'utm_source', 'utm_term', 'utm_content'];
+
+    const matches = {};
+
+    const url = new URL(str);
+    const queryObject = queryStringToObject(url.search);
+
+    for (const [key, value] of Object.entries(queryObject)) {
+        if (utmKeys.includes(key)) {
+            matches[key] = value;
+        }
+    }
+
+    return Object.keys(matches).length > 0 ? matches : null;
+}
+
+export function amountToCents(amount) {
+    if (isNaN(amount)) {
+        amount = 0;
+    }
+
+    if (typeof amount != 'string') {
+        amount = amount.toString();
+    }
+
+    if (amount.indexOf('.') != -1) {
+        amount = parseFloat(amount).toFixed(2) * 100;
+    } else {
+        amount = parseInt(amount);
+    }
+
+    return parseInt(amount);
+}
+
+export function serialize(obj) {
+    const serialized = [];
+
+    const add = (key, value) => {
+        value = typeof value === 'function' ? value() : value;
+        value = value === null ? '' : value === undefined ? '' : value;
+        serialized[serialized.length] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
+    };
+
+    const buildParameters = (prefix, obj) => {
+        let i, len, key;
+
+        if (prefix) {
+            if (Array.isArray(obj)) {
+                for (i = 0, len = obj.length; i < len; i++) {
+                    buildParameters(prefix + '[' + (typeof obj[i] === 'object' && obj[i] ? i : '') + ']', obj[i]);
+                }
+            } else if (Object.prototype.toString.call(obj) === '[object Object]') {
+                for (key in obj) {
+                    buildParameters(prefix + '[' + key + ']', obj[key]);
+                }
+            } else {
+                add(prefix, obj);
+            }
+        } else if (Array.isArray(obj)) {
+            for (i = 0, len = obj.length; i < len; i++) {
+                add(obj[i].name, obj[i].value);
+            }
+        } else {
+            for (key in obj) {
+                buildParameters(key, obj[key]);
+            }
+        }
+
+        return serialized;
+    };
+
+    return buildParameters('', obj).join('&');
+}