@nascentdigital/funnel-cms 5.0.2 → 5.0.3

package/dist/contentful/ContentfulContentClient.d.ts

@@ -34,7 +34,8 @@ export declare class ContentfulContentClient implements ContentClient, IContentf
     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>>;
+    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

@@ -110,18 +110,22 @@ class ContentfulContentClient {
     }
     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 +133,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.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,38 +90,31 @@ 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
         };
     }
@@ -113,7 +125,7 @@ class ContentfulPageClient {
             : 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 } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, includeLinks: true, version: args.version, pagination: { page: 1, pageSize: 1 } }, getPageQueryParams(queryArgs)));
         // skip if no entries
         if (entries.length === 0) {
             return undefined;
@@ -121,8 +133,204 @@ class ContentfulPageClient {
         // use first entry and deserialize
         return Object.assign({ data: models_1.ContentfulPageData.deserialize(entries[0]) }, 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();

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 = {
@@ -41,12 +43,19 @@ export declare namespace IContentfulContentClient {
         };
     }
     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/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,7 @@ export declare namespace ContentfulPageData {
         readonly asset: "files";
     };
     type ReferencesSpec = typeof referencesSpec;
-    type ForSchema = Schema.Page.Data & Pick<ContentfulData, 'references'>;
+    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/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 });
             }
         }
@@ -239,13 +239,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 +291,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 +346,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 +401,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nascentdigital/funnel-cms",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "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": "0d1cc7d78504e8819998d928ffb342d622f75690"
 }