@code.store/arcxp-sdk-ts 5.0.0-beta → 5.0.0

package/dist/index.js

@@ -5,6 +5,7 @@ import * as ws from 'ws';
 import FormData from 'form-data';
 import encode from 'base32-encode';
 import { v5 } from 'uuid';
+import assert from 'node:assert';
 import { TextNode, HTMLElement, CommentNode, parse } from 'node-html-parser';
 import { decode } from 'html-entities';
 
@@ -717,7 +718,7 @@ const ArcAPI = (options) => {
         RetailEvents: new ArcRetailEvents(options),
         Custom: new Custom(options),
     };
-    API.MigrationCenter.setMaxRPS(8);
+    API.MigrationCenter.setMaxRPS(12);
     API.Draft.setMaxRPS(4);
     API.Content.setMaxRPS(3);
     return API;
@@ -1148,10 +1149,186 @@ var Id = /*#__PURE__*/Object.freeze({
     generateArcId: generateArcId
 });
 
+const buildTree = (items) => {
+    const tree = [
+        {
+            id: '/',
+            children: [],
+            meta: new Proxy({}, {
+                get: () => {
+                    throw new Error('Root node meta is not accessible');
+                },
+            }),
+            parent: null,
+        },
+    ];
+    // Track nodes at each level to maintain parent-child relationships
+    // stores last node at each level
+    const currLevelNodes = {
+        0: tree[0],
+    };
+    for (const item of items) {
+        const node = {
+            id: item.id,
+            parent: null,
+            children: [],
+            meta: item,
+        };
+        // Determine the level of this node
+        const levelKey = Object.keys(item).find((key) => key.startsWith('N') && item[key]);
+        const level = Number(levelKey?.replace('N', '')) || 0;
+        if (!level) {
+            throw new Error(`Invalid level for section ${item.id}`);
+        }
+        // This is a child node - attach to its parent
+        const parentLevel = level - 1;
+        const parentNode = currLevelNodes[parentLevel];
+        if (parentNode) {
+            node.parent = parentNode;
+            parentNode.children.push(node);
+        }
+        else {
+            throw new Error(`Parent node not found for section ${item.id}`);
+        }
+        // Set this as the current node for its level
+        currLevelNodes[level] = node;
+    }
+    // return root nodes children
+    return tree[0].children;
+};
+const flattenTree = (tree) => {
+    const flatten = [];
+    const traverse = (node) => {
+        flatten.push(node);
+        for (const child of node.children) {
+            traverse(child);
+        }
+    };
+    // traverse all root nodes and their children
+    for (const node of tree) {
+        traverse(node);
+    }
+    return flatten;
+};
+const buildAndFlattenTree = (items) => flattenTree(buildTree(items));
+const groupByWebsites = (sections) => {
+    return sections.reduce((acc, section) => {
+        const website = section._website;
+        if (!acc[website])
+            acc[website] = [];
+        acc[website].push(section);
+        return acc;
+    }, {});
+};
+const references = (sections) => {
+    return sections.map((s) => reference({
+        id: s._id,
+        website: s._website,
+        type: 'section',
+    }));
+};
+const isReference = (section) => {
+    return section?.type === 'reference' && section?.referent?.type === 'section';
+};
+const removeDuplicates = (sections) => {
+    const map = new Map();
+    sections.forEach((s) => {
+        if (isReference(s)) {
+            map.set(`${s.referent.id}${s.referent.website}`, s);
+        }
+        else {
+            map.set(`${s._id}${s._website}`, s);
+        }
+    });
+    return [...map.values()];
+};
+class SectionsRepository {
+    constructor(arc) {
+        this.arc = arc;
+        this.sectionsByWebsite = {};
+        this.websitesAreLoaded = false;
+    }
+    async put(ans) {
+        await this.arc.Site.putSection(ans);
+        const created = await this.arc.Site.getSection(ans._id, ans.website);
+        this.save(created);
+    }
+    async loadWebsite(website) {
+        const sections = [];
+        let next = true;
+        let offset = 0;
+        while (next) {
+            const migrated = await this.arc.Site.getSections({ website, offset }).catch((_) => {
+                return { q_results: [] };
+            });
+            if (migrated.q_results.length) {
+                sections.push(...migrated.q_results);
+                offset += migrated.q_results.length;
+            }
+            else {
+                next = false;
+            }
+        }
+        return sections;
+    }
+    async loadWebsites(websites) {
+        for (const website of websites) {
+            this.sectionsByWebsite[website] = await this.loadWebsite(website);
+        }
+        this.websitesAreLoaded = true;
+    }
+    save(section) {
+        const website = section._website;
+        assert.ok(website, 'Section must have a website');
+        this.sectionsByWebsite[website] = this.sectionsByWebsite[website] || [];
+        if (!this.sectionsByWebsite[website].find((s) => s._id === section._id)) {
+            this.sectionsByWebsite[website].push(section);
+        }
+    }
+    getById(id, website) {
+        this.ensureWebsitesLoaded();
+        const section = this.sectionsByWebsite[website]?.find((s) => s._id === id);
+        return section;
+    }
+    getByWebsite(website) {
+        this.ensureWebsitesLoaded();
+        return this.sectionsByWebsite[website];
+    }
+    getParentSections(section) {
+        this.ensureWebsitesLoaded();
+        const parents = [];
+        let current = section;
+        while (current.parent?.default && current.parent.default !== '/') {
+            const parent = this.getById(current.parent.default, section._website);
+            if (!parent)
+                break;
+            parents.push(parent);
+            current = parent;
+        }
+        return parents;
+    }
+    ensureWebsitesLoaded() {
+        assert.ok(this.websitesAreLoaded, 'call .loadWebsites() first');
+    }
+}
+
+var Section = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SectionsRepository: SectionsRepository,
+    buildAndFlattenTree: buildAndFlattenTree,
+    buildTree: buildTree,
+    flattenTree: flattenTree,
+    groupByWebsites: groupByWebsites,
+    isReference: isReference,
+    references: references,
+    removeDuplicates: removeDuplicates
+});
+
 const ArcUtils = {
     Id,
     ANS,
     ContentElements,
+    Section,
 };
 
 /**