@agility/content-sync 1.1.9 → 1.2.0-beta.3

package/dist/store-interface.js

@@ -0,0 +1,430 @@
+import { logWarning, } from "./util";
+let store = null;
+let options = null;
+const validateStoreInterface = (storeCandidate) => {
+    if (!storeCandidate.clearItems) {
+        throw new TypeError("Your sync store interface must implement `clearItems`.");
+    }
+    if (!storeCandidate.deleteItem) {
+        throw new TypeError("Your sync store interface must implement `deleteItem`.");
+    }
+    if (!storeCandidate.getItem) {
+        throw new TypeError("Your sync store interface must implement `getItem`.");
+    }
+    if (!storeCandidate.saveItem) {
+        throw new TypeError("Your sync store interface must implement `saveItem`.");
+    }
+    if (!storeCandidate.mergeItemToList) {
+        throw new TypeError("Your sync store interface must implement `mergeItemToList`.");
+    }
+};
+export const setStore = (storeToUse, storeOptions) => {
+    validateStoreInterface(storeToUse);
+    store = storeToUse;
+    options = storeOptions;
+};
+export const getStore = () => {
+    return store;
+};
+// sanitize graphql node names
+const sanitizeName = (name) => {
+    if (name !== undefined && name !== null) {
+        return name.replace(/\W/g, "");
+    }
+    else {
+        return null;
+    }
+};
+export const saveContentItem = async ({ contentItem, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    if (!contentItem || !contentItem.properties) {
+        logWarning("Null item or item with no properties cannot be saved");
+        return;
+    }
+    let definitionName = sanitizeName(contentItem.properties.definitionName);
+    let referenceName = contentItem.properties.referenceName;
+    if (contentItem.properties.state === 3) {
+        //if the item is deleted
+        const currentItem = await store.getItem({
+            options,
+            itemType: "item",
+            languageCode,
+            itemID: contentItem.contentID,
+        });
+        if (currentItem) {
+            //if the item is deleted, we need to grab the def and ref name from the current
+            definitionName = sanitizeName(currentItem.properties.definitionName);
+            referenceName = currentItem.properties.referenceName;
+            await store.deleteItem({
+                options,
+                itemType: "item",
+                languageCode,
+                itemID: contentItem.contentID,
+            });
+        }
+    }
+    else {
+        //regular item
+        if (!contentItem.properties.definitionName || !contentItem.properties.referenceName) {
+            logWarning(`Content with id ${contentItem.contentID} does not have the necessary properties to be saved.`);
+            return;
+        }
+        await store.saveItem({
+            options,
+            item: contentItem,
+            itemType: "item",
+            languageCode,
+            itemID: contentItem.contentID,
+        });
+    }
+    if (referenceName) {
+        //merge the item by reference or definition name - it might need to be merged into a list
+        await store.mergeItemToList({
+            options,
+            item: contentItem,
+            languageCode,
+            itemID: contentItem.contentID,
+            referenceName,
+            definitionName: definitionName || "",
+        });
+    }
+};
+export const savePageItem = async ({ pageItem, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    if (pageItem.properties.state === 3) {
+        //item is deleted
+        await store.deleteItem({
+            options,
+            itemType: "page",
+            languageCode,
+            itemID: pageItem.pageID,
+        });
+    }
+    else {
+        //regular item
+        await store.saveItem({
+            options,
+            item: pageItem,
+            itemType: "page",
+            languageCode,
+            itemID: pageItem.pageID,
+        });
+    }
+};
+export const saveSitemap = async ({ sitemap, channelName, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    await store.saveItem({
+        options,
+        item: sitemap,
+        itemType: "sitemap",
+        languageCode,
+        itemID: channelName,
+    });
+};
+export const saveSitemapNested = async ({ sitemapNested, channelName, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    await store.saveItem({
+        options,
+        item: sitemapNested,
+        itemType: "nestedsitemap",
+        languageCode,
+        itemID: channelName,
+    });
+};
+export const saveUrlRedirections = async ({ urlRedirections, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    await store.saveItem({
+        options,
+        item: urlRedirections,
+        itemType: "urlredirections",
+        languageCode,
+        itemID: "urlredirections",
+    });
+};
+export const getUrlRedirections = async ({ languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    return await store.getItem({
+        options,
+        itemType: "urlredirections",
+        languageCode,
+        itemID: "urlredirections",
+    });
+};
+export const saveSyncState = async ({ syncState, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    await store.saveItem({
+        options,
+        item: syncState,
+        itemType: "state",
+        languageCode,
+        itemID: "sync",
+    });
+};
+export const getSyncState = async (languageCode) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    return await store.getItem({
+        options,
+        itemType: "state",
+        languageCode,
+        itemID: "sync",
+    });
+};
+export const getContentItem = async ({ contentID, languageCode, depth, contentLinkDepth, expandAllContentLinks = false, skip, take }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    let finalDepth = 2;
+    if (depth !== undefined) {
+        finalDepth = depth;
+    }
+    else if (contentLinkDepth !== undefined) {
+        finalDepth = contentLinkDepth;
+    }
+    const contentItem = await store.getItem({
+        options,
+        itemType: "item",
+        languageCode,
+        itemID: contentID,
+    });
+    return await expandContentItem({ contentItem, languageCode, depth: finalDepth, expandAllContentLinks, skip, take });
+};
+const expandContentItem = async ({ contentItem, languageCode, depth, expandAllContentLinks = false, skip, take }) => {
+    if (!contentItem)
+        return null;
+    if (depth > 0) {
+        //make this work for the .fields or the .customFields property...
+        let fields = contentItem.fields;
+        if (!fields)
+            fields = contentItem.customFields;
+        for (const fieldName in fields) {
+            const fieldValue = fields[fieldName];
+            if (!fieldValue) {
+                //do nothing...
+                continue;
+            }
+            else if (fieldValue.contentid > 0) {
+                //single linked item
+                const childItem = await getContentItem({
+                    contentID: fieldValue.contentid,
+                    languageCode,
+                    depth: depth - 1,
+                    expandAllContentLinks,
+                    skip,
+                    take
+                });
+                if (childItem != null)
+                    fields[fieldName] = childItem;
+            }
+            else if (fieldValue.fulllist === true && fieldValue.referencename && expandAllContentLinks === true) {
+                //LINK TO THE FULL LIST
+                const referenceName = fieldValue.referencename;
+                const listSkip = skip || 0;
+                const listTake = take || 50;
+                const list = await getContentList({
+                    referenceName,
+                    languageCode,
+                    depth: depth - 1,
+                    expandAllContentLinks,
+                    skip: listSkip,
+                    take: listTake
+                });
+                let sortIDAry = [];
+                if (fieldValue.sortids && fieldValue.sortids.split) {
+                    sortIDAry = fieldValue.sortids.split(",");
+                }
+                let itemCount = 0;
+                const childItems = [];
+                for (const childItemID of sortIDAry) {
+                    itemCount++;
+                    const childItem = await getContentItem({
+                        contentID: parseInt(childItemID),
+                        languageCode,
+                        depth: depth - 1,
+                        expandAllContentLinks,
+                        skip: listSkip,
+                        take: listTake
+                    });
+                    if (childItem != null) {
+                        childItems.push(childItem);
+                    }
+                }
+                for (const listItem of list.items) {
+                    itemCount++;
+                    if (itemCount > 50)
+                        break;
+                    const listItemContentID = listItem.contentID;
+                    if (sortIDAry.includes(`${listItemContentID}`)) {
+                        continue;
+                    }
+                    const childItem = await getContentItem({
+                        contentID: listItemContentID,
+                        languageCode,
+                        depth: depth - 1,
+                        expandAllContentLinks,
+                        skip: listSkip,
+                        take: listTake
+                    });
+                    if (childItem != null)
+                        childItems.push(childItem);
+                }
+                fields[fieldName] = childItems;
+            }
+            else if (fieldValue.sortids && fieldValue.sortids.split && fieldValue.fulllist !== true) {
+                //MULTI LINKED ITEM
+                let sortIDAry = [];
+                if (fieldValue.sortids && fieldValue.sortids.split) {
+                    sortIDAry = fieldValue.sortids.split(",");
+                }
+                const listSkip = expandAllContentLinks ? (skip || 0) : undefined;
+                const listTake = expandAllContentLinks ? (take || 50) : undefined;
+                const childItems = [];
+                for (const childItemID of sortIDAry) {
+                    const childItem = await getContentItem({
+                        contentID: parseInt(childItemID),
+                        languageCode,
+                        depth: depth - 1,
+                        expandAllContentLinks,
+                        skip: listSkip,
+                        take: listTake
+                    });
+                    if (childItem != null)
+                        childItems.push(childItem);
+                }
+                fields[fieldName] = childItems;
+            }
+        }
+    }
+    return contentItem;
+};
+export const getContentList = async ({ referenceName, languageCode, depth, contentLinkDepth, expandAllContentLinks = false, skip = -1, take = -1 }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    let finalDepth = 0;
+    if (depth !== undefined) {
+        finalDepth = depth;
+    }
+    else if (contentLinkDepth !== undefined) {
+        finalDepth = contentLinkDepth;
+    }
+    let lst = await store.getItem({
+        options,
+        itemType: "list",
+        languageCode,
+        itemID: referenceName,
+    }) || [];
+    if (finalDepth > 0 && take === -1) {
+        throw new Error("If you specify depth > 0, you must also specify the take parameter.");
+    }
+    if (expandAllContentLinks && take === -1) {
+        throw new Error("If you specify expandAllContentLinks=true, you must also specify the take parameter.");
+    }
+    const totalCount = lst.length;
+    if (skip > 0 && skip < lst.length) {
+        lst = lst.slice(skip);
+    }
+    if (take > 0 && take < lst.length) {
+        lst = lst.slice(0, take);
+    }
+    if (finalDepth > 0) {
+        for (let i = 0; i < lst.length; i++) {
+            lst[i] = await expandContentItem({
+                contentItem: lst[i],
+                depth: finalDepth - 1,
+                languageCode,
+                expandAllContentLinks,
+                skip,
+                take
+            });
+        }
+    }
+    if (skip > 0 || take > 0) {
+        //if we have sliced this array, return an object with an items and totalCount property
+        return {
+            items: lst,
+            totalCount
+        };
+    }
+    else {
+        //just return the full list
+        return lst;
+    }
+};
+export const getPage = async ({ pageID, languageCode, depth, contentLinkDepth, expandAllContentLinks = false }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    let finalDepth = 2;
+    if (depth !== undefined) {
+        finalDepth = depth;
+    }
+    else if (contentLinkDepth !== undefined) {
+        finalDepth = contentLinkDepth;
+    }
+    let pageItem = await store.getItem({
+        options,
+        itemType: "page",
+        languageCode,
+        itemID: pageID,
+    });
+    if (finalDepth > 0) {
+        //if a depth was specified, pull in the modules (content items) for this page
+        for (const zoneName in pageItem.zones) {
+            const zone = pageItem.zones[zoneName];
+            for (const mod of zone) {
+                const moduleItem = await getContentItem({
+                    contentID: mod.item.contentid,
+                    languageCode,
+                    depth: finalDepth - 1,
+                    expandAllContentLinks
+                });
+                mod.item = moduleItem;
+            }
+        }
+    }
+    return pageItem;
+};
+export const getSitemap = async ({ channelName, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    return await store.getItem({
+        options,
+        itemType: "sitemap",
+        languageCode,
+        itemID: channelName,
+    });
+};
+export const getSitemapNested = async ({ channelName, languageCode }) => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    return await store.getItem({
+        options,
+        itemType: "nestedsitemap",
+        languageCode,
+        itemID: channelName,
+    });
+};
+export const clear = async () => {
+    if (!store || !options) {
+        throw new Error('Store not initialized. Call setStore first.');
+    }
+    await store.clearItems({ options });
+};

package/dist/sync-client.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'events';
+import { StoreInterface, StoreOptions } from './types/StoreInterface';
+import type { AgilityClient } from './types/AgilityClient';
+import { SyncProgress } from './types/SyncProgress';
+export interface SyncClientOptions extends StoreOptions {
+    contentModels?: boolean;
+    pageModels?: boolean;
+    content?: boolean;
+    pages?: boolean;
+    assets?: boolean;
+    galleries?: boolean;
+    containers?: boolean;
+}
+export declare class SyncClient extends EventEmitter {
+    store: StoreInterface;
+    agilityClient: AgilityClient;
+    private options;
+    private syncState;
+    constructor(store: StoreInterface, agilityClient: AgilityClient, options: SyncClientOptions);
+    syncContentModels(languageCode: string): Promise<AsyncGenerator<SyncProgress, void>>;
+    syncPageModels(): Promise<void>;
+    syncContent(): Promise<void>;
+    syncPages(): Promise<void>;
+    syncAssets(): Promise<void>;
+    syncGalleries(): Promise<void>;
+    syncContainers(): Promise<void>;
+    private updateSyncState;
+    clearSync(): Promise<void>;
+}

package/dist/sync-client.js

@@ -0,0 +1,126 @@
+import { EventEmitter } from 'events';
+import { logInfo, logError, logSuccess } from './util';
+import { syncContentModels } from './methods/syncContentModels';
+import { syncPageModels } from './methods/syncPageModels';
+import syncContent from './methods/syncContent';
+import syncPages from './methods/syncPages';
+import { syncAssets } from './methods/syncAssets';
+import { syncGalleries } from './methods/syncGalleries';
+import { syncContainers } from './methods/syncContainers';
+import { clearSync } from './methods/clearSync';
+export class SyncClient extends EventEmitter {
+    store;
+    agilityClient;
+    options;
+    syncState = {};
+    constructor(store, agilityClient, options) {
+        super();
+        this.store = store;
+        this.agilityClient = agilityClient;
+        this.options = options;
+    }
+    async syncContentModels(languageCode) {
+        const generator = syncContentModels.call({ store: this.store }, languageCode);
+        await this.updateSyncState('contentModels');
+        return generator;
+    }
+    async syncPageModels() {
+        try {
+            const pageModelsGenerator = syncPageModels.call({ store: this.store }, this.options.languageCode);
+            for await (const progress of pageModelsGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('pageModels');
+        }
+        catch (error) {
+            logError('Error syncing page models:', error);
+            throw error;
+        }
+    }
+    async syncContent() {
+        try {
+            const contentGenerator = syncContent.call({
+                store: this.store,
+                agilityClient: this.agilityClient
+            }, this.options.languageCode);
+            for await (const progress of contentGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('content');
+        }
+        catch (error) {
+            logError('Error syncing content:', error);
+            throw error;
+        }
+    }
+    async syncPages() {
+        try {
+            const pagesGenerator = syncPages.call({
+                store: this.store,
+                agilityClient: this.agilityClient
+            }, this.options.languageCode);
+            for await (const progress of pagesGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('pages');
+        }
+        catch (error) {
+            logError('Error syncing pages:', error);
+            throw error;
+        }
+    }
+    async syncAssets() {
+        try {
+            const assetsGenerator = syncAssets.call({ store: this.store }, this.options.languageCode);
+            for await (const progress of assetsGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('assets');
+        }
+        catch (error) {
+            logError('Error syncing assets:', error);
+            throw error;
+        }
+    }
+    async syncGalleries() {
+        try {
+            const galleriesGenerator = syncGalleries.call({ store: this.store }, this.options.languageCode);
+            for await (const progress of galleriesGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('galleries');
+        }
+        catch (error) {
+            logError('Error syncing galleries:', error);
+            throw error;
+        }
+    }
+    async syncContainers() {
+        try {
+            const containersGenerator = syncContainers.call({ store: this.store }, this.options.languageCode);
+            for await (const progress of containersGenerator) {
+                this.emit('progress', progress);
+            }
+            await this.updateSyncState('containers');
+        }
+        catch (error) {
+            logError('Error syncing containers:', error);
+            throw error;
+        }
+    }
+    async updateSyncState(model) {
+        this.syncState[model] = true;
+        logInfo(`Updated sync state for ${model}`);
+    }
+    async clearSync() {
+        try {
+            await clearSync.call({ store: this.store });
+            this.syncState = {};
+            logSuccess('Cleared sync state');
+        }
+        catch (error) {
+            logError('Error clearing sync:', error);
+            throw error;
+        }
+    }
+}

package/dist/types/AgilityClient.d.ts

@@ -0,0 +1,12 @@
+export interface AgilityClient {
+    getSyncContent(params: {
+        syncToken: number;
+        pageSize: number;
+        languageCode: string;
+    }): Promise<any>;
+    getSyncPages(params: {
+        syncToken: number;
+        pageSize: number;
+        languageCode: string;
+    }): Promise<any>;
+}

package/dist/types/AgilityClient.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Asset.d.ts

@@ -0,0 +1,18 @@
+export interface Asset {
+    assetID: number;
+    properties: {
+        fileName: string;
+        url: string;
+        size: number;
+        type: string;
+        state: number;
+    };
+}
+export interface Gallery {
+    galleryID: number;
+    properties: {
+        name: string;
+        state: number;
+    };
+    assets: Asset[];
+}

package/dist/types/Asset.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Container.d.ts

@@ -0,0 +1,15 @@
+export interface Container {
+    id: number;
+    name: string;
+    description?: string;
+    items: ContainerItem[];
+    languageCode: string;
+}
+export interface ContainerItem {
+    id: number;
+    title: string;
+    description?: string;
+    url: string;
+    thumbnailUrl?: string;
+    order: number;
+}

package/dist/types/Container.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ContentItem.d.ts

@@ -0,0 +1,20 @@
+export interface ContentItem {
+    contentID: number;
+    properties: {
+        definitionName: string;
+        referenceName: string;
+        state: number;
+    };
+    fields?: {
+        [key: string]: any;
+    };
+    customFields?: {
+        [key: string]: any;
+    };
+}
+export interface ContentItemField {
+    contentid?: number;
+    referencename?: string;
+    fulllist?: boolean;
+    sortids?: string;
+}

package/dist/types/ContentItem.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ContentModel.d.ts

@@ -0,0 +1,23 @@
+export interface ContentModel {
+    id: number;
+    name: string;
+    definitionName: string;
+    description?: string;
+    fields: ContentModelField[];
+    languageCode: string;
+}
+export interface ContentModelField {
+    name: string;
+    label: string;
+    type: string;
+    required: boolean;
+    defaultValue?: any;
+    validation?: ContentModelFieldValidation;
+}
+export interface ContentModelFieldValidation {
+    type: string;
+    message?: string;
+    pattern?: string;
+    min?: number;
+    max?: number;
+}

package/dist/types/ContentModel.js

@@ -0,0 +1 @@
+export {};