@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.1

package/dist/core/repository/RemoteCollectionRepository.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteCollectionRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const contentful_1 = require("../contentful");
+// class
+class RemoteCollectionRepository {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async create(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createRaw(args) {
+        // locale
+        const locale = this.sdk.locales.default;
+        const groupId = funnel_core_1.Value.uuid();
+        const brand = funnel_core_1.AppConfig.brand();
+        const name = args.name;
+        // create entry
+        const entry = await this.sdk.cma.entry.create({ contentTypeId: contentful_1.ContentfulCollection.contentTypeId }, {
+            fields: {
+                groupId: { [locale]: groupId },
+                type: { [locale]: args.template.type },
+                version: { [locale]: args.template.version },
+                brand: { [locale]: brand },
+                name: { [locale]: name },
+                tags: { [locale]: JSON.stringify(args.tags) },
+                language: { [locale]: args.language },
+            }
+        });
+        // serialize entry to data
+        const data = contentful_1.ContentfulCollection.serializeRemote(entry, locale);
+        // return as group data
+        return {
+            collection: {
+                data,
+                collections: {},
+                files: {}
+            },
+            group: {
+                groupId,
+                type: args.template.type,
+                brand,
+                name,
+                instances: [{
+                        id: data.id,
+                        version: data.version,
+                        language: data.language,
+                        tags: data.tags
+                    }]
+            }
+        };
+    }
+    async createLanguage(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(collection) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish(collection) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getOverview(args) {
+        // locale
+        const locale = this.sdk.locales.default;
+        // collection templates
+        const templates = funnel_core_1.Schema.Site.current().collections;
+        // set counts to zero
+        const collectionCounts = new Map();
+        templates.forEach(template => collectionCounts.set(template.type, 0));
+        // fetch thin collections
+        const collections = await contentful_1.Contentful.allEntries(this.sdk, {
+            content_type: contentful_1.ContentfulCollection.contentTypeId,
+            select: 'fields.type'
+        });
+        // count each type
+        collections.forEach(collection => {
+            const type = collection.fields.type[locale];
+            const count = collectionCounts.get(type);
+            if (count !== undefined) {
+                collectionCounts.set(type, count + 1);
+            }
+        });
+        // return decorated templates
+        return templates.map(template => {
+            var _a;
+            return ({
+                template,
+                type: template.type,
+                count: (_a = collectionCounts.get(template.type)) !== null && _a !== void 0 ? _a : 0
+            });
+        });
+    }
+    async getItems({ type, tags, language }) {
+        // locale
+        const locale = this.sdk.locales.default;
+        // query entries
+        // TODO: implement tags filter
+        const items = await contentful_1.Contentful.allEntries(this.sdk, {
+            content_type: contentful_1.ContentfulCollection.contentTypeId,
+            [`fields.type.${locale}`]: type
+        });
+        // group entries by groupId
+        const groups = new Map();
+        items.forEach(item => {
+            const groupId = item.fields.groupId[locale];
+            const group = groups.get(groupId);
+            if (group) {
+                group.push(item);
+            }
+            else {
+                groups.set(groupId, [item]);
+            }
+        });
+        // create items
+        const result = [];
+        for (const [groupId, entries] of groups) {
+            // find entry matching arg language
+            const mainEntry = entries.find(entry => entry.fields.language[locale] === language);
+            if (!mainEntry) {
+                continue;
+            }
+            // create item
+            result.push({
+                id: mainEntry.sys.id,
+                type: mainEntry.fields.type[locale],
+                groupId: groupId,
+                name: mainEntry.fields.name[locale],
+                refs: entries.reduce((refs, ref) => {
+                    // serialize ref
+                    const refLang = ref.fields.language[locale];
+                    refs[refLang] = contentful_1.ContentfulCollection.serializeRemoteRef(ref, locale);
+                    // keep reducing
+                    return refs;
+                }, {})
+            });
+        }
+        return result;
+    }
+    async get({ id }) {
+        // locale
+        const locale = this.sdk.locales.default;
+        // search by id (expect 0 or 1 items)
+        const response = await this.sdk.cma.entry.getMany({
+            query: { 'sys.id': id, include: 1 }
+        });
+        // no results
+        if (response.items.length === 0) {
+            return undefined;
+        }
+        // bad state
+        else if (response.items.length > 1) {
+            throw new funnel_core_1.IllegalStateError(`There is more than one entry with id "${id}"`);
+        }
+        // serialize single item
+        else {
+            return contentful_1.ContentfulCollection.serializeRemoteWithRefs(response.items[0], locale);
+        }
+    }
+    async update(args) {
+        // locale
+        const locale = this.sdk.locales.default;
+        // fetch latest version of collection
+        const entry = await this.sdk.cma.entry.get({ entryId: args.id });
+        const data = contentful_1.ContentfulCollection.serializeRemote(entry, locale);
+        // apply updates
+        const model = new funnel_core_1.Schema.CollectionModel(data);
+        model.update(args.updates);
+        // update fields
+        entry.fields.name = { [locale]: data.name };
+        entry.fields.fields = { [locale]: data.fields };
+        // update entry
+        const updatedEntry = await this.sdk.cma.entry.update({ entryId: args.id }, entry);
+        const updatedOn = new Date(updatedEntry.sys.updatedAt).getTime();
+        // return
+        return {
+            // TODO: get latest references
+            collection: { data, collections: {}, files: {} },
+            updatedOn,
+            changeSetId: ''
+        };
+    }
+    serializeUpdate(collection, savables) {
+        // add name updates
+        const { id, nameField, name, initialTags, tags, fields, initialErrors, valid } = collection;
+        const updates = [];
+        if (nameField.modified) {
+            updates.push({
+                type: 'collection',
+                property: 'name',
+                value: name
+            });
+            // track change
+            savables.push(nameField);
+        }
+        // add tag updates
+        if (initialTags.symmetricDifference(tags).size > 0) {
+            updates.push({
+                type: 'collection',
+                property: 'tags',
+                value: Array.from(tags).map(tag => tag.data)
+            });
+        }
+        // add errors updates
+        if (initialErrors !== !valid) {
+            updates.push({
+                type: 'collection',
+                property: 'errors',
+                value: !valid
+            });
+        }
+        // add fields
+        components_1.SerializeCollectionUpdate.serializeFieldsUpdate(updates, fields, ['fields'], savables);
+        // return updates
+        return {
+            id,
+            updates,
+            updatedOn: Date.now()
+        };
+    }
+    async getReferences(collectionId) {
+        // setup
+        const { sdk } = this;
+        const locale = sdk.locales.default;
+        // fetch references
+        const references = await sdk.cma.entry.references({
+            entryId: collectionId,
+            include: 10
+        });
+        // serialize and return
+        return contentful_1.ContentfulRefs.serialize(references, locale);
+    }
+}
+exports.RemoteCollectionRepository = RemoteCollectionRepository;

package/dist/core/repository/RemotePageRepository.d.ts

@@ -0,0 +1,14 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { Schema } from '@nascentdigital/funnel-core';
+import { IPage, IPageRepository } from '@nascentdigital/funnel-editor/components';
+export declare class RemotePageRepository implements IPageRepository {
+    readonly sdk: EditorAppSDK;
+    constructor(sdk: EditorAppSDK);
+    search(args: IPageRepository.Search.Args): Promise<IPageRepository.Search.Result>;
+    create(args: IPageRepository.Create.Args): Promise<IPageRepository.Create.Result>;
+    createLanguage(args: IPageRepository.CreateLang.Args): Promise<IPageRepository.CreateLang.Result>;
+    save(page: IPage): Promise<IPage>;
+    unpublish(page: IPage): Promise<void>;
+    getOverview(args: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
+    getReferences(pageId: Schema.Page.Id): Promise<IPage.References>;
+}

package/dist/core/repository/RemotePageRepository.js

@@ -0,0 +1,113 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemotePageRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const contentful_1 = require("../contentful");
+// class
+class RemotePageRepository {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async search(args) {
+        // locale
+        const locale = this.sdk.locales.default;
+        // templates
+        const templates = funnel_core_1.Schema.Site.current().regions[args.region];
+        // fetch all pages
+        // TODO: implement paging
+        // TODO: implement other search args
+        const pages = await contentful_1.Contentful.allEntries(this.sdk, {
+            content_type: contentful_1.ContentfulPage.contentTypeId,
+            [`fields.type`]: args.template.type
+        });
+        // return result
+        return {
+            items: pages.map(page => {
+                const _a = contentful_1.ContentfulPage.serializeRemoteLink(page, locale), { type, tags } = _a, data = __rest(_a, ["type", "tags"]);
+                const template = templates[type];
+                return Object.assign({ template, tags: components_1.TagSerializer.deserializeTags({
+                        groups: template.tags,
+                        tagsData: tags
+                    }) }, data);
+            }),
+            page: 1,
+            pageCount: 1,
+            totalItemCount: pages.length
+        };
+    }
+    async create(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createLanguage(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(page) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish(page) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getOverview(args) {
+        // fetch all pages
+        const pages = await contentful_1.Contentful.allEntriesNormalized(this.sdk, {
+            content_type: contentful_1.ContentfulPage.contentTypeId
+        });
+        // enrich with templates and flip to array
+        const templates = Object.values(funnel_core_1.Schema.Site.current().regions[args.region]);
+        return templates.map(template => {
+            // extract static page overview
+            const { type } = template;
+            if (template.variant === 'static') {
+                const staticPages = pages.filter(page => page.type === type);
+                return new components_1.StaticPageOverview({
+                    template,
+                    type,
+                    refs: staticPages.reduce((refs, page) => {
+                        // page language (bail if no language)
+                        const language = page.language;
+                        if (!language) {
+                            return refs;
+                        }
+                        // add page link
+                        refs[language] = contentful_1.ContentfulPage.normalizedToLink(page);
+                        // keep reducing
+                        return refs;
+                    }, {})
+                });
+            }
+            // or dynamic one
+            else {
+                return new components_1.DynamicPageOverview({
+                    template,
+                    type,
+                    count: pages.filter(page => page.type === type).length,
+                });
+            }
+        });
+    }
+    async getReferences(pageId) {
+        // setup
+        const { sdk } = this;
+        const locale = sdk.locales.default;
+        // fetch references
+        const references = await sdk.cma.entry.references({
+            entryId: pageId,
+            include: 10
+        });
+        // serialize and return
+        return contentful_1.ContentfulRefs.serialize(references, locale);
+    }
+}
+exports.RemotePageRepository = RemotePageRepository;

package/dist/core/repository/index.d.ts

@@ -1 +1,5 @@
-export * from './PageRepository';
+export * from './AssetRepository';
+export * from './LocalCollectionRepository';
+export * from './LocalPageRepository';
+export * from './RemoteCollectionRepository';
+export * from './RemotePageRepository';

package/dist/core/repository/index.js

@@ -14,4 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./PageRepository"), exports);
+__exportStar(require("./AssetRepository"), exports);
+__exportStar(require("./LocalCollectionRepository"), exports);
+__exportStar(require("./LocalPageRepository"), exports);
+__exportStar(require("./RemoteCollectionRepository"), exports);
+__exportStar(require("./RemotePageRepository"), exports);

package/dist/page/{hooks/PageController.d.ts → controller/LocalPageController.d.ts}

@@ -1,13 +1,15 @@
 import { Language } from '@nascentdigital/funnel-core';
 import { IPage, IPageController, PageSummary } from '@nascentdigital/funnel-editor/components';
-import { EditorApiClient, Page, PageRepository } from '../../core';
-export declare class PageController implements IPageController {
+import { Page, LocalPageRepository, RemotePageRepository } from '../../core';
+export declare class LocalPageController implements IPageController {
+    readonly localRepository: LocalPageRepository;
+    readonly remoteRepository: RemotePageRepository;
     private readonly _eventBus;
     private _state;
     private _pageSummary?;
     private _page?;
-    readonly repository: PageRepository;
-    constructor({ editorApi }: PageController.ConstructorArgs);
+    private _pageSubscription?;
+    constructor({ localRepository, remoteRepository }: LocalPageController.ConstructorArgs);
     get events$(): import("rxjs").Observable<IPage.Event | IPageController.Event>;
     get saved$(): import("rxjs").Observable<[IPageController.StateChangedEvent, IPageController.StateChangedEvent]>;
     get state(): IPageController.State;
@@ -18,14 +20,17 @@ export declare class PageController implements IPageController {
     private set pageSummary(value);
     get page(): Page | undefined;
     private set page(value);
+    sync(updatedOn: number): Promise<void>;
     load(): Promise<void>;
     create(target: IPageController.Target): Promise<void>;
+    save(page: Page): Promise<void>;
     reload(): Promise<void>;
     unpublish(): Promise<void>;
     private raiseEvent;
 }
-export declare namespace PageController {
+export declare namespace LocalPageController {
     type ConstructorArgs = {
-        editorApi: EditorApiClient;
+        localRepository: LocalPageRepository;
+        remoteRepository: RemotePageRepository;
     };
 }

package/dist/page/controller/LocalPageController.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPageController = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const rxjs_1 = require("rxjs");
+// class
+class LocalPageController {
+    constructor({ localRepository, remoteRepository }) {
+        // initialize instance variables
+        this.localRepository = localRepository;
+        this.remoteRepository = remoteRepository;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+    }
+    get events$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)((e) => components_1.IPageController.Event.filter(e) || components_1.IPage.Event.filter(e)));
+    }
+    get saved$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)(components_1.IPageController.StateChangedEvent.filter), (0, rxjs_1.pairwise)(), (0, rxjs_1.filter)(([previous, current]) => previous.state === 'saving' && current.state === 'ready'));
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        // skip if unchanged
+        if (this._state === value) {
+            return;
+        }
+        // or update
+        this._state = value;
+        // raise event
+        this._eventBus.publish(components_1.IPageController.StateChangedEvent.create({
+            state: value,
+            controller: this
+        }));
+    }
+    get ready() {
+        const { _state } = this;
+        return _state !== 'uninitialized' && _state !== 'initializing';
+    }
+    get languages() {
+        return [];
+    }
+    get pageSummary() {
+        return this._pageSummary;
+    }
+    set pageSummary(pageSummary) {
+        // skip if summary is the same
+        if (this._pageSummary === pageSummary) {
+            return;
+        }
+        // update summary
+        this._pageSummary = pageSummary;
+        // raise event
+        this.raiseEvent('pageSummary.changed');
+    }
+    get page() {
+        return this._page;
+    }
+    set page(page) {
+        // skip if page is the same
+        if (this._page === page) {
+            console.debug('[CE][PageController] skipping page set, same instance');
+            return;
+        }
+        // unbind previous page subscription (if any)
+        if (this._pageSubscription) {
+            this._pageSubscription.unsubscribe();
+            delete this._pageSubscription;
+        }
+        console.debug('[CE][PageController] new page instance set');
+        // update page
+        this._page = page;
+        // subscribe to page changes
+        if (page) {
+            // subscribe to page events
+            this._pageSubscription = page.events$
+                .pipe((0, rxjs_1.tap)(e => console.debug('[CE][PageController] page event', e)), (0, rxjs_1.filter)(e => {
+                // handle page events
+                if (components_1.IPage.Event.filter(e)) {
+                    return e.type === 'modified';
+                }
+                // or item/object/list events
+                else if (components_1.Item.Event.filter(e)
+                    || components_1.Item.Event.filter(e)
+                    || funnel_core_1.ObjectField.Event.filter(e)
+                    || funnel_core_1.FieldList.Event.filter(e)) {
+                    return e.type === 'changed';
+                }
+                // or field
+                else {
+                    return funnel_core_1.Field.Event.filter(e) && (e.type === 'changed' || e.type === 'reset');
+                }
+            }), (0, rxjs_1.debounce)(e => {
+                return (0, rxjs_1.interval)(1000);
+            }))
+                .subscribe(async (e) => {
+                if (page.modified && this._page === page) {
+                    await this.save(page);
+                }
+            });
+        }
+        // raise state change
+        this.raiseEvent('page.changed');
+    }
+    async sync(updatedOn) {
+        // get current page
+        const page = this._page;
+        // bail if no page
+        if (!page) {
+            console.warn('[CE][PageController] tried to sync with no page');
+            return;
+        }
+        // skip if page already in sync
+        if (page.updatedOn >= updatedOn) {
+            console.debug('[CE][PageController] skipping sync, page already in sync');
+            return;
+        }
+        // skip if saving already
+        if (this.state === 'saving') {
+            console.debug('[CE][PageController] skipping sync while saving');
+            return;
+        }
+        // start fresh load
+        console.debug('[CE][PageController] syncing, page out of date...');
+        await this.load();
+    }
+    async load() {
+        // mark as loading (or initialing if loading for first time)
+        this.state = this._state === 'uninitialized'
+            ? 'initializing'
+            : 'loading';
+        // try to load page
+        try {
+            // load page
+            const page = await this.localRepository.load({ eventBus: this._eventBus });
+            // get page references
+            if (page) {
+                const references = await this.remoteRepository.getReferences(page.id);
+                page.hydrateStores(references);
+            }
+            // set page
+            // TODO: create real page summary
+            this.pageSummary = new components_1.PageSummary({ pages: [{ state: 'draft' }] });
+            this.page = page;
+            // update state
+            this.state = 'ready';
+        }
+        // handle error
+        catch (e) {
+            console.error('[CE][PageController] failed to load page', e);
+            // set error state
+            this.state = 'error';
+        }
+    }
+    async create(target) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(page) {
+        // try to save page
+        try {
+            console.debug('[CE][PageController/save] starting save');
+            // update state
+            this.state = 'saving';
+            // save page
+            const updatedPage = await this.localRepository.save(page);
+            this.page = updatedPage;
+            // update state
+            this.state = 'ready';
+            console.debug('[CE][PageController/save] save finished');
+        }
+        // handle error
+        catch (e) {
+            console.error('[CE][PageController/save] save failed', e);
+            // update state
+            this.state = 'error';
+        }
+    }
+    async reload() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(components_1.IPageController.Event.create({ type, controller: this }));
+    }
+}
+exports.LocalPageController = LocalPageController;

package/dist/page/controller/LocalPageControllerContainer.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import { RemotePageRepository } from '../../core';
+export declare function LocalPageControllerContainer({ children, remoteRepository }: LocalPageControllerContainer.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace LocalPageControllerContainer {
+    type Props = PropsWithChildren & {
+        remoteRepository: RemotePageRepository;
+    };
+}

package/dist/page/controller/LocalPageControllerContainer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPageControllerContainer = LocalPageControllerContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_apps_toolkit_1 = require("@contentful/react-apps-toolkit");
+const react_1 = require("react");
+const core_1 = require("../../core");
+const LocalPageController_1 = require("./LocalPageController");
+const LocalPageControllerContext_1 = require("./LocalPageControllerContext");
+// container
+function LocalPageControllerContainer({ children, remoteRepository }) {
+    // bind context
+    const sdk = (0, react_apps_toolkit_1.useSDK)();
+    const context = (0, react_1.useMemo)(() => {
+        console.debug('[CE][PageControllerContainer] creating page controller');
+        const localRepository = new core_1.LocalPageRepository(sdk);
+        // return context
+        return {
+            controller: new LocalPageController_1.LocalPageController({ localRepository, remoteRepository })
+        };
+    }, [sdk, remoteRepository]);
+    // listen to page changes
+    (0, react_1.useEffect)(() => {
+        // get controller
+        const { controller } = context;
+        // sync on change
+        sdk.entry.onSysChanged(sys => {
+            // get updatedOn in milliseconds
+            const updatedOn = new Date(sys.updatedAt).getTime();
+            // call sync
+            controller.sync(updatedOn).catch(console.error);
+        });
+    }, [sdk, context]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(LocalPageControllerContext_1.LocalPageControllerContext.Provider, { value: context, children: children }));
+}

package/dist/page/controller/LocalPageControllerContext.d.ts

@@ -0,0 +1,7 @@
+import { LocalPageController } from './LocalPageController';
+export declare const LocalPageControllerContext: import("react").Context<LocalPageControllerContext.Type>;
+export declare namespace LocalPageControllerContext {
+    type Type = {
+        controller: LocalPageController;
+    };
+}

package/dist/page/controller/LocalPageControllerContext.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPageControllerContext = void 0;
+const react_1 = require("react");
+// context
+exports.LocalPageControllerContext = (0, react_1.createContext)({});

package/dist/page/controller/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LocalPageController';
+export * from './LocalPageControllerContainer';
+export * from './useLocalPageController';