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

package/dist/store-interface-filesystem.js

@@ -0,0 +1,362 @@
+import { logDebug, logInfo } from './util';
+import * as fs from 'fs';
+import * as path from 'path';
+export class FileSystemStore {
+    options;
+    basePath;
+    constructor(options) {
+        this.options = options;
+        this.basePath = options.rootPath || './data';
+        this.ensureDirectoryExists(this.basePath);
+    }
+    ensureDirectoryExists(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    getItemPath(itemType, languageCode, itemID) {
+        const itemPath = path.join(this.basePath, languageCode, itemType);
+        this.ensureDirectoryExists(itemPath);
+        return path.join(itemPath, `${itemID}.json`);
+    }
+    async clearItems(options) {
+        logInfo('Clearing all items from filesystem store');
+        if (fs.existsSync(this.basePath)) {
+            fs.rmSync(this.basePath, { recursive: true, force: true });
+        }
+        this.ensureDirectoryExists(this.basePath);
+    }
+    async deleteItem(params) {
+        const filePath = this.getItemPath(params.itemType, params.languageCode, params.itemID);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            logDebug(`Deleted item: ${params.itemType} - ${params.itemID} (${params.languageCode})`);
+        }
+    }
+    async getItem(params) {
+        const filePath = this.getItemPath(params.itemType, params.languageCode, params.itemID);
+        if (fs.existsSync(filePath)) {
+            const data = fs.readFileSync(filePath, 'utf8');
+            return JSON.parse(data);
+        }
+        return null;
+    }
+    async saveItem(params) {
+        const filePath = this.getItemPath(params.itemType, params.languageCode, params.itemID);
+        fs.writeFileSync(filePath, JSON.stringify(params.item, null, 2));
+        logDebug(`Saved item: ${params.itemType} - ${params.itemID} (${params.languageCode})`);
+    }
+    // Content Item methods
+    async getContentItem(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'content',
+            languageCode: options.languageCode,
+            itemID: options.contentID
+        });
+    }
+    async saveContentItem(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.contentItem,
+            itemType: 'content',
+            languageCode: options.languageCode,
+            itemID: options.contentItem.contentID
+        });
+    }
+    async getContentItems(options) {
+        const contentPath = path.join(this.basePath, options.languageCode, 'content');
+        if (!fs.existsSync(contentPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(contentPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(contentPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async saveContentItems(options) {
+        for (const contentItem of options.contentItems) {
+            await this.saveContentItem({
+                contentItem,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Page methods
+    async getPage(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'page',
+            languageCode: options.languageCode,
+            itemID: options.pageID
+        });
+    }
+    async savePageItem(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.page,
+            itemType: 'page',
+            languageCode: options.languageCode,
+            itemID: options.page.pageID
+        });
+    }
+    async getPages(options) {
+        const pagePath = path.join(this.basePath, options.languageCode, 'page');
+        if (!fs.existsSync(pagePath)) {
+            return [];
+        }
+        const files = fs.readdirSync(pagePath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(pagePath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async savePageItems(options) {
+        for (const page of options.pages) {
+            await this.savePageItem({
+                page,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Asset methods
+    async getAsset(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'asset',
+            languageCode: options.languageCode,
+            itemID: options.assetID
+        });
+    }
+    async saveAsset(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.asset,
+            itemType: 'asset',
+            languageCode: options.languageCode,
+            itemID: options.asset.assetID
+        });
+    }
+    async getAssets(options) {
+        const assetPath = path.join(this.basePath, options.languageCode, 'asset');
+        if (!fs.existsSync(assetPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(assetPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(assetPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async saveAssets(options) {
+        for (const asset of options.assets) {
+            await this.saveAsset({
+                asset,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Gallery methods
+    async getGallery(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'gallery',
+            languageCode: options.languageCode,
+            itemID: options.galleryID
+        });
+    }
+    async saveGallery(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.gallery,
+            itemType: 'gallery',
+            languageCode: options.languageCode,
+            itemID: options.gallery.id
+        });
+    }
+    async getGalleries(options) {
+        const galleryPath = path.join(this.basePath, options.languageCode, 'gallery');
+        if (!fs.existsSync(galleryPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(galleryPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(galleryPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async saveGalleries(options) {
+        for (const gallery of options.galleries) {
+            await this.saveGallery({
+                gallery,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Container methods
+    async getContainer(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'container',
+            languageCode: options.languageCode,
+            itemID: options.containerID
+        });
+    }
+    async saveContainer(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.container,
+            itemType: 'container',
+            languageCode: options.languageCode,
+            itemID: options.container.id
+        });
+    }
+    async getContainers(options) {
+        const containerPath = path.join(this.basePath, options.languageCode, 'container');
+        if (!fs.existsSync(containerPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(containerPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(containerPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async saveContainers(options) {
+        for (const container of options.containers) {
+            await this.saveContainer({
+                container,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Content Model methods
+    async getContentModel(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'contentmodel',
+            languageCode: options.languageCode,
+            itemID: options.contentModelID
+        });
+    }
+    async saveContentModel(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.contentModel,
+            itemType: 'contentmodel',
+            languageCode: options.languageCode,
+            itemID: options.contentModel.id
+        });
+    }
+    async getContentModels(options) {
+        const contentModelPath = path.join(this.basePath, options.languageCode, 'contentmodel');
+        if (!fs.existsSync(contentModelPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(contentModelPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(contentModelPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async saveContentModels(options) {
+        for (const contentModel of options.contentModels) {
+            await this.saveContentModel({
+                contentModel,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // Page Model methods
+    async getPageModel(options) {
+        return this.getItem({
+            options: this.options,
+            itemType: 'pagemodel',
+            languageCode: options.languageCode,
+            itemID: options.pageModelID
+        });
+    }
+    async savePageModel(options) {
+        await this.saveItem({
+            options: this.options,
+            item: options.pageModel,
+            itemType: 'pagemodel',
+            languageCode: options.languageCode,
+            itemID: options.pageModel.id
+        });
+    }
+    async getPageModels(options) {
+        const pageModelPath = path.join(this.basePath, options.languageCode, 'pagemodel');
+        if (!fs.existsSync(pageModelPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(pageModelPath);
+        return files.map(file => {
+            const data = fs.readFileSync(path.join(pageModelPath, file), 'utf8');
+            return JSON.parse(data);
+        });
+    }
+    async savePageModels(options) {
+        for (const pageModel of options.pageModels) {
+            await this.savePageModel({
+                pageModel,
+                languageCode: options.languageCode
+            });
+        }
+    }
+    // List methods
+    async getList(options) {
+        const listPath = path.join(this.basePath, options.languageCode, 'list', `${options.listName}.json`);
+        if (!fs.existsSync(listPath)) {
+            return [];
+        }
+        const data = fs.readFileSync(listPath, 'utf8');
+        return JSON.parse(data);
+    }
+    async saveList(options) {
+        const listPath = path.join(this.basePath, options.languageCode, 'list');
+        this.ensureDirectoryExists(listPath);
+        fs.writeFileSync(path.join(listPath, `${options.listName}.json`), JSON.stringify(options.items, null, 2));
+    }
+    async mergeItemToList(params) {
+        const listPath = path.join(this.basePath, params.languageCode, 'list');
+        this.ensureDirectoryExists(listPath);
+        const listFile = path.join(listPath, `${params.referenceName}.json`);
+        let items = [];
+        if (fs.existsSync(listFile)) {
+            const data = fs.readFileSync(listFile, 'utf8');
+            items = JSON.parse(data);
+        }
+        const index = items.findIndex(item => item.id === params.itemID);
+        if (index >= 0) {
+            items[index] = params.item;
+        }
+        else {
+            items.push(params.item);
+        }
+        fs.writeFileSync(listFile, JSON.stringify(items, null, 2));
+    }
+    async removeItemFromList(options) {
+        const listPath = path.join(this.basePath, options.languageCode, 'list', `${options.listName}.json`);
+        if (!fs.existsSync(listPath)) {
+            return;
+        }
+        const data = fs.readFileSync(listPath, 'utf8');
+        const items = JSON.parse(data);
+        const filteredItems = items.filter((item) => item.id !== options.itemID);
+        fs.writeFileSync(listPath, JSON.stringify(filteredItems, null, 2));
+    }
+    // Initialization methods
+    async initialize(options) {
+        this.options = options;
+        this.basePath = options.rootPath || './data';
+        this.ensureDirectoryExists(this.basePath);
+    }
+    async clearData(options) {
+        const languagePath = path.join(this.basePath, options.languageCode);
+        if (fs.existsSync(languagePath)) {
+            fs.rmSync(languagePath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/store-interface.d.ts

@@ -0,0 +1,69 @@
+import { StoreInterface, StoreOptions } from './types/StoreInterface';
+import { ContentItem } from './types/ContentItem';
+import { Page } from './types/Page';
+export declare const setStore: (storeToUse: StoreInterface, storeOptions: StoreOptions) => void;
+export declare const getStore: () => StoreInterface | null;
+export declare const saveContentItem: ({ contentItem, languageCode }: {
+    contentItem: ContentItem;
+    languageCode: string;
+}) => Promise<void>;
+export declare const savePageItem: ({ pageItem, languageCode }: {
+    pageItem: Page;
+    languageCode: string;
+}) => Promise<void>;
+export declare const saveSitemap: ({ sitemap, channelName, languageCode }: {
+    sitemap: any;
+    channelName: string;
+    languageCode: string;
+}) => Promise<void>;
+export declare const saveSitemapNested: ({ sitemapNested, channelName, languageCode }: {
+    sitemapNested: any;
+    channelName: string;
+    languageCode: string;
+}) => Promise<void>;
+export declare const saveUrlRedirections: ({ urlRedirections, languageCode }: {
+    urlRedirections: any;
+    languageCode: string;
+}) => Promise<void>;
+export declare const getUrlRedirections: ({ languageCode }: {
+    languageCode: string;
+}) => Promise<any>;
+export declare const saveSyncState: ({ syncState, languageCode }: {
+    syncState: any;
+    languageCode: string;
+}) => Promise<void>;
+export declare const getSyncState: (languageCode: string) => Promise<any>;
+export declare const getContentItem: ({ contentID, languageCode, depth, contentLinkDepth, expandAllContentLinks, skip, take }: {
+    contentID: number;
+    languageCode: string;
+    depth?: number;
+    contentLinkDepth?: number;
+    expandAllContentLinks?: boolean;
+    skip?: number;
+    take?: number;
+}) => Promise<ContentItem | null>;
+export declare const getContentList: ({ referenceName, languageCode, depth, contentLinkDepth, expandAllContentLinks, skip, take }: {
+    referenceName: string;
+    languageCode: string;
+    depth?: number;
+    contentLinkDepth?: number;
+    expandAllContentLinks?: boolean;
+    skip?: number;
+    take?: number;
+}) => Promise<any>;
+export declare const getPage: ({ pageID, languageCode, depth, contentLinkDepth, expandAllContentLinks }: {
+    pageID: number;
+    languageCode: string;
+    depth?: number;
+    contentLinkDepth?: number;
+    expandAllContentLinks?: boolean;
+}) => Promise<Page | null>;
+export declare const getSitemap: ({ channelName, languageCode }: {
+    channelName: string;
+    languageCode: string;
+}) => Promise<any>;
+export declare const getSitemapNested: ({ channelName, languageCode }: {
+    channelName: string;
+    languageCode: string;
+}) => Promise<any>;
+export declare const clear: () => Promise<void>;