@nascentdigital/funnel-editor-contentful 5.0.1 → 5.0.3

package/dist/collection/controller/ContentfulCollectionController.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCollectionController = 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 ContentfulCollectionController {
+    constructor(args) {
+        // initialize instance variables
+        this.collectionRepository = args.collectionRepository;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+    }
+    get events$() {
+        return this._eventBus.events$
+            .pipe((0, rxjs_1.filter)(e => components_1.ICollectionController.Event.filter(e) || components_1.ICollection.Event.filter(e)));
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        // skip if unchanged
+        if (this._state === value) {
+            return;
+        }
+        // or update
+        this._state = value;
+        // raise event
+        this.raiseEvent('state.changed');
+        // process queues if ready (might be noop)
+        if (value === 'ready') {
+            this.processQueues().catch(console.error);
+        }
+    }
+    get ready() {
+        const { _state } = this;
+        return _state !== 'uninitialized' && _state !== 'initializing';
+    }
+    get languages() {
+        const brand = funnel_core_1.AppConfig.brandConfig();
+        return funnel_core_1.RegionsConfig.getLanguages(brand.regionalization);
+    }
+    get collectionSys() {
+        return this._collectionSys;
+    }
+    set collectionSys(sys) {
+        this._collectionSys = sys;
+    }
+    get collectionGroup() {
+        return this._collectionGroup;
+    }
+    set collectionGroup(collectionGroup) {
+        // skip if group is the same
+        if (this._collectionGroup === collectionGroup) {
+            return;
+        }
+        // update group
+        this._collectionGroup = collectionGroup;
+        // raise event
+        this.raiseEvent('collectionGroup.changed');
+    }
+    get collection() {
+        return this._collection;
+    }
+    set collection(collection) {
+        // skip if collection is the same
+        if (this._collection === collection) {
+            console.debug('[ContentfulCollectionController] ignoring collection change for', collection);
+            return;
+        }
+        // unbind previous subscription (if any)
+        if (this._collectionSubscription) {
+            this._collectionSubscription.unsubscribe();
+            delete this._collectionSubscription;
+        }
+        console.debug('[ContentfulCollectionController] updating to new collection', collection);
+        // update collection
+        this._collection = collection;
+        // subscribe to collection changes
+        if (collection) {
+            this._collectionSubscription = collection.events$
+                .pipe((0, rxjs_1.filter)(e => {
+                // handle collection events
+                if (components_1.ICollection.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 => {
+                if ((components_1.ICollection.Event.filter(e) && e.type === 'modified')
+                    || components_1.Item.Event.filter(e)
+                    || funnel_core_1.FieldList.Event.filter(e)
+                    || (funnel_core_1.Field.Event.filter(e) && e.field.isComposite)) {
+                    return (0, rxjs_1.interval)(0);
+                }
+                else {
+                    return (0, rxjs_1.interval)(2000);
+                }
+            }))
+                .subscribe(async () => {
+                if (collection.modified && this._collection === collection) {
+                    await this.save(collection);
+                }
+            });
+        }
+        // raise event
+        this.raiseEvent('collection.changed');
+    }
+    async sync(updatedSys) {
+        // skip if there's no active collection/sys
+        const { collection, collectionSys, state, collectionRepository } = this;
+        if (!collection || !collectionSys) {
+            console.warn('[ContentfulCollectionController/sync] ignoring update before initial load');
+            return;
+        }
+        // or skip if collection version is unchanged
+        else if (collection.id === updatedSys.id && collectionSys.version >= updatedSys.version) {
+            console.debug('[ContentfulCollectionController/sync] ignoring update - current version is fresh');
+            return;
+        }
+        // or ignore if booting up
+        else if (state === 'uninitialized' || state === 'initializing' || state === 'loading') {
+            console.debug('[ContentfulCollectionController/sync] ignoring sync while loading');
+            return;
+        }
+        // or queue if saving
+        else if (this.state === 'saving') {
+            console.debug('[ContentfulCollectionController/sync] queueing collection sync - updated while saving');
+            this._queuedSync = updatedSys;
+            return;
+        }
+        // try to sync
+        try {
+            console.debug('[ContentfulCollectionController/sync] starting sync');
+            // update state
+            this.state = 'loading';
+            // perform sync
+            const result = await collectionRepository.sync({ collection, sys: updatedSys });
+            // update sys
+            this.collectionSys = result.sys;
+            // update collection (if unchanged)
+            if (this.collection !== result.collection) {
+                this.collection = result.collection;
+            }
+            // update summary (if any)
+            if (result.collectionGroup) {
+                this.collectionGroup = result.collectionGroup;
+            }
+            console.debug('[ContentfulCollectionController/sync] sync complete');
+            // clear state
+            this.state = 'ready';
+        }
+        // catch error
+        catch (e) {
+            console.error('[ContentfulCollectionController/sync] sync failed', e);
+            this.state = 'error';
+        }
+    }
+    async load() {
+        // mark as loading (or initialing if loading for first time)
+        this.state = this._state === 'uninitialized'
+            ? 'initializing'
+            : 'loading';
+        // try to fetch collection
+        try {
+            // load collection
+            const { collectionGroup, collection, sys } = await this.collectionRepository.load();
+            // set collection/group
+            this.collectionGroup = collectionGroup;
+            this.collection = collection;
+            this._collectionSys = sys;
+            // update state
+            this.state = 'ready';
+        }
+        // handle load error
+        catch (e) {
+            console.error('[ContentfulCollectionController] failed to load collection', e);
+            // set error state
+            this.state = 'error';
+        }
+    }
+    async createLanguage(target) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(collection) {
+        // ignore if not ready
+        if (this._state !== 'ready') {
+            console.debug(`[ContentfulCollectionController/save] queuing save while in "${this._state}" state`);
+            this._queuedSave = collection;
+            return;
+        }
+        // clear save if queued
+        delete this._queuedSave;
+        // skip if collection isn't modified
+        if (!collection.modified) {
+            console.debug('[ContentfulCollectionController/save] ignore unmodified collection');
+            return;
+        }
+        // try to save collection
+        try {
+            console.debug('[ContentfulCollectionController/save] starting save');
+            // mark as syncing
+            collection.syncing = true;
+            // update state
+            this.state = 'saving';
+            // save page
+            this.collection = await this.collectionRepository.save(collection);
+            // update state
+            this.state = 'ready';
+            console.debug('[ContentfulCollectionController/save] save finished');
+        }
+        // handle error
+        catch (e) {
+            console.error('[ContentfulCollectionController/save] save failed', e);
+            // update state
+            this.state = 'error';
+        }
+        // complete
+        finally {
+            collection.syncing = false;
+        }
+    }
+    async reload() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async processQueues() {
+        // try to save (if queued)
+        const { _queuedSave, _collection } = this;
+        if (_queuedSave) {
+            // nuke if collection differs (keep going afterward)
+            if (_collection !== _queuedSave) {
+                console.debug('[ContentfulCollectionController/processQueues] ignoring queued save for old page');
+                delete this._queuedSave;
+            }
+            // otherwise, try to save
+            else {
+                console.debug('[ContentfulCollectionController/processQueues] restarting queued save');
+                // save
+                this.save(_collection).catch(console.error);
+                // stop processing
+                return;
+            }
+        }
+        // try to sync
+        const { _queuedSync, _collectionSys } = this;
+        if (_queuedSync) {
+            // clear sync
+            delete this._queuedSync;
+            // reload if entity is different
+            if (_queuedSync.id !== (_collectionSys === null || _collectionSys === void 0 ? void 0 : _collectionSys.id)) {
+                console.debug('[ContentfulCollectionController/processQueues] reloading on entity change');
+                this.load().catch(console.error);
+            }
+            // otherwise, try to sync
+            else {
+                console.debug('[ContentfulCollectionController/processQueues] retrying sync');
+                this.sync(_queuedSync).catch(console.error);
+            }
+        }
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(components_1.ICollectionController.Event.create({ type, controller: this }));
+    }
+}
+exports.ContentfulCollectionController = ContentfulCollectionController;

package/dist/collection/controller/ContentfulCollectionControllerContainer.d.ts

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

package/dist/collection/controller/ContentfulCollectionControllerContainer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCollectionControllerContainer = ContentfulCollectionControllerContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_apps_toolkit_1 = require("@contentful/react-apps-toolkit");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const react_1 = require("react");
+const ContentfulCollectionController_1 = require("./ContentfulCollectionController");
+// container
+function ContentfulCollectionControllerContainer({ children }) {
+    // bind context
+    const collectionRepository = (0, components_1.useCollectionRepository)();
+    const sdk = (0, react_apps_toolkit_1.useSDK)();
+    const context = (0, react_1.useMemo)(() => ({
+        controller: new ContentfulCollectionController_1.ContentfulCollectionController({ collectionRepository })
+    }), [collectionRepository]);
+    // list to collection changes
+    (0, react_1.useEffect)(() => {
+        // get controller
+        const { controller } = context;
+        // sync on change
+        sdk.entry.onSysChanged(sys => {
+            controller.sync(sys).catch(console.error);
+        });
+    }, [sdk, context]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(components_1.CollectionControllerContext.Provider, { value: context, children: children }));
+}

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

@@ -1,4 +1,3 @@
-export * from './LocalCollectionController';
-export * from './LocalCollectionControllerContext';
-export * from './LocalCollectionControllerContainer';
-export * from './useLocalCollectionController';
+export * from './ContentfulCollectionController';
+export * from './ContentfulCollectionControllerContainer';
+export * from './useContentfulCollectionController';

package/dist/collection/controller/index.js

@@ -14,7 +14,6 @@ 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("./LocalCollectionController"), exports);
-__exportStar(require("./LocalCollectionControllerContext"), exports);
-__exportStar(require("./LocalCollectionControllerContainer"), exports);
-__exportStar(require("./useLocalCollectionController"), exports);
+__exportStar(require("./ContentfulCollectionController"), exports);
+__exportStar(require("./ContentfulCollectionControllerContainer"), exports);
+__exportStar(require("./useContentfulCollectionController"), exports);

package/dist/collection/controller/useContentfulCollectionController.d.ts

@@ -0,0 +1,2 @@
+import { ContentfulCollectionController } from './ContentfulCollectionController';
+export declare function useContentfulCollectionController(): ContentfulCollectionController;

package/dist/collection/controller/useContentfulCollectionController.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentfulCollectionController = useContentfulCollectionController;
+const components_1 = require("@nascentdigital/funnel-editor/components");
+// hook
+function useContentfulCollectionController() {
+    return (0, components_1.useCollectionController)();
+}

package/dist/{core → collection}/domain/Collection.d.ts

@@ -1,6 +1,7 @@
-import { AssetClient } from '@nascentdigital/funnel-cms';
+import { AssetClient, CollectionClient } from '@nascentdigital/funnel-cms';
+import { ContentfulCollectionData, ContentfulData } from '@nascentdigital/funnel-cms/contentful';
 import { EventBus, Field, FieldModel, Language, Schema } from '@nascentdigital/funnel-core';
-import { Asset, CollectionGroup, ICollection, IPage } from '@nascentdigital/funnel-editor/components';
+import { Asset, CollectionFieldProxy, CollectionGroup, ICollection, IPage } from '@nascentdigital/funnel-editor/components';
 import { Observable } from 'rxjs';
 export declare class Collection implements ICollection {
     readonly template: Schema.Collection;
@@ -27,6 +28,7 @@ export declare class Collection implements ICollection {
     private _initialErrors;
     private _syncing;
     private _savingOn?;
+    readonly references: Readonly<ContentfulData.References>;
     constructor(args: Collection.ConstructorArgs);
     get events$(): Observable<ICollection.Events>;
     get stable$(): Observable<boolean>;
@@ -91,9 +93,16 @@ export declare namespace Collection {
         createdOn: number;
         updatedOn: number;
         publishedOn?: number;
+        references: ContentfulData.References;
     };
     type WithGroup = {
         group: CollectionGroup;
         collection?: Collection;
     };
+    type FromSchemaData = {
+        data: ContentfulCollectionData.ForSchema;
+        references?: Schema.Collection.References;
+    };
+    function fromSchemaData({ data, references }: FromSchemaData): Collection;
+    function toUpdates(collection: Collection | CollectionFieldProxy, savables: ICollection.Savable[]): CollectionClient.Update.Args;
 }

package/dist/{core → collection}/domain/Collection.js

@@ -1,6 +1,18 @@
 "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.Collection = void 0;
+const contentful_1 = require("@nascentdigital/funnel-cms/contentful");
 const funnel_core_1 = require("@nascentdigital/funnel-core");
 const components_1 = require("@nascentdigital/funnel-editor/components");
 const rxjs_1 = require("rxjs");
@@ -41,6 +53,7 @@ class Collection {
         this.createdOn = args.createdOn;
         this._updatedOn = args.updatedOn;
         this.publishedOn = args.publishedOn;
+        this.references = args.references;
         this._state = args.state;
         this._initialErrors = args.errors;
         this._syncing = false;
@@ -309,3 +322,66 @@ class Collection {
     }
 }
 exports.Collection = Collection;
+// extension
+(function (Collection) {
+    function fromSchemaData({ data, references }) {
+        // setup
+        const { snapshot, fields, tags } = data, collectionArgs = __rest(data, ["snapshot", "fields", "tags"]);
+        const { files = {}, collections = {} } = references !== null && references !== void 0 ? references : {};
+        const { fields: fieldsSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        const template = funnel_core_1.Schema.Site.getCollection(data.type);
+        const eventBus = new funnel_core_1.EventBus();
+        // create collection
+        return new Collection(Object.assign(Object.assign({}, collectionArgs), { eventBus,
+            template, tags: components_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags !== null && tags !== void 0 ? tags : []
+            }), fields: Object.entries(template.editableFields).map(([id, schema]) => components_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema,
+                content: fields[id],
+                snapshot: fieldsSnapshot[id]
+            })), files: Object.values(files), collections: Object.values(collections), references: contentful_1.ContentfulData.findReferences(fields) }));
+    }
+    Collection.fromSchemaData = fromSchemaData;
+    function toUpdates(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()
+        };
+    }
+    Collection.toUpdates = toUpdates;
+})(Collection || (exports.Collection = Collection = {}));

package/dist/{core → collection}/domain/index.d.ts

@@ -1,2 +1 @@
 export * from './Collection';
-export * from './Page';

package/dist/{core → collection}/domain/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Collection"), exports);
-__exportStar(require("./Page"), exports);

package/dist/collection/index.d.ts

@@ -1,2 +1,3 @@
 export * from './screens';
 export * from './controller';
+export * from './repository';

package/dist/collection/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./screens"), exports);
 __exportStar(require("./controller"), exports);
+__exportStar(require("./repository"), exports);

package/dist/collection/repository/CollectionRepository.d.ts

@@ -0,0 +1,49 @@
+import { EditorAppSDK, EntrySys, PageAppSDK } from '@contentful/app-sdk';
+import { ContentfulContentClient } from '@nascentdigital/funnel-cms/contentful';
+import { Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, CollectionGroup, ICollection, ICollectionRepository } from '@nascentdigital/funnel-editor/components';
+import { Collection } from '../domain';
+export declare class CollectionRepository implements ICollectionRepository {
+    readonly sdk: EditorAppSDK | PageAppSDK;
+    readonly contentfulClient: ContentfulContentClient;
+    constructor(args: CollectionRepository.ConstructorArgs);
+    getOverview(args: ICollectionRepository.GetOverview.Args): Promise<ICollectionRepository.GetOverview.Result>;
+    getItems(args: ICollectionRepository.GetItems.Args): Promise<ICollectionRepository.GetItems.Result>;
+    get(args: ICollectionRepository.Get.Args): Promise<ICollectionRepository.Get.Result>;
+    create(args: ICollectionRepository.Create.Args): Promise<ICollectionRepository.Create.Result>;
+    createRaw(args: ICollectionRepository.CreateRaw.Args): Promise<ICollectionRepository.CreateRaw.Result>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<ICollectionRepository.CreateLang.Result>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: ICollection | CollectionFieldProxy, savables: ICollection.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+    load(sys?: EntrySys): Promise<CollectionRepository.Load.Result>;
+    save(collection: Collection): Promise<Collection>;
+    sync({ collection, sys }: CollectionRepository.Sync.Args): Promise<CollectionRepository.Sync.Result>;
+    unpublish(collection: ICollection): Promise<void>;
+}
+export declare namespace CollectionRepository {
+    type ConstructorArgs = {
+        sdk: EditorAppSDK | PageAppSDK;
+        contentfulClient: ContentfulContentClient;
+    };
+    namespace Load {
+        type Args = {
+            collectionId?: Schema.Collection.Id;
+        };
+        type Result = {
+            collectionGroup: CollectionGroup;
+            collection: Collection;
+            sys: EntrySys;
+        };
+    }
+    namespace Sync {
+        type Args = {
+            collection: Collection;
+            sys: EntrySys;
+        };
+        type Result = {
+            collectionGroup?: CollectionGroup;
+            collection: Collection;
+            sys: EntrySys;
+        };
+    }
+}