@nascentdigital/funnel-cms 4.4.4

package/dist/errors/TranslateReferencesError.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslateReferencesError = void 0;
+const CMSError_1 = require("./CMSError");
+// class
+class TranslateReferencesError extends CMSError_1.CMSError {
+    constructor(args) {
+        // construct base
+        super(args);
+        // initialize instance variables
+        this.targetLanguage = args.targetLanguage;
+        this.untranslatedPages = args.untranslatedPages;
+        this.untranslatedCollections = args.untranslatedCollections;
+    }
+    serialize() {
+        const { targetLanguage, untranslatedPages, untranslatedCollections } = this;
+        return Object.assign(Object.assign({}, super.serialize()), { targetLanguage,
+            untranslatedPages,
+            untranslatedCollections });
+    }
+}
+exports.TranslateReferencesError = TranslateReferencesError;

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './LinkedDependantsError';
+export * from './LockdownError';
+export * from './SlugValidationError';
+export * from './TranslateReferencesError';

package/dist/errors/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const CMSErrors_1 = require("./CMSErrors");
+// exports
+__exportStar(require("./LinkedDependantsError"), exports);
+__exportStar(require("./LockdownError"), exports);
+__exportStar(require("./SlugValidationError"), exports);
+__exportStar(require("./TranslateReferencesError"), exports);
+// bind module
+funnel_core_1.IsometricErrorUtils.registerModule(CMSErrors_1.CMSErrors);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './errors';
+export * from './models';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./models"), exports);

package/dist/models/Entity.d.ts

@@ -0,0 +1,14 @@
+import { JsonObject } from 'type-fest';
+export type Entity<TId = string, TInternal extends JsonObject = JsonObject> = {
+    __internal?: TInternal;
+    id: TId;
+};
+export declare namespace Entity {
+    type Id = string | number;
+    type Extend<TEntity extends Extensible, TInternal extends JsonObject = JsonObject> = TEntity & {
+        __internal: TInternal;
+    };
+    interface Extensible<TId extends Id = Id> {
+        id: TId;
+    }
+}

package/dist/models/Entity.js

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

package/dist/models/Environment.d.ts

@@ -0,0 +1 @@
+export type Environment = 'draft' | 'published';

package/dist/models/Environment.js

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

package/dist/models/Pagination.d.ts

@@ -0,0 +1,20 @@
+export type Pagination = Pagination.Paging | Pagination.All;
+export declare namespace Pagination {
+    type Paging = {
+        page: number;
+        pageSize: number;
+    };
+    namespace Paging {
+        function filter(value: Pagination): value is Paging;
+    }
+    type All = 'all';
+    namespace All {
+        function filter(value: Pagination): value is All;
+    }
+    type Paginated<T> = {
+        items: T[];
+        page: number;
+        pageCount: number;
+        totalItemCount: number;
+    };
+}

package/dist/models/Pagination.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pagination = void 0;
+// extension
+var Pagination;
+(function (Pagination) {
+    let Paging;
+    (function (Paging) {
+        function filter(value) {
+            return typeof value === 'object' && 'page' in value;
+        }
+        Paging.filter = filter;
+    })(Paging = Pagination.Paging || (Pagination.Paging = {}));
+    let All;
+    (function (All) {
+        function filter(value) {
+            return value === 'all';
+        }
+        All.filter = filter;
+    })(All = Pagination.All || (Pagination.All = {}));
+})(Pagination || (exports.Pagination = Pagination = {}));

package/dist/models/Privilege.d.ts

@@ -0,0 +1,57 @@
+export type Privilege = {
+    readonly id: Privilege.Id;
+    readonly domain: Privilege.Domain;
+    readonly name: string;
+    readonly description: string;
+};
+export declare namespace Privilege {
+    type Id = Site.Id | User.Id | ChangeSet.Id | Content.Id;
+    type DomainId = Site.DomainId | User.DomainId | ChangeSet.DomainId | Content.DomainId;
+    type Domain = {
+        id: DomainId;
+        name: string;
+        description: string;
+    };
+    namespace Site {
+        type Id = 'site.update';
+        type DomainId = 'site';
+        const domain: Domain;
+        const Update: Privilege;
+        const all: ReadonlyArray<Privilege>;
+    }
+    namespace User {
+        type Id = 'user.view' | 'user.create' | 'user.update' | 'user.delete' | 'user.passwordReset';
+        type DomainId = 'user';
+        const domain: Domain;
+        const View: Privilege;
+        const Create: Privilege;
+        const Update: Privilege;
+        const Delete: Privilege;
+        const PasswordReset: Privilege;
+        const all: ReadonlyArray<Privilege>;
+    }
+    namespace ChangeSet {
+        type Id = 'changeset.view' | 'changeset.create' | 'changeset.update' | 'changeset.delete';
+        type DomainId = 'changeset';
+        const domain: Domain;
+        const View: Privilege;
+        const Create: Privilege;
+        const Update: Privilege;
+        const Delete: Privilege;
+        const all: ReadonlyArray<Privilege>;
+    }
+    namespace Content {
+        type Id = 'content.view' | 'content.create' | 'content.update' | 'content.publish' | 'content.unpublish' | 'content.discard';
+        type DomainId = 'content';
+        const domain: Domain;
+        const View: Privilege;
+        const Create: Privilege;
+        const Update: Privilege;
+        const Publish: Privilege;
+        const Unpublish: Privilege;
+        const Discard: Privilege;
+        const edit: ReadonlyArray<Privilege>;
+        const all: ReadonlyArray<Privilege>;
+    }
+    const all: ReadonlyArray<Privilege>;
+}

package/dist/models/Privilege.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Privilege = void 0;
+// extension
+var Privilege;
+(function (Privilege) {
+    // site management
+    let Site;
+    (function (Site) {
+        // domain
+        Site.domain = {
+            id: 'site',
+            name: 'Site management',
+            description: 'Management of CMS/Site settings'
+        };
+        // privileges
+        Site.Update = {
+            id: 'site.update',
+            domain: Site.domain,
+            name: 'Update site',
+            description: 'Can make changes to the site/cms'
+        };
+        // all
+        Site.all = [Site.Update];
+    })(Site = Privilege.Site || (Privilege.Site = {}));
+    // user management
+    let User;
+    (function (User) {
+        // domain
+        User.domain = {
+            id: 'user',
+            name: 'User management',
+            description: 'Management of who can access the CMS'
+        };
+        // privileges
+        User.View = {
+            id: 'user.view',
+            domain: User.domain,
+            name: 'View users',
+            description: 'Can view basic details of users'
+        };
+        User.Create = {
+            id: 'user.create',
+            domain: User.domain,
+            name: 'Create users',
+            description: 'Can create users that are at/below their role'
+        };
+        User.Update = {
+            id: 'user.update',
+            domain: User.domain,
+            name: 'Update users',
+            description: 'Can update users that are at/below their role'
+        };
+        User.Delete = {
+            id: 'user.delete',
+            domain: User.domain,
+            name: 'Delete users',
+            description: 'Can delete users that are at/below their role'
+        };
+        User.PasswordReset = {
+            id: 'user.passwordReset',
+            domain: User.domain,
+            name: 'Reset password',
+            description: 'Can reset passwords of users that are at/below their role'
+        };
+        // all
+        User.all = [User.View, User.Create, User.Update, User.Delete, User.PasswordReset];
+    })(User = Privilege.User || (Privilege.User = {}));
+    // changeset management
+    let ChangeSet;
+    (function (ChangeSet) {
+        // domain
+        ChangeSet.domain = {
+            id: 'changeset',
+            name: 'Changeset management',
+            description: 'Access of publishing, unpublishing, and reverting content changes within the CMS'
+        };
+        // privileges
+        ChangeSet.View = {
+            id: 'changeset.view',
+            domain: ChangeSet.domain,
+            name: 'View changeset',
+            description: 'Can view changesets (current and historical)'
+        };
+        ChangeSet.Create = {
+            id: 'changeset.create',
+            domain: ChangeSet.domain,
+            name: 'Create changesets',
+            description: 'Can create a "named" changeset for parallel updates'
+        };
+        ChangeSet.Update = {
+            id: 'changeset.update',
+            domain: ChangeSet.domain,
+            name: 'Update changesets',
+            description: 'Can modify existing changesets (e.g. renaming it, moving items into it, etc.)'
+        };
+        ChangeSet.Delete = {
+            id: 'changeset.delete',
+            domain: ChangeSet.domain,
+            name: 'Delete changesets',
+            description: 'Can delete a "named" changeset (moving changes to the global changeset)'
+        };
+        // all
+        ChangeSet.all = [ChangeSet.View, ChangeSet.Create, ChangeSet.Update, ChangeSet.Delete];
+    })(ChangeSet = Privilege.ChangeSet || (Privilege.ChangeSet = {}));
+    // content management
+    let Content;
+    (function (Content) {
+        // domain
+        Content.domain = {
+            id: 'content',
+            name: 'Content management',
+            description: 'Management of CMS content'
+        };
+        // privileges
+        Content.View = {
+            id: 'content.view',
+            domain: Content.domain,
+            name: 'View content',
+            description: 'Can view pages, collections, and assets'
+        };
+        Content.Create = {
+            id: 'content.create',
+            domain: Content.domain,
+            name: 'Create content',
+            description: 'Can create new pages/collections and upload new assets'
+        };
+        Content.Update = {
+            id: 'content.update',
+            domain: Content.domain,
+            name: 'Update content',
+            description: 'Can update existing pages/collections'
+        };
+        Content.Publish = {
+            id: 'content.publish',
+            domain: Content.domain,
+            name: 'Publish content',
+            description: 'Can publish content into production'
+        };
+        Content.Unpublish = {
+            id: 'content.unpublish',
+            domain: Content.domain,
+            name: 'Unpublish content',
+            description: 'Can unpublish production content, moving it to a draft or archived state'
+        };
+        Content.Discard = {
+            id: 'content.discard',
+            domain: Content.domain,
+            name: 'Discard content',
+            description: 'Can discard draft page/collection changes to the last published value'
+        };
+        // all
+        Content.edit = [Content.View, Content.Create, Content.Update, Content.Discard];
+        Content.all = [Content.View, Content.Create, Content.Update, Content.Publish, Content.Unpublish, Content.Discard];
+    })(Content = Privilege.Content || (Privilege.Content = {}));
+    // all (cross domain)
+    Privilege.all = [
+        ...Site.all,
+        ...User.all,
+        ...ChangeSet.all,
+        ...Content.all
+    ];
+})(Privilege || (exports.Privilege = Privilege = {}));

package/dist/models/Role.d.ts

@@ -0,0 +1,33 @@
+import { Privilege } from './Privilege';
+export declare class Role {
+    readonly id: Role.Id;
+    readonly groupName: string;
+    readonly name: string;
+    readonly description: string;
+    readonly privileges: ReadonlyArray<Privilege>;
+    readonly privilegeIds: ReadonlySet<Privilege.Id>;
+    constructor(args: Role.ConstructorArgs);
+    has(...privileges: Privilege.Id[]): boolean;
+    hasAny(...privileges: Privilege.Id[]): boolean;
+    compareTo(thatRaw: Role | Role.Id): number;
+}
+export declare namespace Role {
+    type Id = 'owner' | 'admin' | 'manager' | 'editor' | 'viewer' | 'public';
+    namespace Id {
+        const values: ReadonlyArray<Id>;
+    }
+    const Owner: Role;
+    const Admin: Role;
+    const Manager: Role;
+    const Editor: Role;
+    const Viewer: Role;
+    const Public: Role;
+    function fromId(roleId: Role.Id): Role;
+    type ConstructorArgs = {
+        id: Id;
+        groupName: string;
+        name: string;
+        description: string;
+        privileges: ReadonlyArray<Privilege>;
+    };
+}

package/dist/models/Role.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+const Privilege_1 = require("./Privilege");
+// class
+class Role {
+    constructor(args) {
+        this.id = args.id;
+        this.groupName = args.groupName;
+        this.name = args.name;
+        this.description = args.description;
+        this.privileges = args.privileges;
+        this.privilegeIds = new Set(args.privileges.map(({ id }) => id));
+    }
+    has(...privileges) {
+        const { privilegeIds } = this;
+        return privileges.every(privilegeId => privilegeIds.has(privilegeId));
+    }
+    hasAny(...privileges) {
+        const { privilegeIds } = this;
+        return privileges.some(privilegeId => privilegeIds.has(privilegeId));
+    }
+    compareTo(thatRaw) {
+        // coerce
+        const that = typeof thatRaw === 'string'
+            ? Role.fromId(thatRaw)
+            : thatRaw;
+        // compare
+        const thisIndex = Role.Id.values.indexOf(this.id);
+        const thatIndex = Role.Id.values.indexOf(that.id);
+        return thisIndex === thatIndex
+            ? 0
+            : thisIndex < thatIndex
+                ? -1
+                : 1;
+    }
+}
+exports.Role = Role;
+// extension
+(function (Role) {
+    let Id;
+    (function (Id) {
+        Id.values = ['owner', 'admin', 'manager', 'editor', 'viewer', 'public'];
+    })(Id = Role.Id || (Role.Id = {}));
+    // role definitions
+    Role.Owner = new Role({
+        id: 'owner',
+        groupName: 'Owners',
+        name: 'Owner',
+        description: 'A super-admin with access to everything',
+        privileges: Privilege_1.Privilege.all
+    });
+    Role.Admin = new Role({
+        id: 'admin',
+        groupName: 'Admins',
+        name: 'Admin',
+        description: 'Full access, but cannot create/delete owners OR configure site',
+        privileges: [
+            ...Privilege_1.Privilege.User.all,
+            ...Privilege_1.Privilege.ChangeSet.all,
+            ...Privilege_1.Privilege.Content.all
+        ]
+    });
+    Role.Manager = new Role({
+        id: 'manager',
+        groupName: 'Managers',
+        name: 'Manager',
+        description: 'Can manage/publish content, but not manage users',
+        privileges: [
+            ...Privilege_1.Privilege.ChangeSet.all,
+            ...Privilege_1.Privilege.Content.all
+        ]
+    });
+    Role.Editor = new Role({
+        id: 'editor',
+        groupName: 'Editors',
+        name: 'Editor',
+        description: 'Can manage content, but not publish content or manage users',
+        privileges: [
+            ...Privilege_1.Privilege.Content.edit
+        ]
+    });
+    Role.Viewer = new Role({
+        id: 'viewer',
+        groupName: 'Viewers',
+        name: 'Viewer',
+        description: 'Can explore, but not change content',
+        privileges: [
+            Privilege_1.Privilege.ChangeSet.View,
+            Privilege_1.Privilege.Content.View
+        ]
+    });
+    Role.Public = new Role({
+        id: 'public',
+        groupName: 'Public',
+        name: 'Public',
+        description: 'Has no access to the system',
+        privileges: []
+    });
+    // helpers
+    function fromId(roleId) {
+        switch (roleId) {
+            case 'owner':
+                return Role.Owner;
+            case 'admin':
+                return Role.Admin;
+            case 'manager':
+                return Role.Manager;
+            case 'editor':
+                return Role.Editor;
+            case 'viewer':
+                return Role.Viewer;
+            default:
+                return Role.Public;
+        }
+    }
+    Role.fromId = fromId;
+})(Role || (exports.Role = Role = {}));

package/dist/models/SiteConfig.d.ts

@@ -0,0 +1,14 @@
+import { RequiredBy } from '@nascentdigital/funnel-core';
+import { Tagged } from 'type-fest';
+export declare namespace SiteConfig {
+    type Id = Tagged<string, 'SiteConfig.Id'>;
+    type Data = {
+        id: Id;
+        brand: string;
+        lockdownEditor: boolean;
+    };
+    namespace Data {
+        type AsDraft = Omit<Partial<Data>, 'id'>;
+        type Update = RequiredBy<Partial<Data>, 'id'>;
+    }
+}

package/dist/models/SiteConfig.js

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

package/dist/models/Upgrade.d.ts

@@ -0,0 +1,40 @@
+import { Tagged } from 'type-fest';
+export declare namespace Upgrade {
+    type Version = Tagged<number, 'funnel.Upgrade.Version'>;
+    type Status = Status.Pending | Status.Upgrading | Status.Failed | Status.UpToDate;
+    namespace Status {
+        type Id = Tagged<string, 'funnel.Upgrade.Status.Id'>;
+        namespace Id {
+            const unknown: Id;
+        }
+        type Pending = {
+            status: 'pending';
+            current?: Version;
+            available: ReadonlyArray<Version>;
+            dbReady: boolean;
+        };
+        type Upgrading = {
+            id: Id;
+            status: 'upgrading';
+            current?: Version;
+            active: Version;
+        };
+        type Failed = {
+            id: Id;
+            status: 'failed';
+            current?: Version;
+            failed: Version;
+            failure: string;
+            dbReady: boolean;
+        };
+        type UpToDate = {
+            status: 'up-to-date';
+            current: Version;
+        };
+        function getCurrentVersion(status: Status): Version | undefined;
+    }
+    interface Task {
+        readonly version: Version;
+        execute(): Promise<void>;
+    }
+}

package/dist/models/Upgrade.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Upgrade = void 0;
+// extension
+var Upgrade;
+(function (Upgrade) {
+    let Status;
+    (function (Status) {
+        let Id;
+        (function (Id) {
+            Id.unknown = '__unknown__';
+        })(Id = Status.Id || (Status.Id = {}));
+        // helpers
+        function getCurrentVersion(status) {
+            return status.current;
+        }
+        Status.getCurrentVersion = getCurrentVersion;
+    })(Status = Upgrade.Status || (Upgrade.Status = {}));
+})(Upgrade || (exports.Upgrade = Upgrade = {}));

package/dist/models/User.d.ts

@@ -0,0 +1,41 @@
+import type { Tagged } from 'type-fest';
+import type { RequiredBy } from '@nascentdigital/funnel-core';
+import { Role } from './Role';
+import { Privilege } from './Privilege';
+export declare class User<TBrand extends string = string> {
+    readonly data: User.Data<TBrand>;
+    readonly role: Role;
+    constructor(data: User.Data<TBrand>);
+    get isOwner(): boolean;
+    get isAdmin(): boolean;
+    get isEditor(): boolean;
+    get isViewer(): boolean;
+    get id(): User.Id;
+    get brands(): ReadonlyArray<TBrand>;
+    get username(): string;
+    get email(): string;
+    get blocked(): boolean;
+    has(...privileges: Privilege.Id[]): boolean;
+    hasAny(...privileges: Privilege.Id[]): boolean;
+    compareTo(that: User): number;
+}
+export declare namespace User {
+    type Id = Tagged<string, 'funnel.User.Id'>;
+    type Data<TBrand extends string = string> = {
+        id: User.Id;
+        username: string;
+        email: string;
+        blocked: boolean;
+        role: Role.Id;
+        brands: TBrand[];
+    };
+    namespace Data {
+        type Create = Omit<Data, 'id'> & {
+            password?: string;
+        };
+        type Update = RequiredBy<Partial<Data>, 'id'> & {
+            password?: string;
+        };
+    }
+    const UNAUTHENTICATED: User<string>;
+}