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

package/dist/methods/syncPages.js

@@ -0,0 +1,82 @@
+import { logInfo, logWarning, sleep } from '../util';
+/**
+ * Sync the pages in the specified Agility Instance.
+ * @param languageCode - The language code to sync pages for
+ * @param token - The sync token to start from
+ * @returns The last sync token used
+ */
+export default async function* syncPages(languageCode, token = 0) {
+    const storeInterface = this.store;
+    let itemCount = 0;
+    let busy = false;
+    let waitMS = 0;
+    const waitMaxMS = 10 * 60 * 1000;
+    const waitIntervalMS = 1000;
+    // Initialize progress
+    yield { status: 'init' };
+    do {
+        //sync pages...
+        const syncRet = await this.agilityClient.getSyncPages({
+            syncToken: token,
+            pageSize: 100,
+            languageCode: languageCode
+        });
+        if (syncRet === undefined || syncRet === null || (syncRet.busy !== undefined && syncRet.busy === true)) {
+            //if the api is being updated, wait a few ms and try again...
+            waitMS += waitIntervalMS;
+            if (waitMS > waitMaxMS) {
+                logWarning("Sync API has been busy for too long, canceling.");
+                break;
+            }
+            if (!busy) {
+                busy = true;
+                logInfo("Sync API is busy.  Waiting...");
+            }
+            await sleep(waitIntervalMS);
+            continue;
+        }
+        if (busy === true) {
+            logInfo("Continuing sync...");
+            waitMS = 0;
+            busy = false;
+        }
+        const syncItems = syncRet.items;
+        //if we have something...
+        if (syncItems.length > 0) {
+            for (let index = 0; index < syncItems.length; index++) {
+                const item = syncItems[index];
+                await storeInterface.saveItem({
+                    options: {
+                        rootPath: './data',
+                        languageCode: languageCode
+                    },
+                    item,
+                    itemType: 'page',
+                    languageCode,
+                    itemID: item.pageID
+                });
+                itemCount++;
+                yield {
+                    status: 'progress',
+                    current: itemCount,
+                    item,
+                    languageCode
+                };
+            }
+        }
+        if (syncRet.syncToken > token) {
+            token = syncRet.syncToken;
+        }
+        else {
+            break;
+        }
+    } while (token > 0 || busy === true);
+    if (itemCount > 0) {
+        logInfo(`Page Sync returned ${itemCount} item(s).`);
+    }
+    else {
+        logInfo(`Page Sync returned no item(s).`);
+    }
+    yield { status: 'done' };
+    return token;
+}

package/dist/store-interface-console.d.ts

@@ -0,0 +1,163 @@
+import { StoreInterface, StoreOptions } from './types/StoreInterface';
+import type { ContentItem } from './types/ContentItem';
+import type { Page } from './types/Page';
+import type { Asset } from './types/Asset';
+import type { Gallery } from './types/Gallery';
+import type { Container } from './types/Container';
+import type { ContentModel } from './types/ContentModel';
+import type { PageModel } from './types/PageModel';
+export declare class ConsoleStore implements StoreInterface {
+    private options;
+    constructor(options: StoreOptions);
+    clearItems(options: StoreOptions): Promise<void>;
+    deleteItem(params: {
+        options: StoreOptions;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<void>;
+    getItem(params: {
+        options: StoreOptions;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<any>;
+    saveItem(params: {
+        options: StoreOptions;
+        item: any;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<void>;
+    getContentItem(options: {
+        contentID: number;
+        languageCode: string;
+    }): Promise<ContentItem | null>;
+    saveContentItem(options: {
+        contentItem: ContentItem;
+        languageCode: string;
+    }): Promise<void>;
+    getContentItems(options: {
+        languageCode: string;
+    }): Promise<ContentItem[]>;
+    saveContentItems(options: {
+        contentItems: ContentItem[];
+        languageCode: string;
+    }): Promise<void>;
+    getPage(options: {
+        pageID: number;
+        languageCode: string;
+    }): Promise<Page | null>;
+    savePageItem(options: {
+        page: Page;
+        languageCode: string;
+    }): Promise<void>;
+    getPages(options: {
+        languageCode: string;
+    }): Promise<Page[]>;
+    savePageItems(options: {
+        pages: Page[];
+        languageCode: string;
+    }): Promise<void>;
+    getAsset(options: {
+        assetID: number;
+        languageCode: string;
+    }): Promise<Asset | null>;
+    saveAsset(options: {
+        asset: Asset;
+        languageCode: string;
+    }): Promise<void>;
+    getAssets(options: {
+        languageCode: string;
+    }): Promise<Asset[]>;
+    saveAssets(options: {
+        assets: Asset[];
+        languageCode: string;
+    }): Promise<void>;
+    getGallery(options: {
+        galleryID: number;
+        languageCode: string;
+    }): Promise<Gallery | null>;
+    saveGallery(options: {
+        gallery: Gallery;
+        languageCode: string;
+    }): Promise<void>;
+    getGalleries(options: {
+        languageCode: string;
+    }): Promise<Gallery[]>;
+    saveGalleries(options: {
+        galleries: Gallery[];
+        languageCode: string;
+    }): Promise<void>;
+    getContainer(options: {
+        containerID: number;
+        languageCode: string;
+    }): Promise<Container | null>;
+    saveContainer(options: {
+        container: Container;
+        languageCode: string;
+    }): Promise<void>;
+    getContainers(options: {
+        languageCode: string;
+    }): Promise<Container[]>;
+    saveContainers(options: {
+        containers: Container[];
+        languageCode: string;
+    }): Promise<void>;
+    getContentModel(options: {
+        contentModelID: number;
+        languageCode: string;
+    }): Promise<ContentModel | null>;
+    saveContentModel(options: {
+        contentModel: ContentModel;
+        languageCode: string;
+    }): Promise<void>;
+    getContentModels(options: {
+        languageCode: string;
+    }): Promise<ContentModel[]>;
+    saveContentModels(options: {
+        contentModels: ContentModel[];
+        languageCode: string;
+    }): Promise<void>;
+    getPageModel(options: {
+        pageModelID: number;
+        languageCode: string;
+    }): Promise<PageModel | null>;
+    savePageModel(options: {
+        pageModel: PageModel;
+        languageCode: string;
+    }): Promise<void>;
+    getPageModels(options: {
+        languageCode: string;
+    }): Promise<PageModel[]>;
+    savePageModels(options: {
+        pageModels: PageModel[];
+        languageCode: string;
+    }): Promise<void>;
+    getList(options: {
+        listName: string;
+        languageCode: string;
+    }): Promise<any[]>;
+    saveList(options: {
+        listName: string;
+        items: any[];
+        languageCode: string;
+    }): Promise<void>;
+    mergeItemToList(params: {
+        options: StoreOptions;
+        item: any;
+        languageCode: string;
+        itemID: string | number;
+        referenceName: string;
+        definitionName: string;
+    }): Promise<void>;
+    removeItemFromList(options: {
+        listName: string;
+        itemID: number;
+        languageCode: string;
+    }): Promise<void>;
+    initialize(options: StoreOptions): Promise<void>;
+    clearData(options: {
+        languageCode: string;
+    }): Promise<void>;
+}

package/dist/store-interface-console.js

@@ -0,0 +1,146 @@
+import { logDebug, logInfo } from './util';
+export class ConsoleStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async clearItems(options) {
+        logInfo('Clearing all items from console store');
+    }
+    async deleteItem(params) {
+        logDebug(`Deleting item: ${params.itemType} - ${params.itemID} (${params.languageCode})`);
+    }
+    async getItem(params) {
+        logDebug(`Getting item: ${params.itemType} - ${params.itemID} (${params.languageCode})`);
+        return null;
+    }
+    async saveItem(params) {
+        logDebug(`Saving item: ${params.itemType} - ${params.itemID} (${params.languageCode})`);
+    }
+    // Content Item methods
+    async getContentItem(options) {
+        logDebug(`Getting content item: ${options.contentID} (${options.languageCode})`);
+        return null;
+    }
+    async saveContentItem(options) {
+        logDebug(`Saving content item: ${options.contentItem.contentID} (${options.languageCode})`);
+    }
+    async getContentItems(options) {
+        logDebug(`Getting content items (${options.languageCode})`);
+        return [];
+    }
+    async saveContentItems(options) {
+        logDebug(`Saving ${options.contentItems.length} content items (${options.languageCode})`);
+    }
+    // Page methods
+    async getPage(options) {
+        logDebug(`Getting page: ${options.pageID} (${options.languageCode})`);
+        return null;
+    }
+    async savePageItem(options) {
+        logDebug(`Saving page: ${options.page.pageID} (${options.languageCode})`);
+    }
+    async getPages(options) {
+        logDebug(`Getting pages (${options.languageCode})`);
+        return [];
+    }
+    async savePageItems(options) {
+        logDebug(`Saving ${options.pages.length} pages (${options.languageCode})`);
+    }
+    // Asset methods
+    async getAsset(options) {
+        logDebug(`Getting asset: ${options.assetID} (${options.languageCode})`);
+        return null;
+    }
+    async saveAsset(options) {
+        logDebug(`Saving asset: ${options.asset.assetID} (${options.languageCode})`);
+    }
+    async getAssets(options) {
+        logDebug(`Getting assets (${options.languageCode})`);
+        return [];
+    }
+    async saveAssets(options) {
+        logDebug(`Saving ${options.assets.length} assets (${options.languageCode})`);
+    }
+    // Gallery methods
+    async getGallery(options) {
+        logDebug(`Getting gallery: ${options.galleryID} (${options.languageCode})`);
+        return null;
+    }
+    async saveGallery(options) {
+        logDebug(`Saving gallery: ${options.gallery.id} (${options.languageCode})`);
+    }
+    async getGalleries(options) {
+        logDebug(`Getting galleries (${options.languageCode})`);
+        return [];
+    }
+    async saveGalleries(options) {
+        logDebug(`Saving ${options.galleries.length} galleries (${options.languageCode})`);
+    }
+    // Container methods
+    async getContainer(options) {
+        logDebug(`Getting container: ${options.containerID} (${options.languageCode})`);
+        return null;
+    }
+    async saveContainer(options) {
+        logDebug(`Saving container: ${options.container.id} (${options.languageCode})`);
+    }
+    async getContainers(options) {
+        logDebug(`Getting containers (${options.languageCode})`);
+        return [];
+    }
+    async saveContainers(options) {
+        logDebug(`Saving ${options.containers.length} containers (${options.languageCode})`);
+    }
+    // Content Model methods
+    async getContentModel(options) {
+        logDebug(`Getting content model: ${options.contentModelID} (${options.languageCode})`);
+        return null;
+    }
+    async saveContentModel(options) {
+        logDebug(`Saving content model: ${options.contentModel.id} (${options.languageCode})`);
+    }
+    async getContentModels(options) {
+        logDebug(`Getting content models (${options.languageCode})`);
+        return [];
+    }
+    async saveContentModels(options) {
+        logDebug(`Saving ${options.contentModels.length} content models (${options.languageCode})`);
+    }
+    // Page Model methods
+    async getPageModel(options) {
+        logDebug(`Getting page model: ${options.pageModelID} (${options.languageCode})`);
+        return null;
+    }
+    async savePageModel(options) {
+        logDebug(`Saving page model: ${options.pageModel.id} (${options.languageCode})`);
+    }
+    async getPageModels(options) {
+        logDebug(`Getting page models (${options.languageCode})`);
+        return [];
+    }
+    async savePageModels(options) {
+        logDebug(`Saving ${options.pageModels.length} page models (${options.languageCode})`);
+    }
+    // List methods
+    async getList(options) {
+        logDebug(`Getting list: ${options.listName} (${options.languageCode})`);
+        return [];
+    }
+    async saveList(options) {
+        logDebug(`Saving list: ${options.listName} with ${options.items.length} items (${options.languageCode})`);
+    }
+    async mergeItemToList(params) {
+        logDebug(`Merging item to list: ${params.referenceName} - ${params.itemID} (${params.languageCode})`);
+    }
+    async removeItemFromList(options) {
+        logDebug(`Removing item from list: ${options.listName} - ${options.itemID} (${options.languageCode})`);
+    }
+    // Initialization methods
+    async initialize(options) {
+        this.options = options;
+    }
+    async clearData(options) {
+        logInfo(`Clearing data for language: ${options.languageCode}`);
+    }
+}

package/dist/store-interface-filesystem.d.ts

@@ -0,0 +1,166 @@
+import { StoreInterface, StoreOptions } from './types/StoreInterface';
+import type { ContentItem } from './types/ContentItem';
+import type { Page } from './types/Page';
+import type { Asset } from './types/Asset';
+import type { Gallery } from './types/Gallery';
+import type { Container } from './types/Container';
+import type { ContentModel } from './types/ContentModel';
+import type { PageModel } from './types/PageModel';
+export declare class FileSystemStore implements StoreInterface {
+    private options;
+    private basePath;
+    constructor(options: StoreOptions);
+    private ensureDirectoryExists;
+    private getItemPath;
+    clearItems(options: StoreOptions): Promise<void>;
+    deleteItem(params: {
+        options: StoreOptions;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<void>;
+    getItem(params: {
+        options: StoreOptions;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<any>;
+    saveItem(params: {
+        options: StoreOptions;
+        item: any;
+        itemType: string;
+        languageCode: string;
+        itemID: string | number;
+    }): Promise<void>;
+    getContentItem(options: {
+        contentID: number;
+        languageCode: string;
+    }): Promise<ContentItem | null>;
+    saveContentItem(options: {
+        contentItem: ContentItem;
+        languageCode: string;
+    }): Promise<void>;
+    getContentItems(options: {
+        languageCode: string;
+    }): Promise<ContentItem[]>;
+    saveContentItems(options: {
+        contentItems: ContentItem[];
+        languageCode: string;
+    }): Promise<void>;
+    getPage(options: {
+        pageID: number;
+        languageCode: string;
+    }): Promise<Page | null>;
+    savePageItem(options: {
+        page: Page;
+        languageCode: string;
+    }): Promise<void>;
+    getPages(options: {
+        languageCode: string;
+    }): Promise<Page[]>;
+    savePageItems(options: {
+        pages: Page[];
+        languageCode: string;
+    }): Promise<void>;
+    getAsset(options: {
+        assetID: number;
+        languageCode: string;
+    }): Promise<Asset | null>;
+    saveAsset(options: {
+        asset: Asset;
+        languageCode: string;
+    }): Promise<void>;
+    getAssets(options: {
+        languageCode: string;
+    }): Promise<Asset[]>;
+    saveAssets(options: {
+        assets: Asset[];
+        languageCode: string;
+    }): Promise<void>;
+    getGallery(options: {
+        galleryID: number;
+        languageCode: string;
+    }): Promise<Gallery | null>;
+    saveGallery(options: {
+        gallery: Gallery;
+        languageCode: string;
+    }): Promise<void>;
+    getGalleries(options: {
+        languageCode: string;
+    }): Promise<Gallery[]>;
+    saveGalleries(options: {
+        galleries: Gallery[];
+        languageCode: string;
+    }): Promise<void>;
+    getContainer(options: {
+        containerID: number;
+        languageCode: string;
+    }): Promise<Container | null>;
+    saveContainer(options: {
+        container: Container;
+        languageCode: string;
+    }): Promise<void>;
+    getContainers(options: {
+        languageCode: string;
+    }): Promise<Container[]>;
+    saveContainers(options: {
+        containers: Container[];
+        languageCode: string;
+    }): Promise<void>;
+    getContentModel(options: {
+        contentModelID: number;
+        languageCode: string;
+    }): Promise<ContentModel | null>;
+    saveContentModel(options: {
+        contentModel: ContentModel;
+        languageCode: string;
+    }): Promise<void>;
+    getContentModels(options: {
+        languageCode: string;
+    }): Promise<ContentModel[]>;
+    saveContentModels(options: {
+        contentModels: ContentModel[];
+        languageCode: string;
+    }): Promise<void>;
+    getPageModel(options: {
+        pageModelID: number;
+        languageCode: string;
+    }): Promise<PageModel | null>;
+    savePageModel(options: {
+        pageModel: PageModel;
+        languageCode: string;
+    }): Promise<void>;
+    getPageModels(options: {
+        languageCode: string;
+    }): Promise<PageModel[]>;
+    savePageModels(options: {
+        pageModels: PageModel[];
+        languageCode: string;
+    }): Promise<void>;
+    getList(options: {
+        listName: string;
+        languageCode: string;
+    }): Promise<any[]>;
+    saveList(options: {
+        listName: string;
+        items: any[];
+        languageCode: string;
+    }): Promise<void>;
+    mergeItemToList(params: {
+        options: StoreOptions;
+        item: any;
+        languageCode: string;
+        itemID: string | number;
+        referenceName: string;
+        definitionName: string;
+    }): Promise<void>;
+    removeItemFromList(options: {
+        listName: string;
+        itemID: number;
+        languageCode: string;
+    }): Promise<void>;
+    initialize(options: StoreOptions): Promise<void>;
+    clearData(options: {
+        languageCode: string;
+    }): Promise<void>;
+}