@nascentdigital/funnel-cms 4.4.4

package/dist/strapi/StrapiPageClient.js

@@ -0,0 +1,882 @@
+"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.StrapiPageClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const errors_1 = require("../errors");
+const serialization_1 = require("./serialization");
+const Strapi_1 = require("./Strapi");
+// client extension
+class StrapiPageClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async getOverview({ brand, region, version }) {
+        const { static: staticPages, dynamic } = await this.provider.customRequest({
+            command: 'query/pages',
+            params: { brand, region, preview: version === 'draft' ? 'true' : 'false' }
+        });
+        // transform static links
+        return {
+            static: staticPages.map(({ type, refs }) => ({
+                type,
+                refs: Object.entries(refs).reduce((refs, [language, ref]) => {
+                    // map page
+                    refs[language] = serialization_1.PageData.deserializeRef(ref);
+                    // keep reducing
+                    return refs;
+                }, {})
+            })),
+            dynamic
+        };
+    }
+    async getSummaries(args) {
+        // fetch all published pages (as summaries)
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.AsLink.props;
+        const entries = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.PageData.getStrapiFilter(resultProps), sort: args.version === 'published'
+                ? ['type', 'publishedOn:desc', 'updatedAt:desc']
+                : ['type', 'updatedAt:desc'] }, getPageQueryParams(args)));
+        // transform to dtos
+        return entries.items.map(item => serialization_1.PageData.deserialize(item, strapiUrl, resultProps));
+    }
+    async getPreviews(_a) {
+        var { pagination } = _a, args = __rest(_a, ["pagination"]);
+        // fetch all pages that match (as link data)
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.AsPreview.props;
+        const { filters, status } = getPageQueryParams(args);
+        const _b = await Strapi_1.Strapi.paginate({
+            collection,
+            pagination,
+            fields: serialization_1.PageData.getStrapiFilter(resultProps),
+            filters: {
+                $and: [
+                    Object.assign(Object.assign({}, filters), { preview: { $not: { $eq: '{}' } } }),
+                    { preview: { $notNull: true } }
+                ]
+            },
+            populate: serialization_1.PageData.Populate.preview,
+            sort: args.version === 'published'
+                ? ['publishedOn:desc', 'updatedAt:desc']
+                : ['updatedAt:desc'],
+            status
+        }), { items } = _b, paginated = __rest(_b, ["items"]);
+        // transform and return items
+        return Object.assign({ items: items.map(item => serialization_1.PageData.deserialize(item, strapiUrl, resultProps)) }, paginated);
+    }
+    async search(_a) {
+        var { pagination } = _a, args = __rest(_a, ["pagination"]);
+        // fetch all pages that match (as link data)
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.AsLink.props;
+        const _b = await Strapi_1.Strapi.paginate(Object.assign({ collection,
+            pagination, fields: serialization_1.PageData.getStrapiFilter(resultProps), sort: args.version === 'published'
+                ? ['publishedOn:desc', 'updatedAt:desc']
+                : ['updatedAt:desc'] }, getPageQueryParams(args))), { items } = _b, paginated = __rest(_b, ["items"]);
+        // transform and return items
+        return Object.assign({ items: items.map(item => serialization_1.PageData.deserialize(item, strapiUrl, resultProps)) }, paginated);
+    }
+    async query(_a) {
+        var { pagination } = _a, args = __rest(_a, ["pagination"]);
+        // setup
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.AsPreview.props;
+        // fetch ranking of pages
+        const { type, version, brand, region, language, sort, excludeIds = [] } = args;
+        const rankedPageIds = await this.provider.customRequest({
+            method: 'GET',
+            command: 'query/rank-pages',
+            params: {
+                preview: version === 'draft',
+                type: funnel_core_1.ArrayUtils.coerce(type),
+                brand, region, language, sort
+            }
+        });
+        // filter out excluded ids
+        const filteredRankedPageIds = rankedPageIds.filter(id => !excludeIds.includes(id));
+        // get subset of ids based on pagination
+        const start = pagination === 'all' ? 0 : pagination.page - 1;
+        const end = pagination === 'all' ? rankedPageIds.length : pagination.page * pagination.pageSize;
+        const scopedRankedPageIds = filteredRankedPageIds.slice(start, end);
+        // fetch page previews by ids
+        const { data: unorderedPages } = await collection.find(Object.assign({ fields: serialization_1.PageData.getStrapiFilter(resultProps), populate: serialization_1.PageData.Populate.preview }, getPageQueryParams(Object.assign(Object.assign({}, args), { ids: scopedRankedPageIds }))));
+        // apply sorting to fetched page previews
+        const rankedPages = scopedRankedPageIds.map(id => {
+            const pageIndex = unorderedPages.findIndex(page => page.documentId === id);
+            const [page] = unorderedPages.splice(pageIndex, 1);
+            return page;
+        });
+        // deserialize pages and return
+        return {
+            items: rankedPages.map(page => serialization_1.PageData.deserialize(page, strapiUrl, resultProps)),
+            page: pagination === 'all' ? 1 : pagination.page,
+            pageCount: pagination === 'all' ? 1 : Math.ceil(filteredRankedPageIds.length / pagination.pageSize),
+            totalItemCount: filteredRankedPageIds.length
+        };
+    }
+    async find(_a) {
+        var { pagination } = _a, args = __rest(_a, ["pagination"]);
+        // fetch all pages that match (as link data)
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.Props.all;
+        const _b = await Strapi_1.Strapi.paginate(Object.assign({ collection,
+            pagination, fields: serialization_1.PageData.getStrapiFilter(resultProps), sort: args.version === 'published'
+                ? ['publishedOn:desc', 'updatedAt:desc']
+                : ['updatedAt:desc'], populate: serialization_1.PageData.Populate.full }, getPageQueryParams(args))), { items } = _b, paginated = __rest(_b, ["items"]);
+        // transform to DTOs
+        return Object.assign({ items: items.map(item => serialization_1.PageData.deserialize(item, strapiUrl, resultProps)) }, paginated);
+    }
+    async getGroup({ brand, groupId, type, slug, region, language, version }) {
+        // 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: [] }
+        };
+        // 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 [baselinePage] = baselineItems;
+        if (!baselinePage) {
+            return result;
+        }
+        // FIXME: fail if multiple group ids come back in the result
+        // fetch all pages (as summaries) using the groupId to target
+        const { items = [] } = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.PageData.getStrapiFilter(funnel_core_1.Schema.Page.Data.AsGroup.Instance.props) }, getPageQueryParams({ version, brand, groupId: baselinePage.groupId })));
+        // add items if any
+        const { group } = result;
+        for (const item of items) {
+            // connect groupId + preset (should all be the same, so it's ok to pave over)
+            group.groupId = item.groupId;
+            // add instance
+            const instance = serialization_1.PageData.deserialize(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) {
+                result.page = await this.get({ id: instance.id, version });
+            }
+        }
+        // return result
+        return result;
+    }
+    async get(args) {
+        // get page by id
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = 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];
+        }
+        // convert and return
+        return serialization_1.PageData.deserialize(data, strapiUrl, resultProps);
+    }
+    async create(args) {
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // 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.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));
+            draft.sync();
+            // resolve change set (rebind)
+            const { provider } = this;
+            const changeSet = await provider.changeSets.resolve();
+            // create page
+            try {
+                // connect page to changeset
+                draft.data.changeSetId = changeSet.id;
+                // create data model based on existing page
+                const { data } = await client.collection('pages')
+                    .create(serialization_1.PageData.serialize(draft.data), {
+                    status: 'draft',
+                    populate: serialization_1.PageData.Populate.full
+                });
+                // transform the deserialized entry
+                const page = serialization_1.PageData.deserialize(data, strapiUrl, funnel_core_1.Schema.Page.Data.Props.all);
+                // add page to changeset
+                await provider.changeSets.update({
+                    id: changeSet.id,
+                    changes: [
+                        ...changeSet.changes,
+                        {
+                            __type: 'page',
+                            type: 'create',
+                            schema: page.type,
+                            id: page.id,
+                            name: page.name,
+                            region: page.region,
+                            language: page.language,
+                            slug: page.slug,
+                            errors: page.errors,
+                            attribution: [
+                                { userId: user.id, updatedOn: Date.now() }
+                            ]
+                        }
+                    ]
+                });
+                // return new page
+                return {
+                    group: {
+                        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 })),
+                            {
+                                id: page.id,
+                                url: page.url,
+                                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
+                };
+            }
+            // remove
+            catch (e) {
+                // discard if it had no changes
+                if (changeSet.changes.length === 0) {
+                    await provider.changeSets.delete(changeSet.id);
+                }
+                // throw error
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+        // or create a net new page
+        else {
+            // 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,
+                slug: args.slug,
+                language: args.language
+            });
+            // return existing page if it's there
+            if (existingPage) {
+                return { group: existingGroup, page: existingPage };
+            }
+            // 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();
+            // resolve change set (rebind)
+            const { provider } = this;
+            const changeSet = await provider.changeSets.resolve();
+            // create page
+            try {
+                // connect page to changeset
+                draft.data.changeSetId = changeSet.id;
+                // create page
+                const { data } = await client.collection('pages')
+                    .create(serialization_1.PageData.serialize(draft.data), {
+                    status: 'draft',
+                    populate: serialization_1.PageData.Populate.full
+                });
+                // transform the deserialized entry
+                const page = serialization_1.PageData.deserialize(data, strapiUrl, funnel_core_1.Schema.Page.Data.Props.all);
+                // add page to changeset
+                await provider.changeSets.update({
+                    id: changeSet.id,
+                    changes: [
+                        ...changeSet.changes,
+                        {
+                            __type: 'page',
+                            type: 'create',
+                            schema: page.type,
+                            id: page.id,
+                            name: page.name,
+                            region: page.region,
+                            language: page.language,
+                            slug: page.slug,
+                            errors: page.errors,
+                            attribution: [
+                                { userId: user.id, updatedOn: Date.now() }
+                            ]
+                        }
+                    ]
+                });
+                // return page
+                return {
+                    group: {
+                        groupId: page.groupId,
+                        brand: page.brand,
+                        type: page.type,
+                        region: args.region,
+                        slug: page.slug,
+                        instances: [
+                            ...existingGroup.instances,
+                            {
+                                id: page.id,
+                                url: page.url,
+                                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
+                };
+            }
+            // remove
+            catch (e) {
+                // discard page if it had no changes
+                if (changeSet.changes.length === 0) {
+                    await provider.changeSets.delete(changeSet.id);
+                }
+                // throw error
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+    }
+    async duplicate({ source: pageId, targetPage, targetLanguage, targetSlug }) {
+        var _a;
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // get page by id
+        const pageCollection = client.collection('pages');
+        const { data: sourceData } = await pageCollection.findOne(pageId, {
+            fields: serialization_1.PageData.getStrapiFilter(funnel_core_1.Schema.Page.Data.Props.all),
+            status: 'draft',
+            populate: serialization_1.PageData.Populate.full
+        });
+        const sourcePage = sourceData;
+        // throw if there's no page
+        if (!sourcePage) {
+            throw new funnel_core_1.NotFoundError(`Unable to resolve page with id "${pageId}"`);
+        }
+        // TODO: check schema to see if language is possible
+        // make sure target language doesn't already exist if we are targeting the current group
+        if (targetPage === 'current') {
+            const { data: pagesWithTargetLanguage } = await pageCollection.find(Object.assign({ fields: ['documentId'] }, getPageQueryParams({ version: 'draft', groupId: sourcePage.groupId, language: targetLanguage })));
+            if (pagesWithTargetLanguage.length > 0) {
+                throw new funnel_core_1.InvalidOperationError(`There is already a page in group "${sourcePage.groupId}" with ${targetLanguage} language`);
+            }
+        }
+        // make sure a static page isn't getting duplicated and that the slug is good
+        else if (targetPage === 'new') {
+            // get source page's schema
+            const site = funnel_core_1.Schema.Site.current();
+            const schema = site.regions[sourcePage.region][sourcePage.type];
+            // cannot duplicate a static page
+            if (schema.variant === 'static') {
+                throw new funnel_core_1.InvalidOperationError(`cannot duplicate a static page "${sourcePage.name}"`);
+            }
+            // slug must be provided
+            if (targetSlug === undefined) {
+                throw new funnel_core_1.ArgumentError('slug must be provided when duplicating a page');
+            }
+            // validate slug
+            const validateSlugResult = await this.validateSlug({
+                brand: sourcePage.brand,
+                type: sourcePage.type,
+                region: sourcePage.region,
+                slug: targetSlug
+            });
+            if (validateSlugResult.status !== 'available') {
+                throw new errors_1.SlugValidationError({
+                    slug: targetSlug,
+                    reason: validateSlugResult
+                });
+            }
+        }
+        // get refs from source page
+        const { assetRefs, pageRefs, collectionRefs } = sourcePage;
+        // target refs and body
+        let targetPageRefIds;
+        let targetCollectionRefIds;
+        let targetBody;
+        // if we are targeting a different language then we need to "translate" the references
+        if (targetLanguage !== sourcePage.lang) {
+            // fetch target language refs
+            const { pageIdMappings, collectionIdMappings } = await Strapi_1.Strapi.translateReferences({
+                client,
+                targetLanguage,
+                pageRefs,
+                collectionRefs
+            });
+            console.debug('[StrapiPageClient] duplicate: calculated mappings (source to target)', { pageIdMappings, collectionIdMappings });
+            // set target values
+            targetPageRefIds = pageIdMappings.map(mapping => mapping.targetId);
+            targetCollectionRefIds = collectionIdMappings.map(mapping => mapping.targetId);
+            targetBody = {
+                discover: Strapi_1.Strapi.updateRefs({ value: sourcePage.discover, pageIdMappings, collectionIdMappings }),
+                preview: Strapi_1.Strapi.updateRefs({ value: sourcePage.preview, pageIdMappings, collectionIdMappings }),
+                content: Strapi_1.Strapi.updateRefs({ value: sourcePage.content, pageIdMappings, collectionIdMappings }),
+            };
+        }
+        // otherwise we can keep everything the same as the source page
+        else {
+            // set target values
+            targetPageRefIds = pageRefs.map(ref => ref.documentId);
+            targetCollectionRefIds = collectionRefs.map(ref => ref.documentId);
+            targetBody = {
+                discover: sourcePage.discover,
+                preview: sourcePage.preview,
+                content: sourcePage.content
+            };
+        }
+        // resolve change set (rebind)
+        const { provider } = this;
+        const changeSet = await provider.changeSets.resolve();
+        // create duplicate page
+        try {
+            // create target page using content of source
+            const { data: dupData } = await pageCollection.create(Object.assign({ groupId: targetPage === 'current'
+                    ? sourcePage.groupId
+                    : funnel_core_1.Value.uuid(), type: sourcePage.type, brand: sourcePage.brand, region: sourcePage.region, lang: targetLanguage, slug: targetSlug !== null && targetSlug !== void 0 ? targetSlug : sourcePage.slug, name: sourcePage.name, tags: sourcePage.tags, url: sourcePage.url, state: 'draft', errors: sourcePage.errors, assetRefs: { set: assetRefs.map(ref => ref.documentId) }, pageRefs: { set: targetPageRefIds }, collectionRefs: { set: targetCollectionRefIds } }, targetBody), { status: 'draft', populate: serialization_1.PageData.Populate.full });
+            const dupPageData = dupData;
+            console.debug('[StrapiPageClient] duplicate: created duplicate page', { dupPageData });
+            // touch new duplicated page to update url/name
+            let dupPage = serialization_1.PageData.deserialize(dupPageData, strapiUrl, funnel_core_1.Schema.Page.Data.Props.all);
+            const dupPageModel = funnel_core_1.Schema.PageModel.from(dupPage);
+            dupPageModel.sync();
+            // connect page to changeset
+            dupPage.changeSetId = changeSet.id;
+            // update duplicate page with updated url/name
+            const update = serialization_1.PageData.serialize(dupPage);
+            const { data: updatedData } = await pageCollection.update(dupPage.id, update, { status: 'draft' });
+            dupPage = serialization_1.PageData.deserialize(updatedData, strapiUrl, funnel_core_1.Schema.Page.Data.Props.all);
+            console.debug('[StrapiPageClient] duplicate: touched duplicated page');
+            // add page to changeset
+            await provider.changeSets.update({
+                id: changeSet.id,
+                changes: [
+                    ...changeSet.changes,
+                    {
+                        __type: 'page',
+                        type: 'create',
+                        schema: dupPage.type,
+                        id: dupPage.id,
+                        name: dupPage.name,
+                        region: dupPage.region,
+                        language: dupPage.language,
+                        slug: dupPage.slug,
+                        errors: dupPage.errors,
+                        attribution: [
+                            { userId: user.id, updatedOn: Date.now() }
+                        ]
+                    }
+                ]
+            });
+            // return group for duplicated page
+            return this.getGroup({
+                brand: dupPage.brand,
+                groupId: dupPage.groupId,
+                type: dupPage.type,
+                slug: (_a = dupPage.slug) !== null && _a !== void 0 ? _a : undefined,
+                region: dupPage.region,
+                language: dupPage.language,
+                version: 'draft'
+            });
+        }
+        // handle errors
+        catch (e) {
+            // discard changeset if it had no changes
+            if (changeSet.changes.length === 0) {
+                await provider.changeSets.delete(changeSet.id);
+            }
+            // throw error
+            throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+        }
+    }
+    async touch({ id: pageId, version: status }) {
+        // get latest version of page
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.Props.all;
+        const { data: currentData } = await collection.findOne(pageId, {
+            status,
+            populate: serialization_1.PageData.Populate.full
+        });
+        // TODO: switch to isometric error so we can catch it on client-side
+        // throw if page doesn't exist
+        if (!currentData) {
+            throw new funnel_core_1.NotFoundError();
+        }
+        // deserialize page (we'll be updating this version)
+        const page = serialization_1.PageData.deserialize(currentData, strapiUrl, resultProps);
+        // merge changes (the original page will have changed)
+        const model = funnel_core_1.Schema.PageModel.from(page);
+        model.sync();
+        console.debug(`[StrapiPageClient/touch] saving updated page`);
+        // save page
+        const update = serialization_1.PageData.serialize(page);
+        const { data: updatedData } = await collection.update(page.id, update, {
+            status,
+            populate: serialization_1.PageData.Populate.full
+        });
+        console.debug(`[StrapiPageClient/update] returning final page`);
+        // return page ref
+        return serialization_1.PageData.deserializeRef(updatedData);
+    }
+    async update({ id: pageId, slug: pageSlug, publication: pagePublication, errors, updates }) {
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // get latest version of page
+        const collection = client.collection('pages');
+        const resultProps = funnel_core_1.Schema.Page.Data.Props.all;
+        const { data: currentData } = await collection.findOne(pageId, {
+            status: 'draft',
+            populate: serialization_1.PageData.Populate.full
+        });
+        // TODO: validate page is able to be updated (e.g. not archived, etc.)
+        // throw if page doesn't exist
+        if (!currentData) {
+            throw new funnel_core_1.NotFoundError();
+        }
+        // deserialize page (we'll be updating this version)
+        let page = serialization_1.PageData.deserialize(currentData, strapiUrl, resultProps);
+        // update slug
+        if (pageSlug && page.slug) {
+            console.debug(`[StrapiPageClient/update] updating page slug from "${page.slug}" to ${pageSlug}`);
+            // validate slug before updating
+            const validateSlugResult = await this.validateSlug({
+                brand: page.brand,
+                type: page.type,
+                region: page.region,
+                groupId: page.groupId,
+                slug: pageSlug
+            });
+            if (validateSlugResult.status !== 'available') {
+                throw new errors_1.SlugValidationError({ slug: pageSlug, reason: validateSlugResult });
+            }
+            page.slug = pageSlug;
+        }
+        // update publication
+        if (pagePublication !== undefined) {
+            page.publication = pagePublication !== null && pagePublication !== void 0 ? pagePublication : -1;
+        }
+        // set errors
+        page.errors = errors;
+        console.debug(`[StrapiPageClient/update] applying ${updates.length} page updates`);
+        // merge changes (the original page will have changed)
+        const model = funnel_core_1.Schema.PageModel.from(page);
+        model.update(updates);
+        console.debug(`[StrapiPageClient/update] saving updated page`);
+        // resolve change set (rebind)
+        const { provider } = this;
+        const changeSet = await provider.changeSets.resolve({ id: page.changeSetId, fallbackToGlobal: true });
+        page.changeSetId = changeSet.id;
+        // save page
+        const update = serialization_1.PageData.serialize(page);
+        console.debug(`[StrapiPageClient/update] sending update`, JSON.stringify(update, undefined, '  '));
+        const { data: updatedData } = await collection.update(page.id, Object.assign(Object.assign({}, update), { state: 'draft' }), {
+            status: 'draft',
+            populate: serialization_1.PageData.Populate.full
+        });
+        page = serialization_1.PageData.deserialize(updatedData, strapiUrl, resultProps);
+        // update changeset
+        changeSet.addPageChange(user.id, {
+            __type: 'page',
+            id: page.id,
+            name: page.name,
+            schema: page.type,
+            region: page.region,
+            language: page.language,
+            slug: page.slug,
+            type: page.publishedOn ? 'update' : 'create',
+            errors: page.errors
+        });
+        provider.changeSets.update(changeSet.toData())
+            .catch(console.error);
+        // return page
+        return page;
+    }
+    async replace({ page, version, skipSync = false }) {
+        console.debug(`[StrapiPageClient/replace] replacing page`);
+        // get latest version of page
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        // sync changes (the original page will have changed)
+        const model = funnel_core_1.Schema.PageModel.from(page);
+        if (!skipSync) {
+            model.sync();
+        }
+        // save page
+        const update = serialization_1.PageData.serialize(page);
+        const { data: updatedData } = await collection.update(page.id, update, {
+            status: version,
+            populate: serialization_1.PageData.Populate.full
+        });
+        console.debug(`[StrapiPageClient/replace] returning final page`);
+        // return page
+        return serialization_1.PageData.deserialize(updatedData, strapiUrl);
+    }
+    async unpublish(pageId) {
+        // get page
+        const page = await this.get({ id: pageId, version: 'draft' });
+        // throw if there's no page
+        if (!page) {
+            throw new funnel_core_1.NotFoundError('Unable to resolve page');
+        }
+        // or throw if it's already draft
+        else if (!page.publishedOn) {
+            throw new funnel_core_1.InvalidOperationError('Page is not published');
+        }
+        // unpublish the document
+        await this.provider.customRequest({
+            method: 'POST',
+            command: 'unpublish',
+            data: JSON.stringify({
+                collection: 'page',
+                documentId: page.id
+            }),
+            onError: ({ pageRefs, collectionRefs }) => {
+                // throw dependants error if we got any refs
+                if (pageRefs || collectionRefs) {
+                    const client = this.provider.client;
+                    const strapiUrl = client.baseURL;
+                    throw new errors_1.LinkedDependantsError({
+                        message: 'This collection cannot be unpublished because it would break dependencies',
+                        pages: pageRefs.map(data => serialization_1.PageData.deserialize(data, strapiUrl, funnel_core_1.Schema.Page.Data.AsLink.props)),
+                        collections: collectionRefs.map(data => serialization_1.CollectionData.deserialize(data, strapiUrl, funnel_core_1.Schema.Collection.Data.AsLink.props))
+                    });
+                }
+                // or assume the page isn't published
+                else {
+                    throw new funnel_core_1.NotFoundError();
+                }
+            }
+        });
+        // transform dto
+        return true;
+    }
+    async getDependants({ id: pageId, version }) {
+        // get client
+        const client = this.provider.client;
+        // pages are the only direct dependants currently
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const { items: pages = [] } = await Strapi_1.Strapi.paginate({
+            collection,
+            pagination: 'all',
+            filters: {
+                pageRefs: {
+                    documentId: pageId
+                }
+            },
+            status: version
+        });
+        // return
+        return {
+            pages: pages.map(page => serialization_1.PageData.deserialize(page, strapiUrl, funnel_core_1.Schema.Page.Data.AsLink.props))
+        };
+    }
+    async getDependencies({ id: pageId, version }) {
+        // get page by id
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('pages');
+        const { data } = await collection.findOne(pageId, {
+            status: version,
+            populate: ['pageRefs', 'collectionRefs']
+        });
+        const page = data;
+        // throw if not found
+        if (!page) {
+            throw new funnel_core_1.NotFoundError(`cannot find page with id "${pageId}"`);
+        }
+        // return
+        return {
+            pages: page.pageRefs.map(pageRef => serialization_1.PageData.deserialize(pageRef, strapiUrl, funnel_core_1.Schema.Page.Data.AsLink.props)),
+            collections: page.collectionRefs.map(collectionRef => serialization_1.CollectionData.deserialize(collectionRef, strapiUrl, funnel_core_1.Schema.Collection.Data.AsLink.props))
+        };
+    }
+    async validateSlug({ brand, type, region, slug, groupId }) {
+        // TODO: check if slug is a valid format
+        // setup collection
+        const client = this.provider.client;
+        const collection = client.collection('pages');
+        // fetch pages with the same slug with same brand, type, and region
+        const { items } = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.PageData.getStrapiFilter(funnel_core_1.Schema.Page.Data.AsLink.props) }, getPageQueryParams({ version: 'draft', brand, type, region, slug })));
+        // ignore pages in same group (if group specified)
+        const matchedPages = groupId !== undefined
+            ? items.filter(item => item.groupId !== groupId)
+            : items;
+        // available if no pages matched
+        if (matchedPages.length === 0) {
+            return { status: 'available' };
+        }
+        // otherwise not available
+        else {
+            return {
+                status: 'unavailable',
+                takenBy: serialization_1.PageData.deserializeRef(matchedPages[0])
+            };
+        }
+    }
+}
+exports.StrapiPageClient = StrapiPageClient;
+// helper
+function getPageQueryParams(query) {
+    // build filters
+    const { ids = [], groupId, brand, type, slug, region, language, name, tags = [], tagsMatch = 'any', version } = query;
+    const filters = [];
+    // filter ids
+    if (ids.length > 0) {
+        filters.push({ documentId: { $in: ids } });
+    }
+    // filter group
+    if (groupId) {
+        filters.push({ groupId: { $eq: groupId } });
+    }
+    // filter brand
+    if (brand) {
+        filters.push({ brand: { $eq: brand } });
+    }
+    // filter type
+    const normalizedType = type
+        ? Array.isArray(type)
+            ? type
+            : [type]
+        : [];
+    if (normalizedType.length > 0) {
+        filters.push({ type: { $in: type } });
+    }
+    // filter slug
+    if (slug) {
+        filters.push({ slug: { $eq: slug } });
+    }
+    // filter region
+    if (region) {
+        filters.push({ region: { $eq: region } });
+    }
+    // filter language
+    if (language) {
+        filters.push({ lang: { $eq: language } });
+    }
+    // filter name
+    if (name) {
+        filters.push({ name: { $contains: name } });
+    }
+    // filter tags
+    if (tags.length === 1) {
+        filters.push({ tags: { $contains: `"${tags[0]}"` } });
+    }
+    else if (tags.length > 1) {
+        const operator = tagsMatch === 'any' ? '$or' : '$and';
+        filters.push({
+            [operator]: tags
+                .filter((tag) => !!tag)
+                .map((tag) => ({ tags: { $contains: `"${tag}"` } }))
+        });
+    }
+    // return query
+    return {
+        filters: filters.length > 0 ? { $and: filters } : undefined,
+        status: version
+    };
+}