@nascentdigital/funnel-editor 4.4.18

package/dist/core/repository/CollectionRepository.js

@@ -0,0 +1,274 @@
+"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.CollectionRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const CollectionSerializer_1 = require("./CollectionSerializer");
+// class
+class CollectionRepository {
+    constructor(editorApi) {
+        this.editorApi = editorApi;
+    }
+    async load(args) {
+        // try to load collection (skip if there's no collection at all)
+        const { eventBus, template } = args, query = __rest(args, ["eventBus", "template"]);
+        const data = await this.editorApi.getCollectionGroup(Object.assign(Object.assign({}, query), { type: template.type, version: 'draft' }));
+        if (!data) {
+            return undefined;
+        }
+        // deserialize collection (if any)
+        return CollectionSerializer_1.CollectionSerializer.deserializeCollectionGroup(Object.assign(Object.assign({}, args), data));
+    }
+    async create(_a) {
+        var { eventBus } = _a, args = __rest(_a, ["eventBus"]);
+        // resolve collection (get or create)
+        const { template } = args, query = __rest(args, ["template"]);
+        const data = await this.editorApi.createCollection(Object.assign(Object.assign({}, query), { type: template.type, version: template.version }));
+        // return collection
+        return CollectionSerializer_1.CollectionSerializer.deserializeCollectionGroup(Object.assign(Object.assign({ eventBus: eventBus !== null && eventBus !== void 0 ? eventBus : new funnel_core_1.EventBus() }, args), data));
+    }
+    async createLanguage(args) {
+        const { eventBus, template } = args, query = __rest(args, ["eventBus", "template"]);
+        const data = await this.editorApi.createCollection(Object.assign(Object.assign({}, query), { type: template.type }));
+        // return collection
+        return CollectionSerializer_1.CollectionSerializer.deserializeCollectionGroup(Object.assign(Object.assign({}, args), data));
+    }
+    async save(collection) {
+        // get collection update
+        const savables = [];
+        const update = this.serializeCollectionUpdate(collection, savables);
+        console.debug('[CollectionRepository/save] created update', update);
+        // start all updates
+        collection.onSaveStart();
+        savables.forEach(savable => savable.onSaveStart());
+        // update collection
+        const { updatedOn, changeSetId, collection: collectionData } = await this.editorApi.updateCollection(update);
+        // complete all updates
+        savables.forEach(savable => savable.onSaveComplete());
+        collection.onSaveComplete(updatedOn, changeSetId);
+        // return new collection if it was updated
+        if (collectionData) {
+            console.debug('[CollectionRepository/save] received new collection');
+            const { eventBus, template } = collection;
+            return CollectionSerializer_1.CollectionSerializer.deserializeCollection(Object.assign(Object.assign({}, collectionData), { eventBus, template }));
+        }
+        // or simply update the collection updated stamp
+        else {
+            console.debug('[CollectionRepository/save] received no collection update but timestamp is now', updatedOn);
+            // return the same collection
+            return collection;
+        }
+    }
+    async unpublish(collection) {
+        // throw if not valid
+        if (!collection.published) {
+            throw new funnel_core_1.InvalidOperationError('Cannot unpublish collection that is in draft state');
+        }
+        // unpublish collection
+        await this.editorApi.unpublishCollection(collection.id);
+    }
+    serializeCollectionUpdate(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
+        this.serializeFieldsUpdate(updates, fields, ['fields'], savables);
+        // return update data
+        return {
+            id,
+            updatedOn: Date.now(), // FIXME: should come from collection
+            updates
+        };
+    }
+    serializeFieldsUpdate(updates, fields, parentPath, savables) {
+        // handle fields in block
+        fields.forEach(field => {
+            if (field instanceof funnel_core_1.Field) {
+                this.serializeFieldUpdate(updates, field, parentPath, savables);
+            }
+            else if (field instanceof funnel_core_1.ObjectField) {
+                this.serializeObjectFieldUpdate(updates, field, parentPath, savables);
+            }
+            else {
+                this.serializeListUpdate(updates, field, parentPath, savables);
+            }
+        });
+        // return changes (for chaining)
+        return updates;
+    }
+    serializeObjectFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // create object if it's new
+        if (field.isNew) {
+            updates.push({
+                type: 'object.insert',
+                path: [...parentPath, field.id],
+                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
+            });
+            // track save
+            savables.push(field);
+        }
+        // or process subfields
+        else if (field.exists) {
+            // save fields
+            this.serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
+            // track save
+            savables.push(field);
+        }
+        // or process opted out field
+        else if (field.optedOut) {
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: null
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    serializeFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // track change if modified (ignore if field is sandboxed)
+        if (field.modified && !field.sandboxed) {
+            // set field
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    serializeListUpdate(updates, list, parentPath, savables) {
+        var _a, _b;
+        // create list if it's new
+        if (list.isNew) {
+            // add new list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: funnel_core_1.Schema.Field.Data.newValue('list')
+            });
+            // track save
+            savables.push(list);
+        }
+        // or drop list on opt-out
+        else if (list.optedOut) {
+            // drop list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: null
+            });
+            // track save
+            savables.push(list);
+        }
+        // or skip if not modified
+        else if (list.modified) {
+            // track insert/update
+            const path = [...parentPath, list.id];
+            const { value: currentValue, items: fields, initialValue } = list;
+            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
+            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
+            const fieldIds = [];
+            currentItems.forEach((item, index) => {
+                // track id
+                const { id, field } = fields[index];
+                fieldIds.push(item.id);
+                // track insert
+                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
+                if (originalIndex < 0) {
+                    updates.push({
+                        type: 'array.insert',
+                        path,
+                        index,
+                        id,
+                        value: item
+                    });
+                }
+                // track update
+                else if (field.modified) {
+                    // object field updates should be recursed and indexed
+                    if (field instanceof funnel_core_1.ObjectField) {
+                        this.serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
+                    }
+                    // basic field updates can be done inline
+                    else {
+                        updates.push({
+                            type: 'value',
+                            path: [...path, id],
+                            value: item
+                        });
+                    }
+                }
+            });
+            // track delete/reorder
+            let reordered = false;
+            let deleted = 0;
+            initialItems.forEach(({ id }, index) => {
+                // add to deleted list if the original doesn't exist anymore
+                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
+                if (fieldIndex < 0) {
+                    updates.push({
+                        type: 'array.delete',
+                        path,
+                        id
+                    });
+                    // track deletion
+                    ++deleted;
+                }
+                // or mark reorder if index isn't the same
+                else if (fieldIndex !== index) {
+                    reordered = true;
+                }
+            });
+            // track reorder
+            if (reordered) {
+                updates.push({
+                    type: 'array.reorder',
+                    path,
+                    ids: fieldIds
+                });
+            }
+            // track save
+            savables.push(list);
+        }
+    }
+}
+exports.CollectionRepository = CollectionRepository;

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

@@ -0,0 +1,14 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Collection, CollectionGroup } from '../domain';
+export declare namespace CollectionSerializer {
+    type DeserializeCollectionGroupArgs = Schema.Collection.Data.AsGroup & {
+        template: Schema.Collection;
+        eventBus: EventBus;
+    };
+    function deserializeCollectionGroup({ template, eventBus, group: groupData, collection: collectionData }: DeserializeCollectionGroupArgs): CollectionGroup;
+    type DeserializeCollectionArgs = Schema.Collection.Data & {
+        template: Schema.Collection;
+        eventBus: EventBus;
+    };
+    function deserializeCollection({ eventBus, template, tags, fields, files, collections, pageIds, snapshot, ...data }: DeserializeCollectionArgs): Collection;
+}

package/dist/core/repository/CollectionSerializer.js

@@ -0,0 +1,57 @@
+"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 domain_1 = require("../domain");
+const FieldSerializer_1 = require("./FieldSerializer");
+const TagSerializer_1 = require("./TagSerializer");
+// namespace
+var CollectionSerializer;
+(function (CollectionSerializer) {
+    function deserializeCollectionGroup({ template, eventBus, group: groupData, collection: collectionData }) {
+        // deserialize collection (if any)
+        const collection = collectionData && deserializeCollection(Object.assign(Object.assign({}, collectionData), { template, eventBus }));
+        // deserialize summary
+        const { groupId, brand, name, instances } = groupData;
+        return new domain_1.CollectionGroup({
+            template,
+            groupId,
+            brand,
+            name,
+            collections: instances,
+            collection
+        });
+    }
+    CollectionSerializer.deserializeCollectionGroup = deserializeCollectionGroup;
+    function deserializeCollection(_a) {
+        var { eventBus, template, tags, fields = {}, files = [], collections = [], pageIds = [], snapshot } = _a, data = __rest(_a, ["eventBus", "template", "tags", "fields", "files", "collections", "pageIds", "snapshot"]);
+        // determine latest snapshot (if any)
+        const { fields: snapshotFields = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        // create new collection using shared bus
+        return new domain_1.Collection(Object.assign(Object.assign({ eventBus,
+            template, tags: TagSerializer_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags
+            }) }, data), { fields: Object.entries(template.editableFields).map(([id, schema]) => FieldSerializer_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema,
+                content: fields[id],
+                snapshot: snapshotFields[id]
+            })), files,
+            collections,
+            pageIds,
+            snapshot }));
+    }
+    CollectionSerializer.deserializeCollection = deserializeCollection;
+})(CollectionSerializer || (exports.CollectionSerializer = CollectionSerializer = {}));

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

@@ -0,0 +1,9 @@
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Collection } from '../domain';
+export type CollectionTarget = Pick<Collection.ConstructorArgs, 'template' | 'brand' | 'groupId' | 'language'>;
+export declare namespace CollectionTarget {
+    type WithEventBus = CollectionTarget & {
+        eventBus: EventBus;
+    };
+    function equals(lhs: CollectionTarget | undefined, rhs: CollectionTarget | undefined): boolean;
+}

package/dist/core/repository/CollectionTarget.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionTarget = void 0;
+// extension
+var CollectionTarget;
+(function (CollectionTarget) {
+    // helpers
+    function equals(lhs, rhs) {
+        // skip if identical
+        if (lhs === rhs) {
+            return true;
+        }
+        // or skip if one of them is undefined
+        else if (!lhs || !rhs) {
+            return false;
+        }
+        // compare items
+        return lhs.template === rhs.template
+            && lhs.brand === rhs.brand
+            && lhs.groupId === rhs.groupId
+            && lhs.language === rhs.language;
+    }
+    CollectionTarget.equals = equals;
+})(CollectionTarget || (exports.CollectionTarget = CollectionTarget = {}));

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

@@ -0,0 +1,11 @@
+import { EventBus, FieldModel, Schema } from '@nascentdigital/funnel-core';
+export declare namespace FieldSerializer {
+    type DeserializeFieldArgs = {
+        id: string;
+        eventBus: EventBus;
+        schema: Schema.Field.Type;
+        content: any | undefined;
+        snapshot: any | undefined;
+    };
+    function deserializeField({ id, eventBus, schema, content, snapshot }: DeserializeFieldArgs): FieldModel;
+}

package/dist/core/repository/FieldSerializer.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSerializer = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// namespace
+var FieldSerializer;
+(function (FieldSerializer) {
+    function deserializeField({ id, eventBus, schema, content, snapshot }) {
+        var _a;
+        // deserialize based on type
+        switch (schema.type) {
+            // unpack a simple field
+            case 'text':
+            case 'richtext':
+            case 'enum':
+            case 'boolean':
+            case 'date':
+            case 'timestamp':
+            case 'link':
+            case 'form':
+            case 'embedded.video':
+            case 'asset':
+            case 'dynamic.pages':
+            case 'collection':
+            case 'page':
+                return new funnel_core_1.Field({
+                    eventBus,
+                    schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            // handle lists (may nest more complex types)
+            case 'list': {
+                // fail if we don't have any types in the list
+                const itemSchemas = Object.entries(schema.itemTypes);
+                if (itemSchemas.length === 0) {
+                    throw new funnel_core_1.IllegalStateError(`ListField "${schema.name}" is defined without any itemTypes entries`);
+                }
+                // return list
+                return new funnel_core_1.FieldList({
+                    eventBus,
+                    schema: schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            }
+            // or unpack a complex type (aka an object)
+            case 'object':
+                return new funnel_core_1.ObjectField({
+                    eventBus,
+                    schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            default:
+                throw new funnel_core_1.NotImplementedError(`Unsupported content type for block field "${id}": ${(_a = schema.type) !== null && _a !== void 0 ? _a : 'Unknown'}`);
+        }
+    }
+    FieldSerializer.deserializeField = deserializeField;
+})(FieldSerializer || (exports.FieldSerializer = FieldSerializer = {}));

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

@@ -0,0 +1,32 @@
+import { PageClient, Pagination } from '@nascentdigital/funnel-cms';
+import { EventBus, PartialBy } from '@nascentdigital/funnel-core';
+import { EditorApiClient } from '../client';
+import { Page } from '../domain';
+import { PageTarget } from './PageTarget';
+export declare class PageRepository {
+    readonly editorApi: EditorApiClient;
+    constructor(editorApi: EditorApiClient);
+    search(args: PageRepository.SearchArgs): Promise<Pagination.Paginated<Page.Ref>>;
+    load(args: PageRepository.LoadArgs): Promise<Page.WithSummary | undefined>;
+    create({ eventBus, name, ...args }: PageRepository.CreateNewArgs): Promise<Page.WithSummary>;
+    createLanguage(args: PageRepository.CreateLanguageArgs): Promise<Page.WithSummary>;
+    save(page: Page): Promise<Page>;
+    unpublish(page: Page): Promise<void>;
+    private serializePageUpdate;
+    private serializeSectionUpdate;
+    private serializeBlockUpdate;
+    private serializeFieldsUpdate;
+    private serializeObjectFieldUpdate;
+    private serializeFieldUpdate;
+    private serializeListUpdate;
+}
+export declare namespace PageRepository {
+    type SearchArgs = Omit<PageClient.Search.Args, 'version' | 'brand' | 'type' | 'region'> & Pick<Page.ConstructorArgs, 'template' | 'region'>;
+    type LoadArgs = PageTarget.WithEventBus;
+    type CreateNewArgs = PartialBy<Omit<PageClient.Create.NewArgs, 'brand' | 'type' | 'route'>, 'name'> & Pick<Page.ConstructorArgs, 'template'> & {
+        eventBus?: EventBus;
+    };
+    type CreateLanguageArgs = Omit<PageClient.Create.NewLanguageArgs, 'brand' | 'route'> & Pick<Page.ConstructorArgs, 'template'> & {
+        eventBus: EventBus;
+    };
+}