@foxy.io/sdk 1.8.2 → 1.9.2

package/dist/esm/core/BooleanSelector.js

@@ -1,8 +1,3 @@
-var Entity;
-(function (Entity) {
-    Entity[Entity["List"] = 0] = "List";
-    Entity[Entity["Set"] = 1] = "Set";
-})(Entity || (Entity = {}));
 /**
  * Boolean selector is an HTML boolean attribute value format that allows
  * developers to write configurations for elements deep in a shadow DOM. Here's
@@ -54,7 +49,6 @@ export class BooleanSelector {
      * @param value boolean selector value, e.g. `foo:bar baz:not=qux`
      */
     constructor(value) {
-        this.__value = value;
         this.__tree = BooleanSelector.__parse(value);
     }
     /**
@@ -123,24 +117,38 @@ export class BooleanSelector {
         return isFullMatch ? selector === 'not=*' : selector !== '';
     }
     /**
-     * Zooms on the given top-level identifier.
+     * Zooms on the given top-level identifier or follows a path.
      *
      * @example
+     * new BooleanSelector('foo:bar:baz').zoom('foo:bar').toString() // => "baz"
      * new BooleanSelector('foo:bar:baz').zoom('foo').toString() // => "bar:baz"
      * new BooleanSelector('not=foo').zoom('bar').toString() // => "not=*"
      * new BooleanSelector('not=foo').zoom('foo').toString() // => ""
      *
-     * @param id identifier to look for
-     * @returns `true` is current selector includes rules for the given identifier
+     * @param path path to look for
+     * @returns zoomed BooleanSelector
      */
-    zoom(id) {
-        const [firstPart, ...rest] = id.split(':');
-        const { only, not } = this.__tree;
-        if (only === null || only === void 0 ? void 0 : only[firstPart]) {
-            const selector = new BooleanSelector(BooleanSelector.__stringify(only[firstPart]));
-            return rest.length === 0 ? selector : selector.zoom(rest.join(':'));
-        }
-        return !not || not.includes(firstPart) ? BooleanSelector.False : BooleanSelector.True;
+    zoom(path) {
+        const zoomedSelector = new BooleanSelector('');
+        zoomedSelector.__tree = path.split(':').reduce((currentTree, id) => {
+            let zoomedTree;
+            if ('include' in currentTree) {
+                zoomedTree = currentTree.include[id];
+                if (zoomedTree === undefined)
+                    return { include: {} };
+                if (zoomedTree === true)
+                    return { exclude: { '*': true } };
+            }
+            else {
+                zoomedTree = currentTree.exclude[id];
+                if (zoomedTree === undefined)
+                    return { exclude: { '*': true } };
+                if (zoomedTree === true)
+                    return { include: {} };
+            }
+            return zoomedTree;
+        }, this.__tree);
+        return zoomedSelector;
     }
     /**
      * Converts this selector to string.
@@ -151,7 +159,7 @@ export class BooleanSelector {
      * @returns serialized representation of this selector
      */
     toString() {
-        return this.__value;
+        return BooleanSelector.__stringifyTree(this.__tree);
     }
     /**
      * Converts this selector to an attribute value.
@@ -166,103 +174,226 @@ export class BooleanSelector {
      * @returns attribute value representing this selector.
      */
     toAttribute(truthyValue = '') {
-        var _a;
-        if (((_a = this.__tree.not) === null || _a === void 0 ? void 0 : _a[0]) === '*')
+        const serializedSelector = this.toString();
+        if (serializedSelector === 'not=*')
             return truthyValue;
-        return this.__value.trim().length === 0 ? null : this.toString();
+        return serializedSelector.length === 0 ? null : serializedSelector;
+    }
+    static __parsePath(path, tree) {
+        const firstSeparatorIndex = path.indexOf(':');
+        const topLevelId = path.substring(0, firstSeparatorIndex);
+        const nestedPath = path.substring(firstSeparatorIndex + 1);
+        if ('exclude' in tree) {
+            const subTree = tree.exclude[topLevelId];
+            if (subTree)
+                tree.exclude[topLevelId] = this.__parseListItem(nestedPath, subTree === true ? void 0 : subTree);
+        }
+        else {
+            const subTree = tree.include[topLevelId];
+            if (subTree !== true)
+                tree.include[topLevelId] = this.__parseListItem(nestedPath, subTree);
+        }
+        return tree;
+    }
+    static __parseSet(set, tree) {
+        const setItems = set.split(',');
+        if ('include' in tree) {
+            tree = { exclude: tree.include };
+            for (const id in tree.exclude)
+                if (!setItems.includes(id))
+                    delete tree.exclude[id];
+            for (const item of setItems) {
+                if (item in tree.exclude) {
+                    delete tree.exclude[item];
+                }
+                else {
+                    tree.exclude[item] = true;
+                }
+            }
+        }
+        else {
+            for (const id in tree.exclude)
+                if (!setItems.includes(id))
+                    delete tree.exclude[id];
+        }
+        return tree;
     }
-    static __stringify(tree, path = '') {
-        if (tree.only) {
-            return Object.entries(tree.only).reduce((output, [key, subtree]) => {
-                const result = BooleanSelector.__stringify(subtree, path.length === 0 ? key : `${path}:${key}`);
-                return output.length === 0 ? result : `${output} ${result}`;
-            }, '');
+    static __parseListItem(listItem, tree = { include: {} }) {
+        if (listItem.includes(':'))
+            return this.__parsePath(listItem, tree);
+        if (listItem.startsWith('not='))
+            return this.__parseSet(listItem.substring(4), tree);
+        if ('include' in tree) {
+            tree.include[listItem] = true;
         }
-        if (tree.not)
-            return `${path.length === 0 ? '' : `${path}:`}not=${tree.not.join(',')}`;
-        return path;
+        else {
+            for (const id in tree.exclude)
+                if (id === listItem)
+                    delete tree.exclude[id];
+        }
+        return tree;
     }
-    static __parse(value) {
-        const tree = {};
-        const output = { branch: tree, buffer: '', entity: Entity.List, tree };
-        Array.from(`${value} `).forEach((character, position) => {
+    static __parseList(list, tree = { include: {} }) {
+        return list.split(' ').reduce((newTree, listItem) => this.__parseListItem(listItem, newTree), tree);
+    }
+    static __lintList(list) {
+        var _a;
+        let position = 'list';
+        let result = '';
+        for (let i = 0; i < list.length; ++i) {
+            const character = list.charAt(i);
             try {
-                BooleanSelector.__processors[output.entity](output, character);
+                if (position === 'list') {
+                    if (/^\s$/.test(character)) {
+                        if (!/^\s$/.test((_a = list[i - 1]) !== null && _a !== void 0 ? _a : ' '))
+                            result += ' ';
+                        continue;
+                    }
+                    if (/^[a-z]$/.test(character)) {
+                        result += character;
+                        position = 'path';
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z] or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'path') {
+                    if (/^[a-z]$/.test(character)) {
+                        result += character;
+                        continue;
+                    }
+                    if (character === '-') {
+                        if (list[i - 1] === '-' || list[i - 1] === ':') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        else {
+                            result += character;
+                            continue;
+                        }
+                    }
+                    if (character === ':') {
+                        if (list[i - 1] === ':' || list[i - 1] === '-') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        else {
+                            result += character;
+                            continue;
+                        }
+                    }
+                    if (character === '=') {
+                        if (list[i - 1] === '=' || list[i - 1] === ':' || list[i - 1] === '-') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        if (result.endsWith('not') && (result.length === 3 || !/[a-z]|-/.test(result[i - 4]))) {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        else {
+                            throw new SyntaxError(`Expected [a-z] or ":", but got "${character}" instead.`);
+                        }
+                    }
+                    if (/^\s$/.test(character)) {
+                        result += ' ';
+                        position = 'list';
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z], ",", ":", ":" or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'set') {
+                    if (/^\s$/.test(character))
+                        continue;
+                    if (/^[a-z]|\*$/.test(character)) {
+                        position = 'set-item';
+                        result += character;
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z] or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'set-item') {
+                    if (list[i - 1] === '*') {
+                        if (character === ',') {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        if (/^\s$/.test(character)) {
+                            if (i !== list.length - 1)
+                                result += ' ';
+                            position = 'list';
+                            continue;
+                        }
+                        throw new SyntaxError(`Expected "," or a whitespace, but got "${character}" instead.`);
+                    }
+                    else {
+                        if (/^[a-z]$/.test(character)) {
+                            result += character;
+                            continue;
+                        }
+                        if (character === '-') {
+                            if (list[i - 1] === '-' || list[i - 1] === ':' || list[i - 1] === '=') {
+                                throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                            }
+                            else {
+                                result += character;
+                                continue;
+                            }
+                        }
+                        if (character === ',') {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        if (/^\s$/.test(character)) {
+                            if (i !== list.length - 1)
+                                result += ' ';
+                            position = 'list';
+                            continue;
+                        }
+                        throw new SyntaxError(`Expected [a-z], "," or a whitespace, but got "${character}" instead.`);
+                    }
+                }
             }
             catch (err) {
                 const hint = 'This error occured at: ';
-                const trim = (v) => v.substring(Math.max(0, position - 30), position + 30);
-                const preview = trim(value);
-                const pointer = ' '.repeat(hint.length) + trim('^'.padStart(position + 1, ' '));
+                const trim = (v) => v.substring(Math.max(0, i - 30), i + 30);
+                const preview = trim(list);
+                const pointer = ' '.repeat(hint.length) + trim('^'.padStart(i + 1, ' '));
                 throw new SyntaxError([err.message, `${hint}${preview}`, pointer].join('\n'));
             }
-        });
-        return tree;
-    }
-}
-BooleanSelector.__processors = {
-    [Entity.List](output, character) {
-        var _a, _b, _c, _d;
-        /* istanbul ignore next */
-        if (Array.isArray(output.branch))
-            throw new SyntaxError('Paths are not allowed in sets.');
-        if (character === '=') {
-            if (output.buffer === 'not') {
-                const newBranch = (_a = output.branch.not) !== null && _a !== void 0 ? _a : [];
-                delete output.branch.only;
-                output.branch.not = newBranch;
-                output.entity = Entity.Set;
-                output.branch = newBranch;
-                output.buffer = '';
-                return;
-            }
-            else {
-                throw new SyntaxError(`Unknown modifier "${output.buffer}".`);
-            }
         }
-        if (/^\s$/.test(character) || character === ':') {
-            if (output.buffer.length > 0) {
-                const selector = output.buffer;
-                const newBranch = (_c = (_b = output.branch.only) === null || _b === void 0 ? void 0 : _b[selector]) !== null && _c !== void 0 ? _c : {};
-                if (character !== ':')
-                    newBranch.not = ['*'];
-                if (((_d = output.branch.not) === null || _d === void 0 ? void 0 : _d.includes('*')) !== true) {
-                    output.branch.only = Object.assign(Object.assign({}, output.branch.only), { [selector]: newBranch });
-                    delete output.branch.not;
+        return result.trimEnd();
+    }
+    static __parse(list) {
+        return this.__parseList(this.__lintList(list));
+    }
+    static __stringifyTree(tree, path) {
+        const parts = [];
+        if ('include' in tree) {
+            for (const id in tree.include) {
+                const nestedTree = tree.include[id];
+                const newPath = path ? [path, id].join(':') : id;
+                if (nestedTree === true) {
+                    parts.push(newPath);
+                }
+                else {
+                    parts.push(this.__stringifyTree(nestedTree, newPath));
                 }
-                output.branch = character === ':' ? newBranch : output.tree;
-                output.buffer = '';
             }
-            return;
         }
-        if (/^[a-z]|-$/.test(character)) {
-            output.buffer += character;
-            return;
-        }
-        throw new SyntaxError(`Expected [a-z], "-", ":" or a whitespace, but got "${character}" instead.`);
-    },
-    [Entity.Set](output, character) {
-        /* istanbul ignore next */
-        if (!Array.isArray(output.branch))
-            throw new SyntaxError('Unexpected set item.');
-        if (output.buffer.length === 0 && /^\s$/.test(character))
-            return;
-        if (character === ',' || character === '*' || /^\s$/.test(character)) {
-            const newItem = character === '*' ? '*' : output.buffer;
-            const updatedSet = new Set([...output.branch, newItem]);
-            const normalizedSet = updatedSet.has('*') ? new Set(['*']) : updatedSet;
-            output.branch.splice(0, output.branch.length, ...normalizedSet);
-            output.entity = character === ',' ? Entity.Set : Entity.List;
-            output.branch = character === ',' ? output.branch : output.tree;
-            output.buffer = '';
-            return;
-        }
-        if (/^[a-z]|-$/.test(character)) {
-            output.buffer += character;
-            return;
+        else {
+            const ids = [];
+            const partsToPush = [];
+            for (const id in tree.exclude) {
+                const nestedTree = tree.exclude[id];
+                const newPath = path ? [path, id].join(':') : id;
+                ids.push(id);
+                if (nestedTree !== true)
+                    partsToPush.push(this.__stringifyTree(nestedTree, newPath));
+            }
+            parts.push(`${path ? `${path}:` : ''}not=${ids.join(',')}`, ...partsToPush);
         }
-        throw new SyntaxError(`Expected [a-z], "-", "," or a whitespace, but got "${character}" instead.`);
-    },
-};
+        return parts.join(' ');
+    }
+}
 const falseBooleanSelectorSingleton = new BooleanSelector('');
 const trueBooleanSelectorSingleton = new BooleanSelector('not=*');

package/dist/types/backend/Graph/download_url.d.ts

@@ -0,0 +1,5 @@
+import type { Graph } from '../../core';
+
+export interface DownloadUrl extends Graph {
+  curie: 'fx:download_url';
+}

package/dist/types/backend/Graph/report.d.ts

@@ -0,0 +1,30 @@
+import type { DownloadUrl } from './download_url';
+import type { Graph } from '../../core';
+import type { User } from './user';
+
+export interface Report extends Graph {
+  curie: 'fx:report';
+
+  links: {
+    'self': Report;
+    'fx:download_url': DownloadUrl;
+    'fx:user': User;
+  };
+
+  props: {
+    /** The type of report generated, indicating the content of the report. `complete` includes transaction details, summaries, coupon usage, subscription forecasts, and more. `customers` is for exporting customers to import elsewhere. `customers_ltv` includes the lifetime value per customer. */
+    name: 'complete' | 'customers' | 'customers_ltv';
+    /** In the event a report changes significantly, a new version of the report may be available. Leave this empty to retrieve the latest version, or pass a 1 to request a specific version. In the future, additional versions of each named report may be available. */
+    version: '1';
+    /** Current status of the report. Possible values include `queued`, `error`, and `ready`. */
+    status: 'queued' | 'error' | 'ready';
+    /** A timestamp in the `YYYY-MM-DD HH:MM:SS` format, for the start of the reporting period, for your store's configured timezone. Note that any offset will be ignored, and the datetime passed in will be used as your store's configured timezone. */
+    datetime_start: string;
+    /** Same as `datetime_start`, but for the end of the report's timeframe. Note that you likely want to pass `23:59:59` as the time portion, or you may inadvertently miss data from the last day of the reporting period. */
+    datetime_end: string;
+    /** The date this resource was created. */
+    date_created: string | null;
+    /** The date this resource was last modified. */
+    date_modified: string | null;
+  };
+}

package/dist/types/backend/Graph/reports.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionGraphLinks, CollectionGraphProps } from '../../core/defaults';
+import type { Graph } from '../../core';
+import type { Report } from './report';
+
+export interface Reports extends Graph {
+  curie: 'fx:reports';
+  links: CollectionGraphLinks<Reports>;
+  props: CollectionGraphProps;
+  child: Report;
+}

package/dist/types/backend/Graph/store.d.ts

@@ -17,6 +17,7 @@ import type { ItemCategories } from './item_categories';
 import type { PaymentMethodSets } from './payment_method_sets';
 import type { ProcessSubscriptionWebhook } from './process_subscription_webhook';
 import type { ReceiptTemplates } from './receipt_templates';
+import type { Reports } from './reports';
 import type { StoreVersion } from './store_version';
 import type { SubscriptionSettings } from './subscription_settings';
 import type { Subscriptions } from './subscriptions';
@@ -38,6 +39,8 @@ export interface Store extends Graph {
     'fx:users': Users;
     /** List of taxes configured for this store. */
     'fx:taxes': Taxes;
+    /** List of reports for this store. */
+    'fx:reports': Reports;
     /** List of coupons available in this store. */
     'fx:coupons': Coupons;
     /** List of customers of this store. */

package/dist/types/backend/Graph/webhook.d.ts

@@ -0,0 +1,43 @@
+import type { Graph } from '../../core';
+import type { Store } from './store';
+import type { WebhookLogs } from './webhook_logs';
+import type { WebhookStatuses } from './webhook_statuses';
+import type { Webhooks } from './webhooks';
+
+export interface Webhook extends Graph {
+  curie: 'fx:webhook';
+
+  links: {
+    /** This resource. */
+    'self': Webhook;
+    /** Store this webhook was created in. */
+    'fx:store': Store;
+    /** List of all webhooks for the store. */
+    'fx:webhooks': Webhooks;
+    /** List of all webhook delivery attempts and their current states. */
+    'fx:statuses': WebhookStatuses;
+    /** List of all endpoint responses received during webhook delivery attempts. */
+    'fx:logs': WebhookLogs;
+  };
+
+  props: {
+    /** The type of this webhook. Required. */
+    format: 'json' | 'webflow' | 'zapier';
+    /** The version of this webhook. Should not be modified unless you have specific instructions from Foxy. Default value is 2. */
+    version: number;
+    /** The name of this webhook. Required. 255 characters or less. */
+    name: string;
+    /** The endpoint where we will send the webhook data. 1000 characters or less. */
+    url: string | null;
+    /** The webhook payload mirrors the API, and you can include more or less data according to your needs (using `zoom` and other modifiers). 1000 characters or less. Something like `zoom=items,items:options,customer`. */
+    query: string | null;
+    /** The JSON webhooks are encrypted in certain situations. This key is also used to generate a signature to verify the integrity of the payload. 1000 characters or less. */
+    encryption_key: string | null;
+    /** The type of resource to observe changes on. */
+    event_resource: ('subscription' | 'transaction' | 'customer')[];
+    /** The date this resource was created. */
+    date_created: string | null;
+    /** The date this resource was last modified. */
+    date_modified: string | null;
+  };
+}

package/dist/types/backend/Graph/webhook_log.d.ts

@@ -0,0 +1,42 @@
+import type { Customer } from './customer';
+import type { Graph } from '../../core';
+import type { Store } from './store';
+import type { Subscription } from './subscription';
+import type { Transaction } from './transaction';
+import type { Webhook } from './webhook';
+
+export interface WebhookLog extends Graph {
+  curie: 'fx:webhook_log';
+
+  links: {
+    /** This resource. */
+    'self': WebhookLog;
+    /** The store this webhook status is associated with. */
+    'fx:store': Store;
+    /** The webhook this status is associated with. */
+    'fx:webhook': Webhook;
+    /** The resource changes in which have triggered the webhook. */
+    'fx:resource': Transaction | Subscription | Customer;
+  };
+
+  props: {
+    /** The type of resource changes were observed on. */
+    resource_type: 'subscription' | 'transaction' | 'customer';
+    /** The ID of the resource changes in which have triggered the webhook. */
+    resource_id: number;
+    /** The ID of the webhook this status is associated with. */
+    webhook_id: number;
+    /** The code received from the server the webhook was sent to. */
+    response_code: string;
+    /** The content received from the server the webhook was sent to. */
+    response_body: string | null;
+    /** The date this resource was created. */
+    date_created: string | null;
+    /** The date this resource was last modified. */
+    date_modified: string | null;
+  };
+
+  zooms: {
+    webhook?: Webhook;
+  };
+}

package/dist/types/backend/Graph/webhook_logs.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionGraphLinks, CollectionGraphProps } from '../../core/defaults';
+import type { Graph } from '../../core';
+import type { WebhookLog } from './webhook_log';
+
+export interface WebhookLogs extends Graph {
+  curie: 'fx:webhook_logs';
+  links: CollectionGraphLinks<WebhookLogs>;
+  props: CollectionGraphProps;
+  child: WebhookLog;
+}

package/dist/types/backend/Graph/webhook_status.d.ts

@@ -0,0 +1,40 @@
+import type { Customer } from './customer';
+import type { Graph } from '../../core';
+import type { Store } from './store';
+import type { Subscription } from './subscription';
+import type { Transaction } from './transaction';
+import type { Webhook } from './webhook';
+
+export interface WebhookStatus extends Graph {
+  curie: 'fx:webhook_status';
+
+  links: {
+    /** This resource. */
+    'self': WebhookStatus;
+    /** The store this webhook status is associated with. */
+    'fx:store': Store;
+    /** The webhook this status is associated with. */
+    'fx:webhook': Webhook;
+    /** The resource changes in which have triggered the webhook. */
+    'fx:resource': Transaction | Subscription | Customer;
+  };
+
+  props: {
+    /** The type of resource changes were observed on. */
+    resource_type: 'subscription' | 'transaction' | 'customer';
+    /** The ID of the resource changes in which have triggered the webhook. */
+    resource_id: number;
+    /** The ID of the webhook this status is associated with. */
+    webhook_id: number;
+    /** The current state of this attempt. */
+    status: 'pending' | 'failed' | 'successful';
+    /** The date this resource was created. */
+    date_created: string | null;
+    /** The date this resource was last modified. */
+    date_modified: string | null;
+  };
+
+  zooms: {
+    webhook?: Webhook;
+  };
+}

package/dist/types/backend/Graph/webhook_statuses.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionGraphLinks, CollectionGraphProps } from '../../core/defaults';
+import type { Graph } from '../../core';
+import type { WebhookStatus } from './webhook_status';
+
+export interface WebhookStatuses extends Graph {
+  curie: 'fx:webhook_statuses';
+  links: CollectionGraphLinks<WebhookStatuses>;
+  props: CollectionGraphProps;
+  child: WebhookStatus;
+}

package/dist/types/backend/Graph/webhooks.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionGraphLinks, CollectionGraphProps } from '../../core/defaults';
+import type { Graph } from '../../core';
+import type { Webhook } from './webhook';
+
+export interface Webhooks extends Graph {
+  curie: 'fx:webhooks';
+  links: CollectionGraphLinks<Webhooks>;
+  props: CollectionGraphProps;
+  child: Webhook;
+}

package/dist/types/backend/Rels.d.ts

@@ -109,9 +109,12 @@ export * from './Graph/receipt_template';
 export * from './Graph/receipt_templates';
 export * from './Graph/refund';
 export * from './Graph/regions';
+export * from './Graph/report';
+export * from './Graph/download_url';
 export * from './Graph/reporting';
 export * from './Graph/reporting_email_exists';
 export * from './Graph/reporting_store_domain_exists';
+export * from './Graph/reports';
 export * from './Graph/send_emails';
 export * from './Graph/shipment';
 export * from './Graph/shipments';
@@ -155,3 +158,9 @@ export * from './Graph/user_access';
 export * from './Graph/user_accesses';
 export * from './Graph/users';
 export * from './Graph/void';
+export * from './Graph/webhook_log';
+export * from './Graph/webhook_logs';
+export * from './Graph/webhook_status';
+export * from './Graph/webhook_statuses';
+export * from './Graph/webhook';
+export * from './Graph/webhooks';