@nascentdigital/funnel-cms 5.0.2 → 6.0.0

package/dist/api/PageClient.d.ts

@@ -169,7 +169,7 @@ export declare namespace PageClient {
         type Result = Schema.Page.Data.AsGroup;
     }
     namespace Get {
-        type Args = (Query.ById | Query.ByDetails) & Query.Select;
+        type Args = Query.ById & Query.Select;
         type Result = Schema.Page.FlattenedData | undefined;
     }
     namespace Create {

package/dist/contentful/ContentfulCollectionClient.d.ts

@@ -6,7 +6,7 @@ export declare class ContentfulCollectionClient implements CollectionClient {
     readonly cms: IContentfulContentClient;
     constructor(cms: IContentfulContentClient);
     getOverview(args: CollectionClient.GetOverview.Args): Promise<CollectionClient.GetOverview.Result>;
-    getItems(args: CollectionClient.GetItems.Args): Promise<CollectionClient.GetItems.Result>;
+    getItems({ language, ...args }: CollectionClient.GetItems.Args): Promise<CollectionClient.GetItems.Result>;
     find(args: CollectionClient.Find.Args): Promise<CollectionClient.Find.Result>;
     getGroup(args: CollectionClient.GetGroup.Args): Promise<ContentfulCollectionClient.GetGroup.Result>;
     get(args: CollectionClient.Get.Args): Promise<ContentfulCollectionClient.Get.Result>;

package/dist/contentful/ContentfulCollectionClient.js

@@ -1,4 +1,15 @@
 "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.ContentfulCollectionClient = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
@@ -9,10 +20,68 @@ class ContentfulCollectionClient {
         this.cms = cms;
     }
     async getOverview(args) {
-        throw new funnel_core_1.NotImplementedError();
+        // fetch all collections
+        const { cms } = this;
+        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulCollectionData.contentType, version: args.version, select: getCollectionSelect(funnel_core_1.Schema.Collection.Data.AsRef.props) }, getCollectionQueryParams(args)));
+        // convert entries to collection data
+        const collectionsData = entries.map(entry => models_1.ContentfulCollectionData.deserialize(entry, funnel_core_1.Schema.Collection.Data.AsRef.props));
+        // group by type
+        const collectionsByType = new Map();
+        for (const data of collectionsData) {
+            // get group
+            let group = collectionsByType.get(data.type);
+            if (!group) {
+                collectionsByType.set(data.type, group = []);
+            }
+            // push to group
+            group.push(data);
+        }
+        // return in overview format
+        return funnel_core_1.Schema.Site.current().collections.map(({ type }) => {
+            var _a, _b;
+            return ({
+                type,
+                total: (_b = (_a = collectionsByType.get(type)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0
+            });
+        });
     }
-    async getItems(args) {
-        throw new funnel_core_1.NotImplementedError();
+    async getItems(_a) {
+        var { language } = _a, args = __rest(_a, ["language"]);
+        // fetch all collections
+        const { cms } = this;
+        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulCollectionData.contentType, version: args.version, select: getCollectionSelect(funnel_core_1.Schema.Collection.Data.AsRef.props) }, getCollectionQueryParams(args)));
+        // convert entries to collection data
+        const collectionsData = entries.map(entry => models_1.ContentfulCollectionData.deserialize(entry, funnel_core_1.Schema.Collection.Data.AsRef.props));
+        // group by group id
+        const collectionsByGroupId = new Map();
+        for (const data of collectionsData) {
+            // get group
+            let group = collectionsByGroupId.get(data.groupId);
+            if (!group) {
+                collectionsByGroupId.set(data.groupId, group = []);
+            }
+            // push to group
+            group.push(data);
+        }
+        // return in correct format
+        return collectionsByGroupId.entries().map(([groupId, refs]) => {
+            var _a;
+            // find ref with specified language
+            const target = (_a = refs.find(ref => ref.language === language)) !== null && _a !== void 0 ? _a : refs[0];
+            // return item
+            return {
+                id: target.id,
+                groupId: target.groupId,
+                type: args.type,
+                name: target.name,
+                refs: refs.reduce((refs, ref) => {
+                    // map ref
+                    refs[ref.language] = ref;
+                    // keep reducing
+                    return refs;
+                }, {})
+            };
+        }).toArray();
     }
     async find(args) {
         throw new funnel_core_1.NotImplementedError();
@@ -59,10 +128,109 @@ class ContentfulCollectionClient {
             entryId: args.id,
             version: args.version
         });
+        // skip if there's no entry
+        if (!entry) {
+            return undefined;
+        }
+        // or return it
         return Object.assign({ data: models_1.ContentfulCollectionData.deserialize(entry) }, models_1.ContentfulCollectionData.deserializeRefs(references));
     }
     async create(args) {
-        throw new funnel_core_1.NotImplementedError();
+        // create a new language of an existing collection
+        if (funnel_core_1.Schema.Collection.Data.AsNewLanguage.filter(args)) {
+            // fetch all collections in group
+            const groupResult = await this.getGroup({
+                version: 'draft',
+                type: args.type,
+                groupId: args.groupId,
+                language: args.language
+            });
+            // throw if group doesn't exist
+            if (!groupResult) {
+                throw new funnel_core_1.ArgumentError(`Collection group "${args.groupId}" no longer exists`);
+            }
+            // return existing collection if it's there
+            if (groupResult.collection) {
+                return groupResult;
+            }
+            // try to create page
+            try {
+                // create entry
+                const { group } = groupResult;
+                const collectionData = await this.cms.createEntry(models_1.ContentfulCollectionData.contentType, {
+                    type: args.type,
+                    brand: args.brand,
+                    version: args.version,
+                    groupId: args.groupId,
+                    language: args.language,
+                    name: group.name,
+                    references: [],
+                    tags: [],
+                    fields: {},
+                    state: 'draft',
+                    errors: true
+                });
+                // return updated group
+                return {
+                    group: Object.assign(Object.assign({}, group), { instances: [
+                            ...group.instances,
+                            models_1.ContentfulCollectionData.deserialize(collectionData, funnel_core_1.Schema.Collection.Data.AsGroup.Instance.props)
+                        ] }),
+                    collection: {
+                        data: models_1.ContentfulCollectionData.deserialize(collectionData),
+                        files: {},
+                        collections: {},
+                        pages: {}
+                    }
+                };
+            }
+            // or throw
+            catch (e) {
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+        // or create a net-new collection
+        else {
+            // try to create
+            try {
+                // create entry
+                const collectionData = await this.cms.createEntry(models_1.ContentfulCollectionData.contentType, {
+                    type: args.type,
+                    brand: args.brand,
+                    version: args.version,
+                    groupId: funnel_core_1.Value.uuid(),
+                    language: args.language,
+                    name: args.name,
+                    references: [],
+                    tags: [],
+                    fields: {},
+                    state: 'draft',
+                    errors: true
+                });
+                // return updated group
+                return {
+                    group: {
+                        brand: collectionData.brand,
+                        type: collectionData.type,
+                        groupId: collectionData.groupId,
+                        name: collectionData.name,
+                        instances: [
+                            models_1.ContentfulCollectionData.deserialize(collectionData, funnel_core_1.Schema.Collection.Data.AsGroup.Instance.props)
+                        ]
+                    },
+                    collection: {
+                        data: models_1.ContentfulCollectionData.deserialize(collectionData),
+                        files: {},
+                        collections: {},
+                        pages: {}
+                    }
+                };
+            }
+            // or throw
+            catch (e) {
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
     }
     async duplicate(args) {
         throw new funnel_core_1.NotImplementedError();

package/dist/contentful/ContentfulContentClient.d.ts

@@ -33,8 +33,9 @@ export declare class ContentfulContentClient implements ContentClient, IContentf
     set token(token: AuthClient.AccessToken);
     clearToken(): void;
     createEntry<T extends ContentfulData>(contentTypeId: string, entry: ContentfulData.Draft<T>): Promise<T>;
-    getEntry<TEntry extends ContentfulData>({ entryId, includeLinks, version }: IContentfulContentClient.GetEntry.Args<TEntry>): Promise<IContentfulContentClient.GetEntry.Result<TEntry>>;
-    getEntries<TEntry extends ContentfulData>({ limit, version, includeLinks, ...query }: IContentfulContentClient.GetEntries.Args<TEntry>): Promise<IContentfulContentClient.GetEntries.Result<TEntry>>;
+    getEntry<TEntry extends ContentfulData>({ entryId, includeLinks, version, ...query }: IContentfulContentClient.GetEntry.Args<TEntry>): Promise<IContentfulContentClient.GetEntry.Result<TEntry>>;
+    getEntries<TEntry extends ContentfulData>({ pagination, version, includeLinks, ...query }: IContentfulContentClient.GetEntries.Args<TEntry>): Promise<IContentfulContentClient.GetEntries.Result<TEntry>>;
+    uploadAsset(args: IContentfulContentClient.UploadAsset.Args): Promise<IContentfulContentClient.UploadAsset.Result>;
     static forEditor(sdk: KnownAppSDK): Promise<ContentfulContentClient>;
 }
 export declare namespace ContentfulContentClient {

package/dist/contentful/ContentfulContentClient.js

@@ -88,40 +88,43 @@ class ContentfulContentClient {
         // transform + return new entry
         return models_2.ContentfulData.fromCmaData(data, locale);
     }
-    async getEntry({ entryId, includeLinks = false, version = 'draft' }) {
-        var _a, _b;
+    async getEntry(_a) {
+        var _b, _c;
+        var { entryId, includeLinks = false, version = 'draft' } = _a, query = __rest(_a, ["entryId", "includeLinks", "version"]);
         // get entry
         const client = version === 'published' ? this.cda : this.cpa;
         const result = await client.entry.getMany({
-            query: {
-                'sys.id': entryId,
-                include: includeLinks === true
+            query: Object.assign(Object.assign({ 'sys.id': entryId }, query), { include: includeLinks === true
                     ? 10
-                    : includeLinks || undefined
-            }
+                    : includeLinks || undefined })
         });
         const { items: [item], includes } = result;
         console.debug('[ContentfulContentClient/getEntry] fetched', result);
+        // skip
         // bind references
-        const entry = models_2.ContentfulData.fromCdaData(item);
-        const references = (_b = (_a = includes === null || includes === void 0 ? void 0 : includes.Entry) === null || _a === void 0 ? void 0 : _a.map(link => models_2.ContentfulData.fromCdaData(link))) !== null && _b !== void 0 ? _b : [];
+        const entry = item ? models_2.ContentfulData.fromCdaData(item) : undefined;
+        const references = (_c = (_b = includes === null || includes === void 0 ? void 0 : includes.Entry) === null || _b === void 0 ? void 0 : _b.map(link => models_2.ContentfulData.fromCdaData(link))) !== null && _c !== void 0 ? _c : [];
         // return normalized item
         return { entry, references };
     }
     async getEntries(_a) {
         var _b, _c;
-        var { limit = 1000, version = 'draft', includeLinks = false } = _a, query = __rest(_a, ["limit", "version", "includeLinks"]);
+        var { pagination = 'all', version = 'draft', includeLinks = false } = _a, query = __rest(_a, ["pagination", "version", "includeLinks"]);
+        // setup pagination
+        const itemsPerRequest = pagination === 'all' ? 1000 : Math.min(pagination.pageSize, 1000);
+        const page = pagination === 'all' ? 1 : pagination.page;
+        let skip = pagination === 'all' ? 0 : (page - 1) * pagination.pageSize;
+        let totalItemFetched = 0;
+        let hasMorePages = true;
+        let totalItems = undefined;
         // loop until no more pages
         const client = version === 'published' ? this.cda : this.cpa;
-        let skip = 0;
-        let total = 1;
         const entries = [];
         const includes = [];
-        while (skip < total) {
+        do {
             // fetch next page
             const _d = await client.entry.getMany({
-                query: Object.assign(Object.assign({}, query), { limit,
-                    skip, include: includeLinks === true
+                query: Object.assign(Object.assign({}, query), { limit: itemsPerRequest, skip, include: includeLinks === true
                         ? 10
                         : includeLinks || undefined })
             }), { items } = _d, response = __rest(_d, ["items"]);
@@ -129,19 +132,79 @@ class ContentfulContentClient {
             // add items
             items.forEach(item => entries.push(models_2.ContentfulData.fromCdaData(item)));
             includes.push(...((_c = (_b = response.includes) === null || _b === void 0 ? void 0 : _b.Entry) !== null && _c !== void 0 ? _c : []));
-            // update counts
-            total = response.total;
-            skip += limit;
-        }
+            // update paging info
+            totalItemFetched += items.length;
+            totalItems = response.total;
+            skip += items.length;
+            hasMorePages = pagination === 'all'
+                ? skip < totalItems
+                : totalItemFetched < pagination.pageSize && skip < totalItems;
+        } while (hasMorePages);
         console.debug('[ContentfulContentClient/getEntries] fetched entries', { entries, includes });
         // normalize references
         const references = includes.map(link => models_2.ContentfulData.fromCdaData(link));
         // return
         return {
             entries,
-            references
+            references,
+            page,
+            pageCount: pagination === 'all'
+                ? 1
+                : Math.floor(totalItems / pagination.pageSize),
+            totalItemCount: totalItems
         };
     }
+    async uploadAsset(args) {
+        var _a;
+        // upload file
+        const { cma, locale } = this;
+        const uploadResult = await this.cma.upload.create({}, {
+            file: await args.file.arrayBuffer()
+        });
+        // create contentful asset
+        const contentfulAsset = await cma.asset.create({}, {
+            fields: models_2.ContentfulData.toEntryData({
+                title: args.name,
+                description: (_a = args.description) !== null && _a !== void 0 ? _a : '',
+                file: {
+                    contentType: args.file.type,
+                    fileName: args.name,
+                    uploadFrom: {
+                        sys: {
+                            type: 'Link',
+                            linkType: 'Upload',
+                            id: uploadResult.sys.id
+                        }
+                    }
+                }
+            }, locale)
+        });
+        // process contentful asset (creates url etc.) and return
+        const processedAsset = await cma.asset.processForAllLocales({}, contentfulAsset);
+        // create funnel asset then return
+        const entry = await cma.entry.create({ contentTypeId: models_2.ContentfulAssetData.contentType }, {
+            fields: models_2.ContentfulData.toEntryData({
+                name: args.name,
+                description: args.description,
+                brand: args.brand,
+                type: args.type,
+                scope: args.scope,
+                tags: args.tags,
+                url: 'https:' + processedAsset.fields.file[locale].url,
+                size: args.size,
+                metadata: args.metadata,
+                media: {
+                    sys: {
+                        type: 'Link',
+                        linkType: 'Asset',
+                        id: processedAsset.sys.id
+                    }
+                }
+            }, locale)
+        });
+        // return asset
+        return models_2.ContentfulData.fromCmaData(entry, locale);
+    }
     static async forEditor(sdk) {
         var _a;
         // get current site config (throw if we can't)

package/dist/contentful/ContentfulPageClient.d.ts

@@ -21,7 +21,7 @@ export declare class ContentfulPageClient implements PageClient {
     unpublish(args: PageClient.Unpublish.Args): Promise<PageClient.Unpublish.Result>;
     getDependants(args: PageClient.GetDependants.Args): Promise<PageClient.GetDependants.Result>;
     getDependencies(args: PageClient.GetDependencies.Args): Promise<PageClient.GetDependencies.Result>;
-    validateSlug(args: PageClient.ValidateSlug.Args): Promise<PageClient.ValidateSlug.Result>;
+    validateSlug({ brand, type, region, slug, groupId }: PageClient.ValidateSlug.Args): Promise<PageClient.ValidateSlug.Result>;
 }
 export declare namespace ContentfulPageClient {
     type FlattedPageData = Omit<Schema.Page.FlattenedData, 'data'> & {

package/dist/contentful/ContentfulPageClient.js

@@ -1,7 +1,19 @@
 "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.ContentfulPageClient = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
+const errors_1 = require("../errors");
 const models_1 = require("./models");
 // class
 class ContentfulPageClient {
@@ -51,7 +63,7 @@ class ContentfulPageClient {
         };
     }
     async getSummaries(args) {
-        // fetch items (bail if there are no instances
+        // fetch items (bail if there are no instances)
         const { cms } = this;
         const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, version: args.version, select: getPageSelect(funnel_core_1.Schema.Page.Data.AsLink.props) }, getPageQueryParams(args)));
         // return result
@@ -60,8 +72,15 @@ class ContentfulPageClient {
     getPreviews(args) {
         throw new funnel_core_1.NotImplementedError();
     }
-    search(args) {
-        throw new funnel_core_1.NotImplementedError();
+    async search(args) {
+        // fetch items (bail if there are no instances)
+        const { cms } = this;
+        const { entries, page, pageCount, totalItemCount } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, version: args.version, select: getPageSelect(funnel_core_1.Schema.Page.Data.AsLink.props) }, getPageQueryParams(args)));
+        // return entries
+        return {
+            items: entries.map(entry => models_1.ContentfulPageData.deserialize(entry, funnel_core_1.Schema.Page.Data.AsLink.props)),
+            page, pageCount, totalItemCount
+        };
     }
     query(args) {
         throw new funnel_core_1.NotImplementedError();
@@ -71,58 +90,257 @@ class ContentfulPageClient {
     }
     async getGroup(args) {
         // fetch items (bail if there are no instances
+        const { language, region, version } = args, queryArgs = __rest(args, ["language", "region", "version"]);
         const { cms } = this;
-        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, version: args.version, select: getPageSelect(funnel_core_1.Schema.Page.Data.AsGroup.Instance.props) }, getPageQueryParams(args)));
+        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, version, select: getPageSelect(funnel_core_1.Schema.Page.Data.AsGroup.Instance.props) }, getPageQueryParams(queryArgs)));
         // bail if no items
         if (entries.length === 0) {
             console.debug('[ContentfulPageClient/getGroup] no items in group', args);
-            const { brand, groupId: possibleGroupId, type, slug, region } = args;
+            const { brand, groupId: possibleGroupId, type, slug } = queryArgs;
             return {
-                group: { groupId: possibleGroupId !== null && possibleGroupId !== void 0 ? possibleGroupId : funnel_core_1.Schema.Page.GroupId.empty, brand, type, slug, region, instances: [] }
+                group: { groupId: possibleGroupId !== null && possibleGroupId !== void 0 ? possibleGroupId : funnel_core_1.Schema.Page.GroupId.empty, brand, type, slug, instances: [] }
             };
         }
-        console.debug('[ContentfulPageClient/getGroup] processing group items', { args, entries });
+        console.debug('[ContentfulPageClient/getGroup] processing group items', args);
         // collate the group ids into summaries (fetches full page if region/language match exists
         const instances = entries.map(entry => models_1.ContentfulPageData.deserialize(entry, funnel_core_1.Schema.Page.Data.AsGroup.Instance.props));
         // bind page (if it exists)
-        const { language, version } = args;
         const pageInstance = instances
-            .find(instance => instance.language === language);
+            .find(instance => instance.region === region && instance.language === language);
         console.debug('[ContentfulPageClient/getGroup] getting page using this.get...', { id: pageInstance === null || pageInstance === void 0 ? void 0 : pageInstance.id, version });
         const page = pageInstance
             ? await this.get({ id: pageInstance.id, version })
             : undefined;
         // return group (and optional page)
-        const { type, brand, groupId, region, slug } = entries[0];
+        const { type, brand, groupId, slug } = entries[0];
         return {
-            group: {
-                groupId,
-                type,
-                brand,
-                region,
-                slug,
-                instances
-            },
+            group: { groupId, type, brand, slug, instances },
             page
         };
     }
     async get(args) {
-        // create args for query
-        const queryArgs = 'id' in args
-            ? { ids: [args.id], version: args.version }
-            : args;
         // fetch entries (should be one entry)
         const { cms } = this;
-        const { entries, references } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, includeLinks: true, version: args.version, limit: 1 }, getPageQueryParams(queryArgs)));
+        const [{ entries, references }, { entry: entrySnapshot }] = await Promise.all([
+            // query target (could be published/draft)
+            cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, includeLinks: true, version: args.version, pagination: { page: 1, pageSize: 1 }, select: getPageSelect(args.select === 'content'
+                    ? funnel_core_1.Schema.Page.Data.AsContent.props
+                    : funnel_core_1.Schema.Page.Data.Props.all) }, getPageQueryParams({ ids: [args.id] }))),
+            // query published (if pulling draft above)
+            args.version === 'draft'
+                ? cms.getEntry(Object.assign({ content_type: models_1.ContentfulPageData.contentType, entryId: args.id, includeLinks: false, version: 'published', select: getPageSelect(funnel_core_1.Schema.PageSnapshot.props) }, getPageQueryParams({ ids: [args.id] })))
+                : Promise.resolve({ entry: undefined, references: [] })
+        ]);
         // skip if no entries
         if (entries.length === 0) {
             return undefined;
         }
+        // stitch together snapshot with entry (if available
+        const data = models_1.ContentfulPageData.deserialize(entries[0]);
+        const snapshot = entrySnapshot
+            ? models_1.ContentfulPageData.Snapshot.deserialize(entrySnapshot)
+            : undefined;
         // use first entry and deserialize
-        return Object.assign({ data: models_1.ContentfulPageData.deserialize(entries[0]) }, models_1.ContentfulPageData.deserializeRefs(references));
+        return Object.assign({ data: Object.assign(Object.assign({}, data), { snapshotId: snapshot === null || snapshot === void 0 ? void 0 : snapshot.id, snapshot }) }, models_1.ContentfulPageData.deserializeRefs(references));
     }
-    create(args) {
-        throw new funnel_core_1.NotImplementedError();
+    async create(args) {
+        console.debug('[ContentfulPageClient/create] processing create page request', args);
+        // create a new language of an existing page
+        if (funnel_core_1.Schema.Page.Data.AsNewLanguage.filter(args)) {
+            // fetch all pages in group (summaries only)
+            const existingPages = await this.getSummaries({
+                version: 'draft',
+                brand: args.brand,
+                groupId: args.groupId
+            });
+            // throw if there are no pages
+            if (existingPages.length === 0) {
+                throw new funnel_core_1.ArgumentError(`Page group "${args.groupId}" no longer exists in "${args.brand}"`);
+            }
+            // return existing page if it's there
+            let existingPage = existingPages
+                .find(existing => existing.region === args.region && existing.language === args.language);
+            if (existingPage) {
+                console.debug('[ContentfulPageClient/create/lang] returning existing page', existingPage);
+                return this.getGroup(Object.assign(Object.assign({}, existingPage), { version: 'draft' }));
+            }
+            // bind data + update url
+            existingPage = existingPages[0];
+            const draft = funnel_core_1.Schema.PageModel.fromDraft(Object.assign({ type: existingPage.type, slug: existingPage.slug, url: existingPage.url, name: existingPage.name, tags: existingPage.tags }, args));
+            draft.sync();
+            console.debug('[ContentfulPageClient/create/lang] creating from', { draft, existingPages });
+            // create page
+            try {
+                // create page
+                const draftData = draft.data;
+                const references = models_1.ContentfulData.findReferences([draftData.discover, draftData.content]);
+                const pageData = await this.cms.createEntry(models_1.ContentfulPageData.contentType, {
+                    groupId: draftData.groupId,
+                    brand: draftData.brand,
+                    type: draftData.type,
+                    region: draftData.region,
+                    language: draftData.language,
+                    name: draftData.name,
+                    tags: draftData.tags,
+                    slug: draftData.slug,
+                    url: draftData.url,
+                    preview: draftData.preview,
+                    discover: draftData.discover,
+                    content: draftData.content,
+                    state: 'draft',
+                    errors: true,
+                    references
+                });
+                // transform entry to page data
+                const flattenedPage = {
+                    data: pageData,
+                    files: {},
+                    collections: {},
+                    pages: {}
+                };
+                const page = flattenedPage.data;
+                // return new page
+                return {
+                    group: {
+                        groupId: page.groupId,
+                        brand: page.brand,
+                        type: page.type,
+                        slug: page.slug,
+                        instances: [
+                            // map exiting entries
+                            ...existingPages.map(({ id, url, region, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn }) => ({ id, url, region, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn })),
+                            // add new entry
+                            {
+                                id: page.id,
+                                url: page.url,
+                                region: page.region,
+                                language: page.language,
+                                name: page.name,
+                                slug: page.slug,
+                                tags: page.tags,
+                                state: page.state,
+                                errors: page.errors,
+                                createdOn: page.createdOn,
+                                updatedOn: page.updatedOn,
+                                publishedOn: page.publishedOn
+                            }
+                        ]
+                    },
+                    page: flattenedPage
+                };
+            }
+            // or throw
+            catch (e) {
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+        // or create a net-new page
+        else {
+            console.debug('[ContentfulPageClient/create/new] creating fresh');
+            // get page's template
+            const site = funnel_core_1.Schema.Site.current();
+            const schema = site.regions[args.region][args.type];
+            // check slug if dynamic page
+            if (schema.variant === 'dynamic') {
+                // make sure there is a slug for a dynamic page
+                if (args.slug === undefined) {
+                    throw new funnel_core_1.ArgumentError(`A "${args.type}" Page must provide a slug when created`);
+                }
+                // validate slug
+                const validateSlugResult = await this.validateSlug(Object.assign(Object.assign({}, args), { slug: args.slug }));
+                if (validateSlugResult.status !== 'available') {
+                    throw new errors_1.SlugValidationError({ slug: args.slug, reason: validateSlugResult });
+                }
+            }
+            // fetch all pages matching brand/type/region
+            const { group: existingGroup, page: existingPage } = await this.getGroup({
+                version: 'draft',
+                brand: args.brand,
+                type: args.type,
+                region: args.region,
+                language: args.language,
+                slug: args.slug
+            });
+            // return existing page if it's there
+            if (existingPage) {
+                console.debug('[ContentfulPageClient/create/new] returning existing page', existingPage);
+                return { group: existingGroup, page: existingPage };
+            }
+            else if (existingGroup.instances.length > 0) {
+                console.debug('[ContentfulPageClient/create/new] using existing group', existingGroup);
+            }
+            else {
+                console.debug('[ContentfulPageClient/create/new] no existing group found');
+            }
+            // bind data + update url
+            const draft = funnel_core_1.Schema.PageModel.fromDraft(Object.assign(Object.assign({}, args), { groupId: existingGroup.groupId === funnel_core_1.Schema.Page.GroupId.empty
+                    ? funnel_core_1.Value.uuid()
+                    : existingGroup.groupId, url: '' }));
+            draft.sync();
+            // create page
+            try {
+                console.debug('[ContentfulPageClient/create/new] adding new page', draft.data);
+                // create page
+                const draftData = draft.data;
+                const references = models_1.ContentfulData.findReferences([draftData.discover, draftData.content]);
+                const pageData = await this.cms.createEntry(models_1.ContentfulPageData.contentType, {
+                    groupId: draftData.groupId,
+                    brand: draftData.brand,
+                    type: draftData.type,
+                    region: draftData.region,
+                    language: draftData.language,
+                    name: draftData.name,
+                    tags: draftData.tags,
+                    slug: draftData.slug,
+                    url: draftData.url,
+                    preview: draftData.preview,
+                    discover: draftData.discover,
+                    content: draftData.content,
+                    state: 'draft',
+                    errors: true,
+                    references
+                });
+                // transform entry to page data
+                const flattenedPage = {
+                    data: pageData,
+                    files: {},
+                    collections: {},
+                    pages: {}
+                };
+                const page = flattenedPage.data;
+                // return page
+                return {
+                    group: {
+                        groupId: page.groupId,
+                        brand: page.brand,
+                        type: page.type,
+                        slug: page.slug,
+                        instances: [
+                            ...existingGroup.instances,
+                            {
+                                id: page.id,
+                                url: page.url,
+                                region: page.region,
+                                language: page.language,
+                                name: page.name,
+                                slug: page.slug,
+                                tags: page.tags,
+                                state: page.state,
+                                errors: page.errors,
+                                createdOn: page.createdOn,
+                                updatedOn: page.updatedOn,
+                                publishedOn: page.publishedOn
+                            }
+                        ]
+                    },
+                    page: flattenedPage
+                };
+            }
+            // or throw
+            catch (e) {
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
     }
     duplicate(args) {
         throw new funnel_core_1.NotImplementedError();
@@ -145,8 +363,26 @@ class ContentfulPageClient {
     getDependencies(args) {
         throw new funnel_core_1.NotImplementedError();
     }
-    validateSlug(args) {
-        throw new funnel_core_1.NotImplementedError();
+    async validateSlug({ brand, type, region, slug, groupId }) {
+        // fetch items (bail if there are no instances)
+        const { cms } = this;
+        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, version: 'draft', select: getPageSelect(funnel_core_1.Schema.Page.Data.AsLink.props) }, getPageQueryParams({ brand, type, region, slug })));
+        const links = entries.map(entry => models_1.ContentfulPageData.deserialize(entry, funnel_core_1.Schema.Page.Data.AsLink.props));
+        // ignore pages in same group (if group specified)
+        const matchedPages = groupId !== undefined
+            ? links.filter(link => link.groupId !== groupId)
+            : links;
+        // available if no pages matched
+        if (matchedPages.length === 0) {
+            return { status: 'available' };
+        }
+        // otherwise not available
+        else {
+            return {
+                status: 'unavailable',
+                takenBy: links[0]
+            };
+        }
     }
 }
 exports.ContentfulPageClient = ContentfulPageClient;

package/dist/contentful/ContentfulSiteConfigClient.js

@@ -12,7 +12,7 @@ class ContentfulSiteConfigClient {
         // fetch config model
         let { entries: [siteConfig] } = await this.cms.getEntries({
             content_type: models_1.ContentfulSiteConfigData.contentType,
-            limit: 1,
+            pagination: { page: 1, pageSize: 1 },
             'fields.brand': brand
         });
         // or create it if it's not there

package/dist/contentful/IContentfulContentClient.d.ts

@@ -1,6 +1,7 @@
 import { CMAClient } from '@contentful/app-sdk';
 import { PlainClientAPI, QueryOptions } from 'contentful-management';
-import { Environment, User } from '../models';
+import { AssetClient } from '../api';
+import { Environment, Pagination, User } from '../models';
 import type { ContentfulAssetClient } from './ContentfulAssetClient';
 import type { ContentfulAuthClient } from './ContentfulAuthClient';
 import type { ContentfulChangeSetClient } from './ContentfulChangeSetClient';
@@ -8,7 +9,7 @@ import type { ContentfulCollectionClient } from './ContentfulCollectionClient';
 import type { ContentfulPageClient } from './ContentfulPageClient';
 import type { ContentfulSiteConfigClient } from './ContentfulSiteConfigClient';
 import type { ContentfulUserClient } from './ContentfulUserClient';
-import { ContentfulData } from './models';
+import { ContentfulAssetData, ContentfulData } from './models';
 export interface IContentfulContentClient {
     readonly user: User;
     readonly locale: string;
@@ -25,6 +26,7 @@ export interface IContentfulContentClient {
     createEntry<TEntry extends ContentfulData>(contentType: string, entry: ContentfulData.Draft<TEntry>): Promise<TEntry>;
     getEntry<TEntry extends ContentfulData>(args: IContentfulContentClient.GetEntry.Args<TEntry>): Promise<IContentfulContentClient.GetEntry.Result<TEntry>>;
     getEntries<TEntry extends ContentfulData>(args: IContentfulContentClient.GetEntries.Args<TEntry>): Promise<IContentfulContentClient.GetEntries.Result<TEntry>>;
+    uploadAsset(args: IContentfulContentClient.UploadAsset.Args): Promise<IContentfulContentClient.UploadAsset.Result>;
 }
 export declare namespace IContentfulContentClient {
     type EntryQueryOptions = {
@@ -32,21 +34,28 @@ export declare namespace IContentfulContentClient {
         version?: Environment;
     };
     namespace GetEntry {
-        type Args<TEntry extends ContentfulData> = EntryQueryOptions & {
+        type Args<TEntry extends ContentfulData> = Pick<QueryOptions, 'content_type' | 'select'> & EntryQueryOptions & {
             entryId: ContentfulData.EntryId<TEntry>;
         };
         type Result<TEntry extends ContentfulData> = {
-            entry: TEntry;
+            entry: TEntry | undefined;
             references: ContentfulData[];
         };
     }
     namespace GetEntries {
-        type Args<TEntry extends ContentfulData> = Omit<QueryOptions, 'content_type' | 'include'> & EntryQueryOptions & {
+        type Args<TEntry extends ContentfulData> = Omit<QueryOptions, 'content_type' | 'include' | 'limit' | 'skip'> & EntryQueryOptions & {
             content_type: ContentfulData.ContentType<TEntry>;
+            pagination?: Pagination;
         };
-        type Result<TEntry extends ContentfulData> = {
+        type Result<TEntry extends ContentfulData> = Pagination.Counts & {
             entries: TEntry[];
             references: ContentfulData[];
         };
     }
+    namespace UploadAsset {
+        type Args = AssetClient.CreateAsset.Args & {
+            file: Blob;
+        };
+        type Result = ContentfulAssetData;
+    }
 }

package/dist/contentful/models/ContentfulAssetData.d.ts

@@ -1,6 +1,8 @@
 import { Schema } from '@nascentdigital/funnel-core';
 import { ContentfulData } from './ContentfulData';
-export type ContentfulAssetData = ContentfulData<ContentfulAssetData.ContentType, Schema.Asset.Id> & Omit<Schema.AssetField.LinkedValue, 'id'>;
+export type ContentfulAssetData = ContentfulData<ContentfulAssetData.ContentType, Schema.Asset.Id> & Omit<Schema.Asset.Linked['value'], 'id'> & {
+    media: ContentfulData.Link.Asset;
+};
 export declare namespace ContentfulAssetData {
     const contentType: "asset";
     type ContentType = typeof contentType;

package/dist/contentful/models/ContentfulCollectionData.d.ts

@@ -1,10 +1,12 @@
 import { RequiredBy, Schema } from '@nascentdigital/funnel-core';
 import { ContentfulData } from './ContentfulData';
-export type ContentfulCollectionData = ContentfulData<ContentfulCollectionData.ContentType, Schema.Collection.Id> & Omit<Schema.Collection.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'>;
+export type ContentfulCollectionData = ContentfulData<ContentfulCollectionData.ContentType, Schema.Collection.Id> & Omit<Schema.Collection.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'> & {
+    references: ContentfulData.References;
+};
 export declare namespace ContentfulCollectionData {
     const contentType: "collection";
     type ContentType = typeof contentType;
-    type ForSchema = Schema.Collection.Data & Pick<ContentfulData, 'references'>;
+    type ForSchema = Schema.Collection.Data;
     type Potential = RequiredBy<Partial<ContentfulCollectionData>, keyof ContentfulData<ContentfulCollectionData.ContentType, Schema.Collection.Id>>;
     function deserialize(data: Potential, props?: ReadonlyArray<Schema.Collection.Data.Props.All>): ForSchema;
     function deserializeRefs(refs: ContentfulData[]): Schema.Collection.References;

package/dist/contentful/models/ContentfulCollectionData.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentfulCollectionData = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
 const ContentfulAssetData_1 = require("./ContentfulAssetData");
+const ContentfulPageData_1 = require("./ContentfulPageData");
 // extension
 var ContentfulCollectionData;
 (function (ContentfulCollectionData) {
@@ -71,6 +72,7 @@ var ContentfulCollectionData;
         // setup
         const files = {};
         const collections = {};
+        const pages = {};
         // loop over references and serialize
         for (const ref of refs) {
             switch (ref.__type) {
@@ -86,12 +88,18 @@ var ContentfulCollectionData;
                     collections[collectionRef.id] = ContentfulCollectionData.deserialize(collectionRef, funnel_core_1.Schema.Collection.Data.AsLink.props);
                     break;
                 }
+                // page
+                case ContentfulPageData_1.ContentfulPageData.contentType: {
+                    const pageRef = ref;
+                    pages[pageRef.id] = ContentfulPageData_1.ContentfulPageData.deserialize(pageRef, funnel_core_1.Schema.Page.Data.AsLink.props);
+                }
             }
         }
         // return
         return {
             files,
-            collections
+            collections,
+            pages
         };
     }
     ContentfulCollectionData.deserializeRefs = deserializeRefs;

package/dist/contentful/models/ContentfulData.d.ts

@@ -7,13 +7,12 @@ export type ContentfulData<TType extends string = string, TId extends string = s
     id: TId;
     createdOn: number;
     updatedOn: number;
-    references: ContentfulData.References;
 };
 export declare namespace ContentfulData {
     type ContentType<T extends ContentfulData> = T['__type'];
     type EntryId<T extends ContentfulData> = T['id'];
     type References = Array<Link.Entry | Link.Asset>;
-    type Draft<T extends ContentfulData> = Omit<T, keyof ContentfulData>;
+    type Draft<T extends ContentfulData> = Omit<T, keyof ContentfulData | '__root'>;
     type Link<TType extends Link.Type = Link.Type> = {
         sys: {
             type: 'Link';

package/dist/contentful/models/ContentfulPageData.d.ts

@@ -1,6 +1,8 @@
 import { RequiredBy, Schema } from '@nascentdigital/funnel-core';
 import { ContentfulData } from './ContentfulData';
-export type ContentfulPageData = ContentfulData<ContentfulPageData.ContentType, Schema.Page.Id> & Omit<Schema.Page.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'>;
+export type ContentfulPageData = ContentfulData<ContentfulPageData.ContentType, Schema.Page.Id> & Omit<Schema.Page.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'> & {
+    references: ContentfulData.References;
+};
 export declare namespace ContentfulPageData {
     const contentType: "page";
     type ContentType = typeof contentType;
@@ -10,7 +12,11 @@ export declare namespace ContentfulPageData {
         readonly asset: "files";
     };
     type ReferencesSpec = typeof referencesSpec;
-    type ForSchema = Schema.Page.Data & Pick<ContentfulData, 'references'>;
+    type Snapshot = ContentfulData<ContentfulPageData.ContentType, Schema.PageSnapshot.Id> & Omit<Schema.PageSnapshot, 'id' | 'changeSetId'>;
+    namespace Snapshot {
+        function deserialize(snapshot: Snapshot): Schema.PageSnapshot;
+    }
+    type ForSchema = Schema.Page.Data;
     type Potential = RequiredBy<Partial<ContentfulPageData>, keyof ContentfulData<ContentfulPageData.ContentType, Schema.Page.Id>>;
     function deserialize(data: Potential, props?: ReadonlyArray<Schema.Page.Data.Props.All>): ForSchema;
     function deserializeRefs(refs: ContentfulData[]): Schema.Page.References;

package/dist/contentful/models/ContentfulPageData.js

@@ -9,11 +9,21 @@ var ContentfulPageData;
 (function (ContentfulPageData) {
     // constants
     ContentfulPageData.contentType = 'page';
+    // references
     ContentfulPageData.referencesSpec = {
         'page': 'pages',
         'collection': 'collections',
         'asset': 'files'
     };
+    let Snapshot;
+    (function (Snapshot) {
+        function deserialize(snapshot) {
+            var _a, _b;
+            const data = ContentfulPageData.deserialize(snapshot, funnel_core_1.Schema.PageSnapshot.props);
+            return Object.assign(Object.assign({}, data), { changeSetId: ((_b = (_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.__version) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'unknown') });
+        }
+        Snapshot.deserialize = deserialize;
+    })(Snapshot = ContentfulPageData.Snapshot || (ContentfulPageData.Snapshot = {}));
     function deserialize(data, props = funnel_core_1.Schema.Page.Data.Props.all) {
         var _a;
         // create base page

package/dist/models/Pagination.d.ts

@@ -17,4 +17,5 @@ export declare namespace Pagination {
         pageCount: number;
         totalItemCount: number;
     };
+    type Counts = Omit<Paginated<any>, 'items'>;
 }

package/dist/strapi/StrapiPageClient.js

@@ -150,12 +150,12 @@ class StrapiPageClient {
     async getGroup({ brand, groupId, type, slug, region, language, version, select }) {
         // create base result
         const result = {
-            group: { groupId: groupId !== null && groupId !== void 0 ? groupId : funnel_core_1.Schema.Page.GroupId.empty, brand, type, slug, region, instances: [] }
+            group: { groupId: groupId !== null && groupId !== void 0 ? groupId : funnel_core_1.Schema.Page.GroupId.empty, brand, type, slug, instances: [] }
         };
         // fetch baseline page (fail if it doesn't exist)
         const client = this.provider.client;
         const collection = client.collection('pages');
-        const { items: baselineItems = [] } = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.PageData.getStrapiFilter(funnel_core_1.Schema.Page.Data.Props.id) }, getPageQueryParams({ version, brand, groupId, type, slug, region })));
+        const { items: baselineItems = [] } = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.PageData.getStrapiFilter(funnel_core_1.Schema.Page.Data.Props.id) }, getPageQueryParams({ version, brand, groupId, type, slug })));
         const [baselinePage] = baselineItems;
         if (!baselinePage) {
             return result;
@@ -172,7 +172,7 @@ class StrapiPageClient {
             const instance = serialization_1.PageData.deserializeLegacy(item, client.baseURL, funnel_core_1.Schema.Page.Data.AsGroup.Instance.props);
             group.instances.push(instance);
             // set page if language matches
-            if (instance.language === language) {
+            if (instance.region === region && instance.language === language) {
                 result.page = await this.get({ id: instance.id, version, select });
             }
         }
@@ -187,33 +187,16 @@ class StrapiPageClient {
         const resultProps = args.select === 'content'
             ? funnel_core_1.Schema.Page.Data.AsContent.props
             : funnel_core_1.Schema.Page.Data.Props.all;
-        let data;
-        if ('id' in args) {
-            // find entry by document id
-            const { data: rawData } = await collection.findOne(args.id, {
-                fields: serialization_1.PageData.getStrapiFilter(resultProps),
-                status: args.version,
-                populate: serialization_1.PageData.Populate.full
-            });
-            // skip if there's no entry
-            if (!rawData) {
-                console.debug(`[StrapiPageClient/getPage] no "${args.version}" entry found for id ${args.id}`);
-                return undefined;
-            }
-            // or capture it
-            data = rawData;
-        }
-        // or by querying type (including region, and language)
-        else {
-            // lookup entry from collection (might be a miss)
-            const { data: rawData } = await collection.find(Object.assign({ fields: serialization_1.PageData.getStrapiFilter(resultProps), sort: ['updatedAt:desc'], populate: serialization_1.PageData.Populate.full }, getPageQueryParams(args)));
-            // skip if there's no entry
-            if (rawData.length === 0) {
-                console.warn(`[StrapiPageClient/getStaticPage] no "${args.version}" entry found for type ${args.type} in region ${args.region}/${args.language}`);
-                return undefined;
-            }
-            // or capture entry
-            data = rawData[0];
+        // find entry by document id
+        const { data } = await collection.findOne(args.id, {
+            fields: serialization_1.PageData.getStrapiFilter(resultProps),
+            status: args.version,
+            populate: serialization_1.PageData.Populate.full
+        });
+        // skip if there's no entry
+        if (!data) {
+            console.debug(`[StrapiPageClient/getPage] no "${args.version}" entry found for id ${args.id}`);
+            return undefined;
         }
         // convert and return
         return serialization_1.PageData.deserializeFlattened(data, strapiUrl, resultProps);
@@ -239,13 +222,14 @@ class StrapiPageClient {
                 throw new funnel_core_1.ArgumentError(`Page group "${args.groupId}" no longer exists in "${args.brand}"`);
             }
             // return existing page if it's there
-            let existingPage = existingPages.find(existing => existing.language === args.language);
+            let existingPage = existingPages
+                .find(existing => existing.region === args.region && existing.language === args.language);
             if (existingPage) {
                 return this.getGroup(Object.assign(Object.assign({}, existingPage), { version: 'draft' }));
             }
             // bind data + update url
             existingPage = existingPages[0];
-            const draft = funnel_core_1.Schema.PageModel.fromDraft(Object.assign({ type: existingPage.type, slug: existingPage.slug, url: existingPage.url, region: existingPage.region, name: existingPage.name, tags: existingPage.tags }, args));
+            const draft = funnel_core_1.Schema.PageModel.fromDraft(Object.assign({ type: existingPage.type, slug: existingPage.slug, url: existingPage.url, name: existingPage.name, tags: existingPage.tags }, args));
             draft.sync();
             // resolve change set (rebind)
             const { provider } = this;
@@ -290,13 +274,13 @@ class StrapiPageClient {
                         groupId: page.groupId,
                         brand: page.brand,
                         type: page.type,
-                        region: page.region,
                         slug: page.slug,
                         instances: [
-                            ...existingPages.map(({ id, url, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn }) => ({ id, url, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn })),
+                            ...existingPages.map(({ id, url, region, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn }) => ({ id, url, region, language, name, slug, tags, state, errors, createdOn, updatedOn, publishedOn })),
                             {
                                 id: page.id,
                                 url: page.url,
+                                region: page.region,
                                 language: page.language,
                                 name: page.name,
                                 slug: page.slug,
@@ -345,8 +329,8 @@ class StrapiPageClient {
                 brand: args.brand,
                 type: args.type,
                 region: args.region,
-                slug: args.slug,
-                language: args.language
+                language: args.language,
+                slug: args.slug
             });
             // return existing page if it's there
             if (existingPage) {
@@ -400,13 +384,13 @@ class StrapiPageClient {
                         groupId: page.groupId,
                         brand: page.brand,
                         type: page.type,
-                        region: args.region,
                         slug: page.slug,
                         instances: [
                             ...existingGroup.instances,
                             {
                                 id: page.id,
                                 url: page.url,
+                                region: args.region,
                                 language: page.language,
                                 name: page.name,
                                 slug: page.slug,

package/dist/strapi/serialization/CollectionData.js

@@ -181,7 +181,8 @@ var CollectionData;
         // return
         return {
             files,
-            collections
+            collections,
+            pages: {}
         };
     }
     CollectionData.deserializeRefs = deserializeRefs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nascentdigital/funnel-cms",
-  "version": "5.0.2",
+  "version": "6.0.0",
   "repository": {
     "url": "git+https://github.com/nascentdigital/funnel.git",
     "directory": "libs/cms"
@@ -48,5 +48,5 @@
     "ts-jest": "^29",
     "type-fest": "^4"
   },
-  "gitHead": "24d9690cf813052f6561c3ccef11c7cf69ad7f7c"
+  "gitHead": "83e335312f91fb90aae73dfc31b3df1ec1895f76"
 }