@nascentdigital/funnel-cms 5.0.1 → 5.0.3

package/dist/contentful/ContentfulPageClient.js

@@ -0,0 +1,459 @@
+"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 {
+    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();
+    }
+    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();
+    }
+    find(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    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, 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 } = queryArgs;
+            return {
+                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);
+        // 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 pageInstance = instances
+            .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, slug } = entries[0];
+        return {
+            group: { groupId, type, brand, slug, instances },
+            page
+        };
+    }
+    async get(args) {
+        // create args for query
+        const queryArgs = 'id' in args
+            ? { ids: [args.id], version: args.version }
+            : args;
+        // fetch entries (should be one entry)
+        const { cms } = this;
+        const { entries, references } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulPageData.contentType, includeLinks: true, version: args.version, pagination: { page: 1, pageSize: 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));
+    }
+    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();
+    }
+    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,
+            pagination: { page: 1, pageSize: 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;

package/dist/contentful/IContentfulContentClient.d.ts

@@ -0,0 +1,61 @@
+import { CMAClient } from '@contentful/app-sdk';
+import { PlainClientAPI, QueryOptions } from 'contentful-management';
+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';
+import type { ContentfulCollectionClient } from './ContentfulCollectionClient';
+import type { ContentfulPageClient } from './ContentfulPageClient';
+import type { ContentfulSiteConfigClient } from './ContentfulSiteConfigClient';
+import type { ContentfulUserClient } from './ContentfulUserClient';
+import { ContentfulAssetData, ContentfulData } from './models';
+export interface IContentfulContentClient {
+    readonly user: User;
+    readonly locale: string;
+    readonly cma: CMAClient;
+    readonly cda: PlainClientAPI;
+    readonly cpa: PlainClientAPI;
+    readonly auth: ContentfulAuthClient;
+    readonly changeSets: ContentfulChangeSetClient;
+    readonly files: ContentfulAssetClient;
+    readonly pages: ContentfulPageClient;
+    readonly collections: ContentfulCollectionClient;
+    readonly users: ContentfulUserClient;
+    readonly siteConfig: ContentfulSiteConfigClient;
+    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 = {
+        includeLinks?: boolean | number;
+        version?: Environment;
+    };
+    namespace GetEntry {
+        type Args<TEntry extends ContentfulData> = EntryQueryOptions & {
+            entryId: ContentfulData.EntryId<TEntry>;
+        };
+        type Result<TEntry extends ContentfulData> = {
+            entry: TEntry;
+            references: ContentfulData[];
+        };
+    }
+    namespace GetEntries {
+        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> = Pagination.Counts & {
+            entries: TEntry[];
+            references: ContentfulData[];
+        };
+    }
+    namespace UploadAsset {
+        type Args = AssetClient.CreateAsset.Args & {
+            file: Blob;
+        };
+        type Result = ContentfulAssetData;
+    }
+}

package/dist/contentful/IContentfulContentClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contentful/api/ContentfulApi.d.ts

@@ -0,0 +1,10 @@
+import 'server-only';
+import type { NextRequest, NextResponse as NextResponseType } from 'next/server';
+import { ContentfulApiCommand } from '../ContentfulApiCommand';
+export declare namespace ContentfulApi {
+    function process(request: NextRequest, NextResponse: typeof NextResponseType): Promise<NextResponseType<{
+        data: ContentfulApiCommand.GetAccessTokens.Result;
+    }> | NextResponseType<{
+        error: import("@nascentdigital/funnel-core").SerializedIsometricError;
+    }>>;
+}