@nascentdigital/funnel-cms 5.0.1 → 5.0.2

package/dist/contentful/ContentfulAccess.d.ts

@@ -0,0 +1,19 @@
+import { User } from '../models';
+export declare class ContentfulAccess {
+    readonly userId: User.Id;
+    readonly token: string;
+    readonly expiry: number;
+    constructor(args: ContentfulAccess.ConstructorArgs);
+    get isExpired(): boolean;
+    get data(): ContentfulAccess.Data;
+    static new(userId: string): ContentfulAccess;
+}
+export declare namespace ContentfulAccess {
+    type Data = {
+        userId: string;
+        token: string;
+        expiry: number;
+    };
+    type ConstructorArgs = Data;
+    const tokenLifetimeMs: number;
+}

package/dist/contentful/ContentfulAccess.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulAccess = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const uuid = __importStar(require("uuid"));
+// class
+class ContentfulAccess {
+    constructor(args) {
+        // initialize instance variables
+        this.userId = args.userId;
+        this.token = args.token;
+        this.expiry = args.expiry || 0;
+    }
+    get isExpired() {
+        return Date.now() > this.expiry;
+    }
+    get data() {
+        const { userId, token, expiry } = this;
+        return { userId, token, expiry };
+    }
+    static new(userId) {
+        return new ContentfulAccess({
+            userId,
+            token: uuid.v4(),
+            expiry: Date.now() + ContentfulAccess.tokenLifetimeMs
+        });
+    }
+}
+exports.ContentfulAccess = ContentfulAccess;
+// extension
+(function (ContentfulAccess) {
+    // constants
+    ContentfulAccess.tokenLifetimeMs = funnel_core_1.Duration.toMilliseconds('30s');
+})(ContentfulAccess || (exports.ContentfulAccess = ContentfulAccess = {}));

package/dist/contentful/ContentfulApiCommand.d.ts

@@ -0,0 +1,21 @@
+export type ContentfulApiCommand = ContentfulApiCommand.GetAccessTokens;
+export declare namespace ContentfulApiCommand {
+    type Type = 'GetAccessTokens';
+    namespace Type {
+        const values: ReadonlyArray<Type>;
+    }
+    type Spec<TCommand extends Type = Type> = {
+        type: TCommand;
+        userId: string;
+        token: string;
+    };
+    type GetAccessTokens = Spec<'GetAccessTokens'>;
+    namespace GetAccessTokens {
+        type Result = {
+            deliveryAccessToken: string;
+            previewAccessToken: string;
+        };
+    }
+    type Result = GetAccessTokens.Result;
+    function filter(json: any): json is ContentfulApiCommand;
+}

package/dist/contentful/ContentfulApiCommand.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulApiCommand = void 0;
+var ContentfulApiCommand;
+(function (ContentfulApiCommand) {
+    let Type;
+    (function (Type) {
+        Type.values = [
+            'GetAccessTokens'
+        ];
+    })(Type = ContentfulApiCommand.Type || (ContentfulApiCommand.Type = {}));
+    // helpers
+    function filter(json) {
+        return !!json && typeof json === 'object' && !Array.isArray(json)
+            && 'type' in json && typeof json.type === 'string' && Type.values.includes(json.type)
+            && 'userId' in json && typeof json.userId === 'string'
+            && 'token' in json && typeof json.token === 'string';
+    }
+    ContentfulApiCommand.filter = filter;
+})(ContentfulApiCommand || (exports.ContentfulApiCommand = ContentfulApiCommand = {}));

package/dist/contentful/ContentfulApiResponse.d.ts

@@ -0,0 +1,10 @@
+import { SerializedIsometricError } from '@nascentdigital/funnel-core';
+export type ContentfulApiResponse<T> = ContentfulApiResponse.Data<T> | ContentfulApiResponse.Error;
+export declare namespace ContentfulApiResponse {
+    type Data<T> = {
+        data: T;
+    };
+    type Error = {
+        error: SerializedIsometricError;
+    };
+}

package/dist/contentful/ContentfulApiResponse.js

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

package/dist/contentful/ContentfulAssetClient.d.ts

@@ -0,0 +1,11 @@
+import { AssetClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+export declare class ContentfulAssetClient implements AssetClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    getAssets(args: AssetClient.GetAssets.Args): Promise<AssetClient.GetAssets.Result>;
+    getAsset(args: AssetClient.GetAsset.Args): Promise<AssetClient.GetAsset.Result>;
+    createAsset(args: AssetClient.CreateAsset.Args): Promise<AssetClient.CreateAsset.Result>;
+    updateAsset(args: AssetClient.UpdateAsset.Args): Promise<AssetClient.UpdateAsset.Result>;
+    deleteAsset(args: AssetClient.DeleteAsset.Args): Promise<AssetClient.DeleteAsset.Result>;
+}

package/dist/contentful/ContentfulAssetClient.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulAssetClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ContentfulAssetClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    getAssets(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    getAsset(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    createAsset(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    updateAsset(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    deleteAsset(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulAssetClient = ContentfulAssetClient;

package/dist/contentful/ContentfulAuthClient.d.ts

@@ -0,0 +1,9 @@
+import { AuthClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+export declare class ContentfulAuthClient implements AuthClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    identify(args: AuthClient.Identify.Args): Promise<AuthClient.Identify.Result>;
+    login(args: AuthClient.Login.Args): Promise<AuthClient.Login.Result>;
+    authorize(args: AuthClient.Authorize.Args): Promise<AuthClient.Authorize.Result>;
+}

package/dist/contentful/ContentfulAuthClient.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulAuthClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ContentfulAuthClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    identify(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    login(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    authorize(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulAuthClient = ContentfulAuthClient;

package/dist/contentful/ContentfulChangeSetClient.d.ts

@@ -0,0 +1,14 @@
+import { ChangeSetClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+export declare class ContentfulChangeSetClient implements ChangeSetClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    current(args: ChangeSetClient.Current.Args): Promise<ChangeSetClient.Current.Result>;
+    listGroups(args: ChangeSetClient.ListGroups.Args): Promise<ChangeSetClient.ListGroups.Result>;
+    list(args: ChangeSetClient.List.Args): Promise<ChangeSetClient.List.Result>;
+    get(args: ChangeSetClient.Get.Args): Promise<ChangeSetClient.Get.Result>;
+    update(args: ChangeSetClient.Update.Args): Promise<ChangeSetClient.Update.Result>;
+    delete(args: ChangeSetClient.Delete.Args): Promise<ChangeSetClient.Delete.Result>;
+    commit(args: ChangeSetClient.Commit.Args): Promise<ChangeSetClient.Commit.Result>;
+    revert(args: ChangeSetClient.Revert.Args): Promise<ChangeSetClient.Revert.Result>;
+}

package/dist/contentful/ContentfulChangeSetClient.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulChangeSetClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ContentfulChangeSetClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    current(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    listGroups(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    list(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    get(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    delete(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    commit(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    revert(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulChangeSetClient = ContentfulChangeSetClient;

package/dist/contentful/ContentfulCollectionClient.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { CollectionClient } from '../api';
+import { IContentfulContentClient } from './IContentfulContentClient';
+import { ContentfulCollectionData } from './models';
+export declare class ContentfulCollectionClient implements CollectionClient {
+    readonly cms: IContentfulContentClient;
+    constructor(cms: IContentfulContentClient);
+    getOverview(args: CollectionClient.GetOverview.Args): Promise<CollectionClient.GetOverview.Result>;
+    getItems(args: CollectionClient.GetItems.Args): Promise<CollectionClient.GetItems.Result>;
+    find(args: CollectionClient.Find.Args): Promise<CollectionClient.Find.Result>;
+    getGroup(args: CollectionClient.GetGroup.Args): Promise<ContentfulCollectionClient.GetGroup.Result>;
+    get(args: CollectionClient.Get.Args): Promise<ContentfulCollectionClient.Get.Result>;
+    create(args: CollectionClient.Create.Args): Promise<CollectionClient.Create.Result>;
+    duplicate(args: CollectionClient.Duplicate.Args): Promise<CollectionClient.Duplicate.Result>;
+    update(args: CollectionClient.Update.Args): Promise<ContentfulCollectionClient.Update.Result>;
+    replace(args: CollectionClient.Replace.Args): Promise<CollectionClient.Replace.Result>;
+    unpublish(args: CollectionClient.Unpublish.Args): Promise<CollectionClient.Unpublish.Result>;
+    getDependants(args: CollectionClient.GetDependants.Args): Promise<CollectionClient.GetDependants.Result>;
+    getDependencies(args: CollectionClient.GetDependencies.Args): Promise<CollectionClient.GetDependencies.Result>;
+}
+export declare namespace ContentfulCollectionClient {
+    type FlattenedCollectionData = Omit<Schema.Collection.FlattenedData, 'data'> & {
+        data: ContentfulCollectionData.ForSchema;
+    };
+    namespace GetGroup {
+        type Result = (Omit<Schema.Collection.Data.AsGroup, 'collection'> & {
+            collection?: FlattenedCollectionData;
+        }) | undefined;
+    }
+    namespace Get {
+        type Result = FlattenedCollectionData | undefined;
+    }
+    namespace Update {
+        type Result = Omit<CollectionClient.Update.Result, 'collection'> & {
+            collection?: FlattenedCollectionData;
+        };
+    }
+}

package/dist/contentful/ContentfulCollectionClient.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCollectionClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const models_1 = require("./models");
+// class
+class ContentfulCollectionClient {
+    constructor(cms) {
+        this.cms = cms;
+    }
+    async getOverview(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getItems(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async find(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getGroup(args) {
+        var _a, _b;
+        // fetch items (bail if there are no instances
+        const { cms } = this;
+        const { entries } = await cms.getEntries(Object.assign({ content_type: models_1.ContentfulCollectionData.contentType, version: args.version, select: getCollectionSelect(funnel_core_1.Schema.Collection.Data.AsGroup.Instance.props) }, getCollectionQueryParams(args)));
+        // bail if no items
+        if (entries.length === 0) {
+            return undefined;
+        }
+        // create group
+        const { type, brand, language, groupId, version } = args;
+        const schema = funnel_core_1.Schema.Site.getCollection(type);
+        const instances = entries.map(entry => models_1.ContentfulCollectionData.deserialize(entry, funnel_core_1.Schema.Collection.Data.AsGroup.Instance.props));
+        const result = {
+            group: {
+                type,
+                brand,
+                groupId,
+                name: (_b = (_a = funnel_core_1.ArrayUtils.first(entries)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : schema.name,
+                instances
+            }
+        };
+        // add language if it exists as an instance
+        const target = instances.find(item => item.language === language);
+        if (target) {
+            // get collection
+            result.collection = await this.get({ version, id: target.id });
+            // sync name if collection was found
+            if (result.collection) {
+                result.group.name = result.collection.data.name;
+            }
+        }
+        // return result
+        return result;
+    }
+    async get(args) {
+        // fetch entry
+        const { cms } = this;
+        const { entry, references } = await cms.getEntry({
+            entryId: args.id,
+            version: args.version
+        });
+        return Object.assign({ data: models_1.ContentfulCollectionData.deserialize(entry) }, models_1.ContentfulCollectionData.deserializeRefs(references));
+    }
+    async create(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async duplicate(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async replace(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getDependants(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getDependencies(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.ContentfulCollectionClient = ContentfulCollectionClient;
+// helpers
+function getCollectionQueryParams(query) {
+    // build filters
+    const { ids = [], groupId, brand, type, slug, 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 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 getCollectionSelect(props) {
+    // build select
+    const select = new Set(['sys']);
+    for (const prop of props) {
+        switch (prop) {
+            // parity
+            case 'groupId':
+            case 'brand':
+            case 'type':
+            case 'language':
+            case 'name':
+            case 'tags':
+            case 'state':
+            case 'errors':
+            case 'publishedOn':
+                select.add(`fields.${prop}`);
+                break;
+            // links
+            case 'files':
+            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/ContentfulContentClient.d.ts

@@ -0,0 +1,59 @@
+import { CMAClient, KnownAppSDK } from '@contentful/app-sdk';
+import { PlainClientAPI } from 'contentful-management';
+import { AuthClient, ContentClient } from '../api';
+import { User } from '../models';
+import { ContentfulAssetClient } from './ContentfulAssetClient';
+import { ContentfulAuthClient } from './ContentfulAuthClient';
+import { ContentfulChangeSetClient } from './ContentfulChangeSetClient';
+import { ContentfulCollectionClient } from './ContentfulCollectionClient';
+import { ContentfulPageClient } from './ContentfulPageClient';
+import { ContentfulSiteConfigClient } from './ContentfulSiteConfigClient';
+import { ContentfulUpgradeClient } from './ContentfulUpgradeClient';
+import { ContentfulUserClient } from './ContentfulUserClient';
+import { IContentfulContentClient } from './IContentfulContentClient';
+import { ContentfulData } from './models';
+export declare class ContentfulContentClient implements ContentClient, IContentfulContentClient {
+    readonly user: User;
+    readonly locale: string;
+    readonly deliveryAccessToken: string;
+    readonly previewAccessToken: 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 upgrade: ContentfulUpgradeClient;
+    readonly users: ContentfulUserClient;
+    readonly siteConfig: ContentfulSiteConfigClient;
+    constructor(args: ContentfulContentClient.ConstructorArgs);
+    get token(): AuthClient.AccessToken;
+    set token(token: AuthClient.AccessToken);
+    clearToken(): void;
+    createEntry<T extends ContentfulData>(contentTypeId: string, entry: ContentfulData.Draft<T>): Promise<T>;
+    getEntry<TEntry extends ContentfulData>({ entryId, includeLinks, version }: IContentfulContentClient.GetEntry.Args<TEntry>): Promise<IContentfulContentClient.GetEntry.Result<TEntry>>;
+    getEntries<TEntry extends ContentfulData>({ limit, version, includeLinks, ...query }: IContentfulContentClient.GetEntries.Args<TEntry>): Promise<IContentfulContentClient.GetEntries.Result<TEntry>>;
+    static forEditor(sdk: KnownAppSDK): Promise<ContentfulContentClient>;
+}
+export declare namespace ContentfulContentClient {
+    type ConstructorArgs = ConstructorArgs.ForServer | ConstructorArgs.ForEditor;
+    namespace ConstructorArgs {
+        type ForServer = {
+            locale: string;
+            accessToken: string;
+            spaceId: string;
+            environment: string;
+            deliveryAccessToken: string;
+            previewAccessToken: string;
+        };
+        type ForEditor = {
+            sdk: KnownAppSDK;
+            deliveryAccessToken: string;
+            previewAccessToken: string;
+        };
+        function isForServer(args: ConstructorArgs): args is ForServer;
+        function isForEditor(args: ConstructorArgs): args is ForEditor;
+    }
+}