@nascentdigital/funnel-cms 4.4.4

package/dist/api/AssetClient.d.ts

@@ -0,0 +1,53 @@
+import { FileType, RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { Pagination } from '../models';
+/**
+ * Provides access to (and management of) {@link File} related models.
+ */
+export interface AssetClient {
+    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>;
+}
+export declare namespace AssetClient {
+    namespace GetAssets {
+        type Args = {
+            brand: string;
+            fileType?: FileType | ReadonlyArray<FileType>;
+            scope?: Scope;
+            tags?: Schema.TagGroup.Data;
+            pagination: Pagination;
+        };
+        type Scope = Scope.Page | Scope.Collection;
+        namespace Scope {
+            type Page = {
+                target: 'page';
+                type: Schema.Page.Type;
+                groupId: Schema.Page.GroupId;
+            };
+            type Collection = {
+                target: 'collection';
+                type: Schema.Collection.Type;
+                groupId: Schema.Collection.GroupId;
+            };
+        }
+        type Result = Pagination.Paginated<Schema.Asset.Linked>;
+    }
+    namespace GetAsset {
+        type Args = Schema.Asset.Id;
+        type Result = Schema.Asset.Linked | undefined;
+    }
+    namespace CreateAsset {
+        type Args = Omit<Schema.AssetField.LinkedValue, 'id' | 'url'>;
+        type Result = Schema.Asset.Linked;
+    }
+    namespace UpdateAsset {
+        type Args = RequiredBy<Partial<Pick<Schema.AssetField.LinkedValue, 'id' | 'url' | 'name' | 'description' | 'scope' | 'tags' | 'metadata'>>, 'id'>;
+        type Result = Schema.Asset.Linked;
+    }
+    namespace DeleteAsset {
+        type Args = Schema.Asset.Id;
+        type Result = void;
+    }
+}

package/dist/api/AssetClient.js

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

package/dist/api/AssetUploadClient.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { AssetClient } from './AssetClient';
+import { IAssetApiClient } from './IAssetApiClient';
+export declare abstract class AssetUploadClient {
+    abstract onUpload(args: AssetUploadClient.OnUpload.Args): Promise<AssetUploadClient.OnUpload.Result>;
+}
+export declare namespace AssetUploadClient {
+    namespace OnUpload {
+        type Args = Omit<AssetClient.CreateAsset.Args, ''> & {
+            api: IAssetApiClient;
+            file: Blob;
+        };
+        type Result = Schema.Asset.Linked;
+    }
+    function get(): AssetUploadClient;
+    function set(client: AssetUploadClient): void;
+}

package/dist/api/AssetUploadClient.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetUploadClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class AssetUploadClient {
+}
+exports.AssetUploadClient = AssetUploadClient;
+// extension
+(function (AssetUploadClient) {
+    // methods
+    function get() {
+        // throw if config isn't bound
+        if (!_client) {
+            throw new funnel_core_1.IllegalStateError('Attempt to access AssetUploadClient before first call to AssetUploadClient.set()');
+        }
+        return _client;
+    }
+    AssetUploadClient.get = get;
+    function set(client) {
+        _client = client;
+    }
+    AssetUploadClient.set = set;
+})(AssetUploadClient || (exports.AssetUploadClient = AssetUploadClient = {}));
+// storage
+let _client = undefined;

package/dist/api/AuthClient.d.ts

@@ -0,0 +1,29 @@
+import { Tagged } from 'type-fest';
+import { User } from '../models';
+/**
+ * Provides authentication (and identity) apis.
+ */
+export interface AuthClient {
+    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>;
+}
+export declare namespace AuthClient {
+    type Credentials = {
+        email: string;
+        password: string;
+    };
+    type AccessToken = Tagged<string, 'funnel.AuthClient.AccessToken'>;
+    namespace Identify {
+        type Args = AccessToken;
+        type Result = User.Data | undefined;
+    }
+    namespace Login {
+        type Args = Credentials;
+        type Result = AccessToken;
+    }
+    namespace Authorize {
+        type Args = string;
+        type Result = AccessToken;
+    }
+}

package/dist/api/AuthClient.js

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

package/dist/api/ChangeSetClient.d.ts

@@ -0,0 +1,84 @@
+import { PartialBy, RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { Pagination } from '../models';
+/**
+ * Provides access to (and management of) {@link Schema.ChangeSet} related models.
+ */
+export interface ChangeSetClient {
+    /**
+     * Gets current `ChangeSet`, creating it if it doesn't exist.
+     */
+    current(args: ChangeSetClient.Current.Args): Promise<ChangeSetClient.Current.Result>;
+    /**
+     * Lists all changesets (current and historical) as rolled-up groups.
+     */
+    listGroups(args: ChangeSetClient.ListGroups.Args): Promise<ChangeSetClient.ListGroups.Result>;
+    /**
+     * Lists all current and historical `ChangeSet` entities.
+     */
+    list(args: ChangeSetClient.List.Args): Promise<ChangeSetClient.List.Result>;
+    /**
+     * Gets a specific `ChangeSet`, creating it if it doesn't exist.
+     */
+    get(args: ChangeSetClient.Get.Args): Promise<ChangeSetClient.Get.Result>;
+    /**
+     * Updates an existing `ChangeSet`.
+     */
+    update(args: ChangeSetClient.Update.Args): Promise<ChangeSetClient.Update.Result>;
+    /**
+     * Deletes a `ChangeSet`.
+     */
+    delete(args: ChangeSetClient.Delete.Args): Promise<ChangeSetClient.Delete.Result>;
+    /**
+     * Commits a `ChangeSet`.
+     */
+    commit(args: ChangeSetClient.Commit.Args): Promise<ChangeSetClient.Commit.Result>;
+    /**
+     * Reverts the specified changes in a `ChangeSet` OR all changes if no specific change ids are specified.
+     */
+    revert(args: ChangeSetClient.Revert.Args): Promise<ChangeSetClient.Revert.Result>;
+}
+export declare namespace ChangeSetClient {
+    namespace Current {
+        type Args = PartialBy<Pick<Schema.ChangeSet.Data, 'brand' | 'groupId'>, 'groupId'>;
+        type Result = Schema.ChangeSet.Data;
+    }
+    namespace ListGroups {
+        type Args = Pick<Schema.ChangeSet.Data, 'brand'>;
+        type Result = Schema.ChangeSet.Data.Grouped[];
+    }
+    namespace List {
+        type Scope = 'unpublished' | 'published' | 'all';
+        namespace Scope {
+            const values: ReadonlyArray<Scope>;
+            function parse(value: string): Scope;
+        }
+        type Args = PartialBy<Pick<Schema.ChangeSet.Data, 'brand' | 'groupId'>, 'groupId'> & {
+            scope?: Scope;
+            pagination: Pagination;
+        };
+        type Result = Pagination.Paginated<Schema.ChangeSet.Data>;
+    }
+    namespace Get {
+        type Args = Schema.ChangeSet.Id;
+        type Result = Schema.ChangeSet.Data;
+    }
+    namespace Update {
+        type Args = RequiredBy<Partial<Pick<Schema.ChangeSet.Data, 'id' | 'name' | 'changes' | 'publishedOn'>>, 'id'>;
+        type Result = Schema.ChangeSet.Data;
+    }
+    namespace Delete {
+        type Args = Schema.ChangeSet.Id;
+        type Result = boolean;
+    }
+    namespace Commit {
+        type Args = Schema.ChangeSet.Id;
+        type Result = Schema.ChangeSet.Data;
+    }
+    namespace Revert {
+        type Args = {
+            changeSetId: Schema.ChangeSet.Id;
+            changeIds?: ReadonlyArray<Schema.ChangeSet.Change.Id>;
+        };
+        type Result = Schema.ChangeSet.Data | false;
+    }
+}

package/dist/api/ChangeSetClient.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var ChangeSetClient;
+(function (ChangeSetClient) {
+    let List;
+    (function (List) {
+        let Scope;
+        (function (Scope) {
+            // values
+            Scope.values = [
+                'unpublished', 'published', 'all'
+            ];
+            // helpers
+            function parse(value) {
+                const normalizeValue = value.trim().toLowerCase();
+                switch (normalizeValue) {
+                    case 'unpublished':
+                    case 'published':
+                    case 'all':
+                        return normalizeValue;
+                    default:
+                        throw new funnel_core_1.ArgumentError(`Invalid scope: "${value}"`);
+                }
+            }
+            Scope.parse = parse;
+        })(Scope = List.Scope || (List.Scope = {}));
+    })(List = ChangeSetClient.List || (ChangeSetClient.List = {}));
+})(ChangeSetClient || (exports.ChangeSetClient = ChangeSetClient = {}));

package/dist/api/CollectionClient.d.ts

@@ -0,0 +1,187 @@
+import { Language, RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { Environment, Pagination } from '../models';
+/**
+ * Provides access to (and management of) {@link Collection} related models.
+ */
+export interface CollectionClient {
+    /**
+     * Fetches a count for each collection type for a given brand, including non-branded (or universal) collection
+     * instances.
+     */
+    getOverview(args: CollectionClient.GetOverview.Args): Promise<CollectionClient.GetOverview.Result>;
+    /**
+     * Lists the items within a collection, returning a short summary for each item (e.g. groupId, type, name, etc).
+     */
+    getItems(args: CollectionClient.GetItems.Args): Promise<CollectionClient.GetItems.Result>;
+    /**
+     * Find collections based on query.
+     * */
+    find(args: CollectionClient.Find.Args): Promise<CollectionClient.Find.Result>;
+    /**
+     * Fetches the details for a specific collection, including a group of all related collection models (if any) for the
+     * same groupId, OR `undefined` if no collection exists for the target.
+     */
+    getGroup(args: CollectionClient.GetGroup.Args): Promise<CollectionClient.GetGroup.Result>;
+    /**
+     * Fetches the details for a specific collection model for a given brand
+     */
+    get(args: CollectionClient.Get.Args): Promise<CollectionClient.Get.Result>;
+    /**
+     * Create a new collection.
+     */
+    create(args: CollectionClient.Create.Args): Promise<CollectionClient.Create.Result>;
+    /**
+     * Duplicate collection or collection's language
+     */
+    duplicate(args: CollectionClient.Duplicate.Args): Promise<CollectionClient.Duplicate.Result>;
+    /**
+     * Updates an existing collection.
+     */
+    update(args: CollectionClient.Update.Args): Promise<CollectionClient.Update.Result>;
+    /**
+     * Replaces an existing collection with a new value - paves over the existing collection.
+     * */
+    replace(args: CollectionClient.Replace.Args): Promise<CollectionClient.Replace.Result>;
+    /**
+     * Unpublishes a collection.
+     */
+    unpublish(args: CollectionClient.Unpublish.Args): Promise<CollectionClient.Unpublish.Result>;
+    /**
+     * Fetch items that depend on a collection
+     */
+    getDependants(args: CollectionClient.GetDependants.Args): Promise<CollectionClient.GetDependants.Result>;
+    /**
+     * Fetch items that a collection has dependencies on
+     */
+    getDependencies(args: CollectionClient.GetDependencies.Args): Promise<CollectionClient.GetDependencies.Result>;
+}
+export declare namespace CollectionClient {
+    namespace Query {
+        export type Paginated = Base & Criteria & WithPagination;
+        export type By<TCriteria extends Criteria.Key> = Base & RequiredBy<Criteria, TCriteria>;
+        export type ById = Base & {
+            id: Schema.Collection.Id;
+        };
+        export type ByGroupId = Base & {
+            groupId: Schema.Collection.GroupId;
+        };
+        export type ByBrand = Base & {
+            brand: string;
+        };
+        export type TagsMatch = 'any' | 'all';
+        type Base = {
+            version: Environment;
+        };
+        type WithPagination = {
+            pagination: Pagination;
+        };
+        export type Criteria = {
+            groupId?: Schema.Collection.GroupId;
+            brand?: string;
+            type?: Schema.Collection.Type | Schema.Collection.Type[];
+            name?: string;
+            language?: Language;
+            tags?: Schema.Tag.Data[];
+            tagsMatch?: TagsMatch;
+        };
+        export namespace Criteria {
+            type Key = keyof Criteria;
+        }
+        export {};
+    }
+    type Update = {
+        id: Schema.Collection.Id;
+        errors: boolean;
+        updates: ReadonlyArray<Schema.Collection.Update>;
+    };
+    namespace Replace {
+        type Args = {
+            updatedCollection: Schema.Collection.Data;
+            version: Environment;
+            skipSync?: boolean;
+        };
+        type Result = Schema.Collection.Data;
+    }
+    namespace GetOverview {
+        type Args = Query.ByBrand;
+        type Result = Item[];
+        type Item = {
+            type: Schema.Collection.Type;
+            total: number;
+        };
+    }
+    namespace GetItems {
+        type Args = Query.ByBrand & {
+            type: Schema.Collection.Type;
+            language: Language;
+            tags?: Schema.Tag.Data[];
+        };
+        type Result = Item[];
+        type Item = {
+            id: Schema.Collection.Id;
+            groupId: Schema.Collection.GroupId;
+            type: Schema.Collection.Type;
+            name: string;
+            refs: Record<Language, Schema.Collection.Data.AsRef>;
+        };
+    }
+    namespace Find {
+        type Args = Query.Paginated;
+        type Result = Pagination.Paginated<Schema.Collection.Data>;
+    }
+    namespace GetGroup {
+        type Args = Query.ByGroupId & {
+            type: Schema.Collection.Type;
+            brand?: string;
+            language?: Language;
+        };
+        type Result = Schema.Collection.Data.AsGroup | undefined;
+    }
+    namespace Get {
+        type Args = Query.ById;
+        type Result = Schema.Collection.Data | undefined;
+    }
+    namespace Create {
+        type Args = NewArgs | NewLanguageArgs;
+        type NewArgs = Schema.Collection.Data.AsNew;
+        type NewLanguageArgs = Schema.Collection.Data.AsNewLanguage;
+        type Result = Schema.Collection.Data.AsGroup;
+    }
+    namespace Duplicate {
+        type TargetCollection = 'current' | 'new';
+        export type Args = {
+            source: Schema.Collection.Id;
+            targetCollection: TargetCollection;
+            targetLanguage: Language;
+        };
+        export type Result = Schema.Collection.Data.AsGroup;
+        export {};
+    }
+    namespace Update {
+        type Args = Update;
+        type Result = Schema.Collection.Data;
+    }
+    namespace Unpublish {
+        type Args = Schema.Collection.Id;
+        type Result = boolean;
+    }
+    namespace GetDependants {
+        type Args = {
+            id: Schema.Collection.Id;
+            version: Environment;
+        };
+        type Result = {
+            pages: Schema.Page.Data.AsLink[];
+            collections: Schema.Collection.Data.AsRef[];
+        };
+    }
+    namespace GetDependencies {
+        type Args = {
+            id: Schema.Collection.Id;
+            version: Environment;
+        };
+        type Result = {
+            collections: Schema.Collection.Data.AsRef[];
+        };
+    }
+}

package/dist/api/CollectionClient.js

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

package/dist/api/ContentClient.d.ts

@@ -0,0 +1,43 @@
+import { AuthClient } from './AuthClient';
+import { CollectionClient } from './CollectionClient';
+import { AssetClient } from './AssetClient';
+import { ChangeSetClient } from './ChangeSetClient';
+import { PageClient } from './PageClient';
+import { SiteConfigClient } from './SiteConfigClient';
+import { UpgradeClient } from './UpgradeClient';
+import { UserClient } from './UserClient';
+export interface ContentClient {
+    token: AuthClient.AccessToken;
+    clearToken(): void;
+    readonly auth: AuthClient;
+    readonly changeSets: ChangeSetClient;
+    readonly files: AssetClient;
+    readonly pages: PageClient;
+    readonly collections: CollectionClient;
+    readonly upgrade: UpgradeClient;
+    readonly users: UserClient;
+    readonly siteConfig: SiteConfigClient;
+}
+export declare namespace ContentClient {
+    interface Factory {
+        /**
+         * Returns an authenticated {@link ContentClient} for usage as a service account.
+         * This account should never be used for handling editor requests, since it has full
+         * access and privileges.
+         *
+         * This instance is typically shared.
+         */
+        forServer(): ContentClient;
+        /**
+         * Returns a new unauthenticated {@link ContentClient} for proxying actions on behalf of
+         * a content editor user.  This client should **never** be stored or shared beyond a single request.
+         */
+        forEditor(): ContentClient;
+    }
+    namespace Factory {
+        function get(): Factory;
+        function set(factory: Factory): void;
+    }
+    function forServer(): ContentClient;
+    function forEditor(): ContentClient;
+}

package/dist/api/ContentClient.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var ContentClient;
+(function (ContentClient) {
+    let Factory;
+    (function (Factory) {
+        function get() {
+            // throw if config isn't bound
+            if (!_factory) {
+                throw new funnel_core_1.IllegalStateError('Attempt to access ContentClient.Factory before first call to ContentClient.Factory.set()');
+            }
+            return _factory;
+        }
+        Factory.get = get;
+        function set(factory) {
+            _factory = factory;
+        }
+        Factory.set = set;
+    })(Factory = ContentClient.Factory || (ContentClient.Factory = {}));
+    // methods (for convenience)
+    function forServer() {
+        return Factory.get().forServer();
+    }
+    ContentClient.forServer = forServer;
+    function forEditor() {
+        return Factory.get().forEditor();
+    }
+    ContentClient.forEditor = forEditor;
+})(ContentClient || (exports.ContentClient = ContentClient = {}));
+// storage
+let _factory = undefined;

package/dist/api/IAssetApiClient.d.ts

@@ -0,0 +1,9 @@
+import { AssetClient } from './AssetClient';
+export interface IAssetApiClient {
+    readonly token: string | undefined;
+    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/api/IAssetApiClient.js

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