@agility/content-sync 1.2.0-beta.4 → 1.2.0-beta.6

package/dist/store-interface-filesystem.js

@@ -1,362 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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>;