@nascentdigital/funnel-cms 5.0.1 → 5.0.3

package/dist/contentful/ContentfulContentClient.js

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