@nascentdigital/funnel-cms 4.6.7 → 5.0.2

package/dist/contentful/ContentfulContentClient.js

@@ -0,0 +1,208 @@
+"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.ContentfulContentClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const contentful_management_1 = require("contentful-management");
+const models_1 = require("../models");
+const ContentfulAccess_1 = require("./ContentfulAccess");
+const ContentfulAssetClient_1 = require("./ContentfulAssetClient");
+const ContentfulAuthClient_1 = require("./ContentfulAuthClient");
+const ContentfulChangeSetClient_1 = require("./ContentfulChangeSetClient");
+const ContentfulCollectionClient_1 = require("./ContentfulCollectionClient");
+const ContentfulPageClient_1 = require("./ContentfulPageClient");
+const ContentfulSiteConfigClient_1 = require("./ContentfulSiteConfigClient");
+const ContentfulUpgradeClient_1 = require("./ContentfulUpgradeClient");
+const ContentfulUserClient_1 = require("./ContentfulUserClient");
+const models_2 = require("./models");
+// class
+class ContentfulContentClient {
+    constructor(args) {
+        var _a;
+        // initialize instance variables
+        let sp;
+        if (ContentfulContentClient.ConstructorArgs.isForServer(args)) {
+            this.user = models_1.User.UNAUTHENTICATED;
+            this.locale = args.locale;
+            const options = { defaults: { spaceId: args.spaceId, environmentId: args.environment } };
+            this.cma = (0, contentful_management_1.createClient)({ accessToken: args.accessToken }, options);
+            this.cda = (0, contentful_management_1.createClient)({ accessToken: args.deliveryAccessToken, host: 'cdn.contentful.com' }, options);
+            this.cpa = (0, contentful_management_1.createClient)({ accessToken: args.previewAccessToken, host: 'preview.contentful.com' }, options);
+        }
+        else {
+            const { user, locales, cma, ids } = args.sdk;
+            this.user = new models_1.User({
+                brands: [funnel_core_1.AppConfig.brand()],
+                id: user.sys.id,
+                email: user.email,
+                username: user.email,
+                blocked: false,
+                role: user.spaceMembership.roles.length === 0
+                    ? 'public'
+                    : user.spaceMembership.roles
+                        .map(({ name }) => models_2.ContentfulUserData.parseRole(name))
+                        .sort((lhs, rhs) => lhs.compareTo(rhs))[0].id
+            });
+            this.locale = locales.default;
+            this.cma = cma;
+            const options = { defaults: { spaceId: ids.space, environmentId: (_a = ids.environmentAlias) !== null && _a !== void 0 ? _a : ids.environment } };
+            this.cda = (0, contentful_management_1.createClient)({ accessToken: args.deliveryAccessToken, host: 'cdn.contentful.com' }, options);
+            this.cpa = (0, contentful_management_1.createClient)({ accessToken: args.previewAccessToken, host: 'preview.contentful.com' }, options);
+        }
+        this.deliveryAccessToken = args.deliveryAccessToken;
+        this.previewAccessToken = args.previewAccessToken;
+        this.auth = new ContentfulAuthClient_1.ContentfulAuthClient(this);
+        this.changeSets = new ContentfulChangeSetClient_1.ContentfulChangeSetClient(this);
+        this.files = new ContentfulAssetClient_1.ContentfulAssetClient(this);
+        this.pages = new ContentfulPageClient_1.ContentfulPageClient(this);
+        this.collections = new ContentfulCollectionClient_1.ContentfulCollectionClient(this);
+        this.upgrade = new ContentfulUpgradeClient_1.ContentfulUpgradeClient(this);
+        this.users = new ContentfulUserClient_1.ContentfulUserClient(this);
+        this.siteConfig = new ContentfulSiteConfigClient_1.ContentfulSiteConfigClient(this);
+    }
+    get token() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    set token(token) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    clearToken() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createEntry(contentTypeId, entry) {
+        // create entry
+        const { locale, cma } = this;
+        const data = await cma.entry.create({ contentTypeId }, {
+            fields: models_2.ContentfulData.toEntryData(entry, locale)
+        });
+        // transform + return new entry
+        return models_2.ContentfulData.fromCmaData(data, locale);
+    }
+    async getEntry({ entryId, includeLinks = false, version = 'draft' }) {
+        var _a, _b;
+        // get entry
+        const client = version === 'published' ? this.cda : this.cpa;
+        const result = await client.entry.getMany({
+            query: {
+                'sys.id': entryId,
+                include: includeLinks === true
+                    ? 10
+                    : includeLinks || undefined
+            }
+        });
+        const { items: [item], includes } = result;
+        console.debug('[ContentfulContentClient/getEntry] fetched', result);
+        // 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 : [];
+        // 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"]);
+        // 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) {
+            // fetch next page
+            const _d = await client.entry.getMany({
+                query: Object.assign(Object.assign({}, query), { limit,
+                    skip, include: includeLinks === true
+                        ? 10
+                        : includeLinks || undefined })
+            }), { items } = _d, response = __rest(_d, ["items"]);
+            console.debug('[ContentfulContentClient/getEntries] fetched page', { query, items, response });
+            // 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;
+        }
+        console.debug('[ContentfulContentClient/getEntries] fetched entries', { entries, includes });
+        // normalize references
+        const references = includes.map(link => models_2.ContentfulData.fromCdaData(link));
+        // return
+        return {
+            entries,
+            references
+        };
+    }
+    static async forEditor(sdk) {
+        var _a;
+        // get current site config (throw if we can't)
+        const { user, cma, locales: { default: locale } } = sdk;
+        const userId = user.sys.id;
+        const brand = funnel_core_1.AppConfig.brand();
+        const { items: [siteConfigData] } = await cma.entry.getMany({
+            query: {
+                content_type: models_2.ContentfulSiteConfigData.contentType,
+                'fields.brand': brand
+            }
+        });
+        const siteConfig = siteConfigData && models_2.ContentfulData.fromCmaData(siteConfigData, locale);
+        if (!siteConfig) {
+            throw new funnel_core_1.NotFoundError('Unable to resolve SiteConfig');
+        }
+        // grant user temp access via the new token
+        const access = ContentfulAccess_1.ContentfulAccess.new(userId);
+        await cma.entry.patch({ entryId: siteConfig.id, version: siteConfig.__version }, [
+            {
+                op: 'replace',
+                path: `/fields/access/${locale}`,
+                value: Object.assign(Object.assign({}, siteConfig.access), { [userId]: access.data })
+            }
+        ]);
+        // call API to get delivery/preview tokens
+        const command = {
+            type: 'GetAccessTokens',
+            userId: access.userId,
+            token: access.token
+        };
+        const response = await fetch('/api/contentful', {
+            method: 'POST',
+            body: JSON.stringify(command)
+        });
+        // throw if response failed
+        await funnel_core_1.IsometricErrorUtils.checkResponse(response);
+        // throw if not valid
+        const { data } = (_a = await response.json()) !== null && _a !== void 0 ? _a : {};
+        const { deliveryAccessToken, previewAccessToken } = data !== null && data !== void 0 ? data : {};
+        if (!deliveryAccessToken || !previewAccessToken) {
+            throw new funnel_core_1.IllegalStateError('Invalid data return from API');
+        }
+        console.debug('[ContentfulContentClient/forEditor] creating with', { sdk, deliveryAccessToken, previewAccessToken });
+        // create + return new client
+        return new ContentfulContentClient({ sdk, deliveryAccessToken, previewAccessToken });
+    }
+}
+exports.ContentfulContentClient = ContentfulContentClient;
+// extension
+(function (ContentfulContentClient) {
+    let ConstructorArgs;
+    (function (ConstructorArgs) {
+        // helpers
+        function isForServer(args) {
+            return 'accessToken' in args;
+        }
+        ConstructorArgs.isForServer = isForServer;
+        function isForEditor(args) {
+            return 'sdk' in args;
+        }
+        ConstructorArgs.isForEditor = isForEditor;
+    })(ConstructorArgs = ContentfulContentClient.ConstructorArgs || (ContentfulContentClient.ConstructorArgs = {}));
+})(ContentfulContentClient || (exports.ContentfulContentClient = ContentfulContentClient = {}));

package/dist/contentful/ContentfulContentClientFactory.d.ts

@@ -0,0 +1,12 @@
+import { ContentClient } from '../api';
+import { ContentfulContentClient } from './ContentfulContentClient';
+export declare class ContentfulContentClientFactory implements ContentClient.Factory {
+    private readonly args;
+    private readonly _serverClient;
+    constructor(args: ContentfulContentClientFactory.ConstructorArgs);
+    forServer(): ContentfulContentClient;
+    forEditor(): ContentfulContentClient;
+}
+export declare namespace ContentfulContentClientFactory {
+    type ConstructorArgs = ContentfulContentClient.ConstructorArgs;
+}

package/dist/contentful/ContentfulContentClientFactory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulContentClientFactory = void 0;
+const ContentfulContentClient_1 = require("./ContentfulContentClient");
+// factory
+class ContentfulContentClientFactory {
+    constructor(args) {
+        this.args = args;
+        // initialize instance variables
+        this._serverClient = new ContentfulContentClient_1.ContentfulContentClient(args);
+    }
+    forServer() {
+        return this._serverClient;
+    }
+    forEditor() {
+        return new ContentfulContentClient_1.ContentfulContentClient(this.args);
+    }
+}
+exports.ContentfulContentClientFactory = ContentfulContentClientFactory;

package/dist/contentful/ContentfulPageClient.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { PageClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+import { ContentfulPageData } from './models';
+export declare class ContentfulPageClient implements PageClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    getOverview(args: PageClient.GetOverview.Args): Promise<PageClient.GetOverview.Result>;
+    getSummaries(args: PageClient.GetSummaries.Args): Promise<PageClient.GetSummaries.Result>;
+    getPreviews(args: PageClient.GetPreviews.Args): Promise<PageClient.GetPreviews.Result>;
+    search(args: PageClient.Search.Args): Promise<PageClient.Search.Result>;
+    query(args: PageClient.Query.Args): Promise<PageClient.Query.Result>;
+    find(args: PageClient.Find.Args): Promise<PageClient.Find.Result>;
+    getGroup(args: PageClient.GetGroup.Args): Promise<ContentfulPageClient.GetGroup.Result>;
+    get(args: PageClient.Get.Args): Promise<ContentfulPageClient.Get.Result>;
+    create(args: PageClient.Create.Args): Promise<PageClient.Create.Result>;
+    duplicate(args: PageClient.Duplicate.Args): Promise<PageClient.Duplicate.Result>;
+    update(args: PageClient.Update.Args): Promise<ContentfulPageClient.Update.Result>;
+    replace(args: PageClient.Replace.Args): Promise<PageClient.Replace.Result>;
+    touch(args: PageClient.Touch.Args): Promise<PageClient.Touch.Result>;
+    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>;
+}
+export declare namespace ContentfulPageClient {
+    type FlattedPageData = Omit<Schema.Page.FlattenedData, 'data'> & {
+        data: ContentfulPageData.ForSchema;
+    };
+    namespace GetGroup {
+        type Result = Omit<PageClient.GetGroup.Result, 'page'> & {
+            page?: FlattedPageData;
+        };
+    }
+    namespace Get {
+        type Result = FlattedPageData | undefined;
+    }
+    namespace Update {
+        type Result = Omit<PageClient.Update.Result, 'page'> & {
+            page?: FlattedPageData;
+        };
+    }
+}

package/dist/contentful/ContentfulPageClient.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulPageClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const models_1 = require("./models");
+// class
+class ContentfulPageClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    async getOverview(args) {
+        // fetch all pages
+        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)));
+        // convert entries to page data
+        const pagesData = entries.map(entry => models_1.ContentfulPageData.deserialize(entry, funnel_core_1.Schema.Page.Data.AsLink.props));
+        // setup maps
+        const staticPages = new Map();
+        const dynamicPages = new Map();
+        // go over each page data
+        for (const data of pagesData) {
+            // use appropriate map (determine if page is static/dynamic)
+            const pagesMap = data.slug === undefined
+                ? staticPages
+                : dynamicPages;
+            // get references by page type
+            let refs = pagesMap.get(data.type);
+            if (!refs) {
+                pagesMap.set(data.type, refs = []);
+            }
+            // add to refs
+            refs.push(data);
+        }
+        // return
+        return {
+            // static pages
+            static: staticPages.entries().map(([type, refs]) => ({
+                type,
+                refs: refs.reduce((refs, ref) => {
+                    // add page
+                    refs[ref.language] = ref;
+                    // keep reducing
+                    return refs;
+                }, {})
+            })).toArray(),
+            // dynamic pages
+            dynamic: dynamicPages.entries().map(([type, refs]) => ({
+                type,
+                count: refs.length
+            })).toArray()
+        };
+    }
+    async getSummaries(args) {
+        // 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
+        return entries.map(entry => models_1.ContentfulPageData.deserialize(entry, funnel_core_1.Schema.Page.Data.AsLink.props));
+    }
+    getPreviews(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    search(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    query(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    find(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getGroup(args) {
+        // 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.AsGroup.Instance.props) }, getPageQueryParams(args)));
+        // 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;
+            return {
+                group: { groupId: possibleGroupId !== null && possibleGroupId !== void 0 ? possibleGroupId : funnel_core_1.Schema.Page.GroupId.empty, brand, type, slug, region, instances: [] }
+            };
+        }
+        console.debug('[ContentfulPageClient/getGroup] processing group items', { args, entries });
+        // 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);
+        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];
+        return {
+            group: {
+                groupId,
+                type,
+                brand,
+                region,
+                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)));
+        // skip if no entries
+        if (entries.length === 0) {
+            return undefined;
+        }
+        // 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();
+    }
+    duplicate(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    replace(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    touch(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    unpublish(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    getDependants(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    getDependencies(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    validateSlug(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulPageClient = ContentfulPageClient;
+// helpers
+function getPageQueryParams(query) {
+    // build filters
+    const { ids = [], groupId, brand, type, slug, region, language, name, tags = [], tagsMatch = 'any', version } = query;
+    const filters = {};
+    // filter id(s)
+    if (ids.length === 1) {
+        filters['sys.id'] = ids[0];
+    }
+    else if (ids.length > 1) {
+        filters['sys.id[in]'] = ids.join(',');
+    }
+    // filter group
+    if (groupId) {
+        filters['fields.groupId'] = groupId;
+    }
+    // filter brand
+    if (brand) {
+        filters['fields.brand'] = brand;
+    }
+    // filter type(s)
+    const normalizedType = type
+        ? Array.isArray(type)
+            ? type
+            : [type]
+        : [];
+    if (normalizedType.length === 1) {
+        filters['fields.type'] = normalizedType[0];
+    }
+    else if (normalizedType.length > 1) {
+        filters['fields.type[in]'] = normalizedType.join(',');
+    }
+    // filter slug
+    if (slug) {
+        filters['fields.slug'] = slug;
+    }
+    // filter region
+    if (region) {
+        filters['fields.region'] = region;
+    }
+    // filter language
+    if (language) {
+        filters['fields.language'] = language;
+    }
+    // filter name
+    if (name) {
+        filters['fields.name[match]'] = name;
+    }
+    // filter tags
+    if (tags.length > 0) {
+        filters[`fields.tags[${tagsMatch === 'any' ? 'in' : 'all'}]`] = tags
+            .filter((tag) => !!tag)
+            .join(',');
+    }
+    // return filters
+    return filters;
+}
+function getPageSelect(props) {
+    // build select
+    const select = new Set(['sys']);
+    for (const prop of props) {
+        switch (prop) {
+            // parity
+            case 'groupId':
+            case 'brand':
+            case 'type':
+            case 'slug':
+            case 'url':
+            case 'region':
+            case 'language':
+            case 'name':
+            case 'tags':
+            case 'discover':
+            case 'preview':
+            case 'content':
+            case 'state':
+            case 'errors':
+            case 'publishedOn':
+            case 'publication':
+                select.add(`fields.${prop}`);
+                break;
+            // links
+            case 'files':
+            case 'pages':
+            case 'collections':
+                select.add('fields.references');
+                break;
+            // ignore the rest
+            default:
+                break;
+        }
+    }
+    // bail if nothing added
+    if (select.size === 0) {
+        return undefined;
+    }
+    // return as joint string
+    return Array.from(select).join(',');
+}

package/dist/contentful/ContentfulSiteConfigClient.d.ts

@@ -0,0 +1,9 @@
+import { SiteConfigClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+import { ContentfulSiteConfigData } from './models';
+export declare class ContentfulSiteConfigClient implements SiteConfigClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    get({ brand }: SiteConfigClient.Get.Args): Promise<ContentfulSiteConfigData>;
+    update(args: SiteConfigClient.Update.Args): Promise<SiteConfigClient.Update.Result>;
+}

package/dist/contentful/ContentfulSiteConfigClient.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulSiteConfigClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const models_1 = require("./models");
+// class
+class ContentfulSiteConfigClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    async get({ brand }) {
+        // fetch config model
+        let { entries: [siteConfig] } = await this.cms.getEntries({
+            content_type: models_1.ContentfulSiteConfigData.contentType,
+            limit: 1,
+            'fields.brand': brand
+        });
+        // or create it if it's not there
+        if (!siteConfig) {
+            siteConfig = await this.cms.createEntry(models_1.ContentfulSiteConfigData.contentType, {
+                brand,
+                lockdownEditor: false,
+                access: {}
+            });
+        }
+        // return config
+        return siteConfig;
+    }
+    update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulSiteConfigClient = ContentfulSiteConfigClient;

package/dist/contentful/ContentfulUpgradeClient.d.ts

@@ -0,0 +1,9 @@
+import { UpgradeClient } from '../api';
+import { Upgrade } from '../models';
+import { IContentfulContentClient } from './IContentfulContentClient';
+export declare class ContentfulUpgradeClient implements UpgradeClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    status(): Promise<Upgrade.Status>;
+    upgrade(): Promise<Upgrade.Status>;
+}

package/dist/contentful/ContentfulUpgradeClient.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulUpgradeClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ContentfulUpgradeClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    status() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    upgrade() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulUpgradeClient = ContentfulUpgradeClient;

package/dist/contentful/ContentfulUserClient.d.ts

@@ -0,0 +1,13 @@
+import { UserClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+export declare class ContentfulUserClient implements UserClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    me(): Promise<UserClient.Me.Result>;
+    getUsers(args?: UserClient.GetUsers.Args): Promise<UserClient.GetUsers.Result>;
+    getUser(args: UserClient.GetUser.Args): Promise<UserClient.GetUser.Result>;
+    createUser(args: UserClient.CreateUser.Args): Promise<UserClient.CreateUser.Result>;
+    updateUser(args: UserClient.UpdateUser.Args): Promise<UserClient.UpdateUser.Result>;
+    resetUser(args: UserClient.ResetUser.Args): Promise<UserClient.ResetUser.Result>;
+    deleteUser(args: UserClient.DeleteUser.Args): Promise<UserClient.DeleteUser.Result>;
+}

package/dist/contentful/ContentfulUserClient.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulUserClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ContentfulUserClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    async me() {
+        return this.cms.user.data;
+    }
+    getUsers(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    getUser(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    createUser(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    updateUser(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    resetUser(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    deleteUser(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulUserClient = ContentfulUserClient;