@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.1

package/dist/core/repository/CollectionSerializer.js

@@ -0,0 +1,41 @@
+"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.CollectionSerializer = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const domain_1 = require("../domain");
+// namespace
+var CollectionSerializer;
+(function (CollectionSerializer) {
+    function deserializeCollection({ flattenedCollection, eventBus }) {
+        // destructure
+        const { data } = flattenedCollection;
+        const { snapshot, fields } = data, dataRest = __rest(data
+        // determine latest snapshot (if any)
+        , ["snapshot", "fields"]);
+        // determine latest snapshot (if any)
+        const { fields: fieldsSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        // get collection schema
+        const template = funnel_core_1.Schema.Site.getCollection(data.type);
+        // create collection
+        return new domain_1.Collection(Object.assign(Object.assign({}, dataRest), { template, fields: Object.entries(template.editableFields).map(([id, schema]) => components_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema,
+                content: fields[id],
+                snapshot: fieldsSnapshot[id]
+            })), eventBus }));
+    }
+    CollectionSerializer.deserializeCollection = deserializeCollection;
+})(CollectionSerializer || (exports.CollectionSerializer = CollectionSerializer = {}));

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

@@ -0,0 +1,27 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { CollectionClient } from '@nascentdigital/funnel-cms';
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, ICollection, ICollectionRepository } from '@nascentdigital/funnel-editor/components';
+import { Collection } from '../domain';
+export declare class LocalCollectionRepository implements ICollectionRepository {
+    readonly sdk: EditorAppSDK;
+    constructor(sdk: EditorAppSDK);
+    load({ eventBus }: LocalCollectionRepository.LoadArgs): Promise<Collection | undefined>;
+    create(args: ICollectionRepository.Create.Args): Promise<ICollection.WithGroup>;
+    createRaw(args: ICollectionRepository.Create.Args): Promise<Schema.Collection.Data.AsGroup>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<ICollection.WithGroup>;
+    save(collection: Collection): Promise<Collection>;
+    unpublish(collection: ICollection): Promise<void>;
+    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>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: Collection | CollectionFieldProxy, savables: ICollectionRepository.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+    private onSave;
+}
+export declare namespace LocalCollectionRepository {
+    type LoadArgs = {
+        eventBus: EventBus;
+    };
+    function currentCollectionGroup(sdk: EditorAppSDK): CollectionClient.GetGroup.Result;
+}

package/dist/core/repository/LocalCollectionRepository.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCollectionRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const contentful_1 = require("../contentful");
+const CollectionSerializer_1 = require("./CollectionSerializer");
+// class
+class LocalCollectionRepository {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async load({ eventBus }) {
+        var _a;
+        // fetch current collection
+        const { collection: flattenedCollection } = (_a = LocalCollectionRepository.currentCollectionGroup(this.sdk)) !== null && _a !== void 0 ? _a : {};
+        if (!flattenedCollection) {
+            return undefined;
+        }
+        // deserialize collection
+        return CollectionSerializer_1.CollectionSerializer.deserializeCollection({
+            eventBus,
+            flattenedCollection
+        });
+    }
+    async create(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createRaw(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createLanguage(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(collection) {
+        // serialize to collection data
+        const collectionData = contentful_1.ContentfulCollection.serialize(this.sdk.entry);
+        // serialize collection updates
+        const savables = [];
+        const { updates } = this.serializeUpdate(collection, savables);
+        // start all updates
+        collection.onSaveStart();
+        savables.forEach(savable => savable.onSaveStart());
+        // create model and apply updates
+        const collectionModel = new funnel_core_1.Schema.CollectionModel(collectionData);
+        collectionModel.update(updates);
+        // deserialize and apply changes
+        const updatedContentfulCollection = contentful_1.ContentfulCollection.deserialize(collectionData);
+        const updatedOn = await this.onSave(updatedContentfulCollection);
+        // complete updates
+        savables.forEach(savable => savable.onSaveComplete());
+        collection.onSaveComplete(updatedOn);
+        // return collection
+        return collection;
+    }
+    async unpublish(collection) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getOverview(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getItems(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async get(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    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 onSave(contentfulCollection) {
+        // TODO: need to improve saving to entry, need to save only needed fields
+        // entry
+        const entry = this.sdk.entry;
+        // update fields
+        await Promise.all([
+            entry.fields.name.setValue(contentfulCollection.name),
+            entry.fields.fields.setValue(contentfulCollection.fields),
+            entry.fields.state.setValue(contentfulCollection.state),
+            entry.fields.errors.setValue(contentfulCollection.errors)
+        ]);
+        // update references
+        const links = contentful_1.ContentfulCollection.deserializeLinks(contentfulCollection);
+        await entry.fields.references.setValue(links);
+        // manually trigger save
+        await entry.save();
+        // return updated on
+        return new Date(entry.getSys().updatedAt).getTime();
+    }
+}
+exports.LocalCollectionRepository = LocalCollectionRepository;
+// extension
+(function (LocalCollectionRepository) {
+    function currentCollectionGroup(sdk) {
+        return {
+            group: {},
+            collection: {
+                data: contentful_1.ContentfulCollection.serialize(sdk.entry),
+                files: {},
+                collections: {}
+            }
+        };
+    }
+    LocalCollectionRepository.currentCollectionGroup = currentCollectionGroup;
+})(LocalCollectionRepository || (exports.LocalCollectionRepository = LocalCollectionRepository = {}));

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

@@ -0,0 +1,16 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Page } from '../domain';
+export declare class LocalPageRepository {
+    readonly sdk: EditorAppSDK;
+    constructor(sdk: EditorAppSDK);
+    load({ eventBus }: LocalPageRepository.LoadArgs): Promise<Page>;
+    save(page: Page): Promise<Page>;
+    private serializePageUpdates;
+    private onSave;
+}
+export declare namespace LocalPageRepository {
+    type LoadArgs = {
+        eventBus: EventBus;
+    };
+}

package/dist/core/repository/LocalPageRepository.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPageRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const contentful_1 = require("../contentful");
+const PageSerializer_1 = require("./PageSerializer");
+// class
+class LocalPageRepository {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async load({ eventBus }) {
+        // entry to page data
+        const data = contentful_1.ContentfulPage.serialize(this.sdk.entry);
+        // page data to domain
+        return PageSerializer_1.PageSerializer.deserializePage({ eventBus, data });
+    }
+    async save(page) {
+        // serialize to page data
+        const pageData = contentful_1.ContentfulPage.serialize(this.sdk.entry);
+        // serialize page updates
+        const savables = [];
+        const updates = this.serializePageUpdates(page, savables);
+        // start all updates
+        page.onSaveStart();
+        savables.forEach(savable => savable.onSaveStart());
+        // create model and apply updates
+        const pageModel = new funnel_core_1.Schema.PageModel(pageData);
+        pageModel.update(updates);
+        pageModel.sync();
+        // deserialize and apply changes
+        const updatedContentfulPage = contentful_1.ContentfulPage.deserialize(pageData);
+        const updatedOn = await this.onSave(updatedContentfulPage);
+        // complete updates
+        savables.forEach(savable => savable.onSaveComplete());
+        page.onSaveComplete(updatedOn);
+        // return page
+        return page;
+    }
+    serializePageUpdates(page, savables) {
+        var _a, _b;
+        // root page updates
+        const rootPageUpdates = [];
+        // name
+        if (page.initialName !== page.name) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'name',
+                value: page.name
+            });
+        }
+        // tags
+        if (page.initialTags.symmetricDifference(page.tags).size > 0) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'tags',
+                value: Array.from(page.tags).map(tag => tag.data)
+            });
+        }
+        // slug + url
+        if (page.initialSlug !== page.slug) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'slug',
+                value: (_a = page.slug) !== null && _a !== void 0 ? _a : null
+            });
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'url',
+                value: page.url
+            });
+        }
+        // preview
+        const previewBlock = page.getPreviewBlock();
+        if (previewBlock && previewBlock.modified) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'preview',
+                value: previewBlock.value
+            });
+        }
+        // errors
+        if (page.initialErrors !== !page.valid) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'errors',
+                value: !page.valid
+            });
+        }
+        // publication
+        if (page.initialPublication !== page.publication) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'publication',
+                value: (_b = page.publication) !== null && _b !== void 0 ? _b : null
+            });
+        }
+        // discover updates
+        const discoverUpdates = page.discover.reduce((updates, block) => {
+            // try to update block
+            components_1.SerializePageUpdate.serializeBlockUpdate(updates, block, 'discover', savables);
+            // keep reducing
+            return updates;
+        }, []);
+        // content updates
+        const contentUpdates = page.content.reduce((updates, item) => {
+            // handle block
+            if (item instanceof components_1.Block) {
+                components_1.SerializePageUpdate.serializeBlockUpdate(updates, item, 'content', savables);
+            }
+            // or section
+            else {
+                components_1.SerializePageUpdate.serializeSectionUpdate(updates, item, 'content', savables);
+            }
+            // keep reducing
+            return updates;
+        }, []);
+        // delete block updates
+        const deletedBlockUpdates = page.deleteBlocks.map(block => ({
+            type: 'block.delete',
+            path: [block.area, block.key]
+        }));
+        // return updates
+        return [
+            ...rootPageUpdates,
+            ...discoverUpdates,
+            ...contentUpdates,
+            ...deletedBlockUpdates
+        ];
+    }
+    async onSave(contentfulPage) {
+        // TODO: need to improve saving to entry, need to save only needed fields
+        // local entry
+        const entry = this.sdk.entry;
+        // save fields
+        await Promise.all([
+            entry.fields.url.setValue(contentfulPage.url),
+            entry.fields.state.setValue(contentfulPage.state),
+            entry.fields.errors.setValue(contentfulPage.errors),
+            entry.fields.preview.setValue(contentfulPage.preview),
+            entry.fields.content.setValue(contentfulPage.content),
+        ]);
+        // update references
+        const links = contentful_1.ContentfulPage.deserializeLinks(contentfulPage);
+        await entry.fields.references.setValue(links);
+        // manually trigger save
+        await entry.save();
+        // grab latest updated time
+        return new Date(entry.getSys().updatedAt).getTime();
+    }
+}
+exports.LocalPageRepository = LocalPageRepository;

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

@@ -2,8 +2,8 @@ import { EventBus, Schema } from '@nascentdigital/funnel-core';
 import { Page } from '../domain';
 export declare namespace PageSerializer {
     type DeserializePageArgs = {
-        flattenedPage: Schema.Page.FlattenedData;
+        data: Schema.Page.Data;
         eventBus: EventBus;
     };
-    function deserializePage({ flattenedPage, eventBus }: DeserializePageArgs): Page;
+    function deserializePage({ data, eventBus }: DeserializePageArgs): Page;
 }

package/dist/core/repository/PageSerializer.js

@@ -18,27 +18,30 @@ const domain_1 = require("../domain");
 // namespace
 var PageSerializer;
 (function (PageSerializer) {
-    function deserializePage({ flattenedPage, eventBus }) {
+    function deserializePage({ data, eventBus }) {
         // destructure
-        const { data } = flattenedPage;
-        const { snapshot, content } = data, dataRest = __rest(data
+        const { snapshot, discover, content, tags } = data, dataRest = __rest(data
         // determine latest snapshot (if any)
-        , ["snapshot", "content"]);
+        , ["snapshot", "discover", "content", "tags"]);
         // determine latest snapshot (if any)
-        const { content: contentSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
-        // create new page using shared bus
-        const pageSchemas = funnel_core_1.Schema.Site.current().regions[data.region];
-        const template = pageSchemas[data.type];
-        // create new page
-        const page = new domain_1.Page(Object.assign(Object.assign({}, dataRest), { template, content: Object.entries(template.content).map(([key, schema]) => components_1.PageSerializer.deserializeContent({
+        const { discover: discoverSnapshot = {}, content: contentSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        // get page schema
+        const template = funnel_core_1.Schema.Site.getPage(data.type, data.region);
+        // create page
+        return new domain_1.Page(Object.assign(Object.assign({}, dataRest), { template, tags: components_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags
+            }), discover: [
+                components_1.PageSerializer.deserializeBlock({ schema: funnel_core_1.Schema.Seo, eventBus, key: 'seo', content: discover['seo'], snapshot: discoverSnapshot['seo'] })
+            ], content: Object.entries(template.content).map(([key, schema]) => components_1.PageSerializer.deserializeContent({
                 key,
                 schema: schema.unwrap(),
                 eventBus,
                 content: content[key],
                 snapshot: contentSnapshot[key],
-            })), eventBus }));
-        // return
-        return page;
+            })), eventBus, 
+            // references get hydrated from remote page repository
+            files: [], pages: [], collections: [] }));
     }
     PageSerializer.deserializePage = deserializePage;
 })(PageSerializer || (exports.PageSerializer = PageSerializer = {}));

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

@@ -0,0 +1,19 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, ICollection, ICollectionRepository } from '@nascentdigital/funnel-editor/components';
+import { Collection } from '../domain';
+export declare class RemoteCollectionRepository implements ICollectionRepository {
+    readonly sdk: EditorAppSDK;
+    constructor(sdk: EditorAppSDK);
+    create(args: ICollectionRepository.Create.Args): Promise<ICollectionRepository.Create.Result>;
+    createRaw(args: ICollectionRepository.CreateRaw.Args): Promise<ICollectionRepository.CreateRaw.Result>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<ICollection.WithGroup>;
+    save(collection: ICollection): Promise<ICollection>;
+    unpublish(collection: ICollection): Promise<void>;
+    getOverview(args: ICollectionRepository.GetOverview.Args): Promise<ICollectionRepository.GetOverview.Result>;
+    getItems({ type, tags, language }: ICollectionRepository.GetItems.Args): Promise<ICollectionRepository.GetItems.Result>;
+    get({ id }: ICollectionRepository.Get.Args): Promise<ICollectionRepository.Get.Result>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: Collection | CollectionFieldProxy, savables: ICollectionRepository.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+    getReferences(collectionId: Schema.Collection.Id): Promise<ICollection.References>;
+}