@nascentdigital/funnel-core 4.4.4

package/dist/schema/Collection.d.ts

@@ -0,0 +1,197 @@
+import { Tagged } from 'type-fest';
+import { Language } from '../regionalization';
+import { Asset } from './Asset';
+import type { ChangeSet } from './ChangeSet';
+import type { CollectionSnapshot } from './CollectionSnapshot';
+import { Field, ListField, ObjectField, TextField } from './field';
+import { Fields } from './Fields';
+import { Optional } from './Optional';
+import type { Page } from './Page';
+import { TagGroup } from './TagGroup';
+export declare class Collection<TFields extends Fields = Fields> {
+    readonly type: Collection.Type;
+    readonly tags: ReadonlyArray<TagGroup>;
+    readonly name: string;
+    readonly description: string;
+    readonly version: number;
+    readonly fields: TFields;
+    readonly editableFields: Fields.UnwrapOptional<TFields>;
+    private constructor();
+    modify(args: Collection.ModifyArgs<TFields>): Collection<TFields>;
+    rename(name: string): Collection<TFields>;
+    hide(...keys: ReadonlyArray<Fields.OptionalKeys<TFields>>): Collection<TFields>;
+    override(override: Fields.Override<TFields>): Collection<TFields>;
+    static create<TFields extends Fields>(args: Collection.FactoryArgs<TFields>): Collection<TFields>;
+}
+export declare namespace Collection {
+    type Id = Tagged<string, 'funnel.Collection.Id'>;
+    namespace Id {
+        const draft: Id;
+    }
+    type GroupId = Tagged<string, 'funnel.Collection.GroupId'>;
+    type Type = Tagged<string, 'funnel.Collection.Type'>;
+    type State = 'draft' | 'published' | 'unpublished';
+    type Update = Update.Name | Update.Tag | Update.ObjectInsert | Update.ArrayInsert | Update.ArrayDelete | Update.ArrayReorder | Update.Value;
+    namespace Update {
+        type Name = {
+            type: 'name';
+            name: string;
+        };
+        type Tag = {
+            type: 'tags';
+            tags: TagGroup.Data;
+        };
+        type Value = {
+            type: 'value';
+            path: string[];
+            value: Field.Data | ListField.Value.ForItem;
+        };
+        type ObjectInsert = {
+            type: 'object.insert';
+            path: string[];
+            value: Field.Data<ObjectField>;
+        };
+        type ArrayInsert = {
+            type: 'array.insert';
+            path: string[];
+            index: number;
+            id: string;
+            value: ListField.Value.ForItem;
+        };
+        type ArrayDelete = {
+            type: 'array.delete';
+            path: string[];
+            id: string;
+        };
+        type ArrayReorder = {
+            type: 'array.reorder';
+            path: string[];
+            ids: string[];
+        };
+    }
+    type Data<T extends Collection = Collection> = {
+        __root: 'collection';
+        id: Id;
+        groupId: GroupId;
+        type: T['type'];
+        tags: TagGroup.Data;
+        brand?: string;
+        language: Language;
+        version: number;
+        name: string;
+        fields: Data.ForFields<T['fields']>;
+        files: Asset.Linked[];
+        collections: Data.AsLink[];
+        pageIds?: Page.Id[];
+        state: State;
+        errors: boolean;
+        changeSetId?: ChangeSet.Id;
+        snapshotId?: CollectionSnapshot.Id;
+        snapshot?: CollectionSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+    };
+    namespace Data {
+        namespace Props {
+            type Id = Extract<All, 'id' | 'groupId' | 'type' | 'brand' | 'language' | 'version' | 'name' | 'tags'>;
+            const id: ReadonlyArray<Id>;
+            type Content = Extract<All, 'fields'>;
+            const content: ReadonlyArray<Content>;
+            type Links = Extract<All, 'files' | 'collections' | 'pageIds'>;
+            const links: ReadonlyArray<Links>;
+            type Audit = Extract<All, 'state' | 'errors' | 'changeSetId' | 'snapshotId' | 'createdOn' | 'updatedOn' | 'publishedOn'>;
+            const audit: ReadonlyArray<Audit>;
+            type Backup = Extract<All, 'snapshot'>;
+            const backup: ReadonlyArray<Backup>;
+            type All = keyof Data;
+            const all: ReadonlyArray<All>;
+        }
+        type AsDraft = Pick<Data, AsDraft.Prop>;
+        namespace AsDraft {
+            type Prop = Exclude<Props.Id, 'id'> | Extract<Props.Audit, 'changeSetId'>;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsNew = Pick<Data, AsNew.Prop>;
+        namespace AsNew {
+            type Prop = Exclude<Props.Id, 'id' | 'groupId'> | Extract<Props.Audit, 'changeSetId'>;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsNewLanguage = Pick<Data, AsNewLanguage.Prop>;
+        namespace AsNewLanguage {
+            type Prop = Extract<Props.Id, 'type' | 'brand' | 'groupId' | 'version' | 'language'> | Extract<Props.Audit, 'changeSetId'>;
+            const props: ReadonlyArray<Prop>;
+            function filter(page: AsNew | AsNewLanguage): page is AsNewLanguage;
+        }
+        type AsRef = Pick<Data, AsRef.Prop>;
+        namespace AsRef {
+            type Prop = Props.Id | Props.Audit;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsLink = Pick<Data, AsLink.Prop>;
+        namespace AsLink {
+            type Prop = Props.Id | Props.Content | Extract<Props.Links, 'pageIds'> | Props.Audit;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsContent = Pick<Data, AsContent.Prop>;
+        namespace AsContent {
+            type Prop = Props.Id | Props.Content | Props.Links | Props.Audit;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsGroup = {
+            group: {
+                groupId: GroupId;
+                type: Type;
+                brand?: string;
+                name: string;
+                instances: AsGroup.Instance[];
+            };
+            collection?: Data;
+        };
+        namespace AsGroup {
+            type Instance = Pick<Data, Instance.Prop>;
+            namespace Instance {
+                type Prop = Extract<Props.Id, 'id' | 'language' | 'version' | 'tags'>;
+                const props: ReadonlyArray<Prop>;
+            }
+        }
+        type AsInline<T extends Collection = Collection> = Pick<Data<T>, AsInline.Prop>;
+        namespace AsInline {
+            type Prop = Extract<Props.Id, 'type' | 'version' | 'name' | 'tags'> | Props.Content;
+            const props: ReadonlyArray<Prop>;
+        }
+        function filter(value: any): value is Data;
+        type ForFields<T extends Fields = Fields> = {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? never : key]: Field.Data.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? key : never]?: Field.Data.ForOptionalType<T[key]>;
+        };
+    }
+    type LinkedData<T extends Collection = Collection> = LinkedData.FromRef<T> | LinkedData.FromInline<T>;
+    namespace LinkedData {
+        type FromRef<T extends Collection = Collection> = Omit<Data<T>, 'fields'> & {
+            fields: ForFields<T['fields']>;
+        };
+        type FromInline<T extends Collection = Collection> = Pick<Data<T>, Exclude<Data.AsInline.Prop, 'fields'>> & {
+            fields: ForFields<T['fields']>;
+        };
+        type ForFields<T extends Fields = Fields> = {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? never : key]: Field.LinkedData.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? key : never]?: Field.LinkedData.ForOptionalType<T[key]>;
+        } & {
+            name: Field.LinkedData<TextField>;
+        };
+    }
+    type ConstructorArgs<TFields extends Fields> = {
+        type: string;
+        name: string;
+        description: string;
+        version: number;
+        fields: TFields;
+        editableFields: Fields.UnwrapOptional<TFields>;
+        tags?: ReadonlyArray<TagGroup>;
+    };
+    type ModifyArgs<TFields extends Fields> = Partial<Pick<ConstructorArgs<TFields>, 'tags' | 'name' | 'description'>>;
+    type FactoryArgs<TFields extends Fields> = Omit<ConstructorArgs<TFields>, 'editableFields'>;
+}

package/dist/schema/Collection.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const Fields_1 = require("./Fields");
+// class
+class Collection {
+    constructor(args) {
+        var _a;
+        // fail if name key/id is included
+        if ('name' in args.fields) {
+            throw new errors_1.ArgumentError('Collection schemas reserve the "name" key for the built-in name property.');
+        }
+        // initialize instance variables
+        this.type = args.type;
+        this.tags = (_a = args.tags) !== null && _a !== void 0 ? _a : [];
+        this.name = args.name;
+        this.description = args.description;
+        this.version = args.version;
+        this.fields = args.fields;
+        this.editableFields = args.editableFields;
+    }
+    modify(args) {
+        // create new collection (re-map required fields)
+        return new Collection(Object.assign({ type: this.type, tags: this.tags, name: this.name, description: this.description, version: this.version, fields: this.fields, editableFields: this.editableFields }, args));
+    }
+    rename(name) {
+        return this.modify({ name });
+    }
+    hide(...keys) {
+        // create new collection with removed fields
+        return new Collection({
+            type: this.type,
+            name: this.name,
+            description: this.description,
+            version: this.version,
+            fields: this.fields,
+            editableFields: keys.reduce((fields, key) => {
+                // handle field if not already pruned
+                const field = fields[key];
+                if (field) {
+                    // throw if field is required
+                    if (field.required) {
+                        throw new errors_1.InvalidOperationError(`Cannot hide required field: ${String(key)} in Collection: ${this.name}`);
+                    }
+                    // otherwise delete field if not already pruned
+                    else {
+                        delete fields[key];
+                    }
+                }
+                // keep reducing
+                return fields;
+            }, Object.assign({}, this.editableFields))
+        });
+    }
+    override(override) {
+        // get overrides from function
+        const overrides = override(this.fields);
+        // create new collection with persisted field spec and overridden fields in unwrapped fields
+        return new Collection({
+            type: this.type,
+            name: this.name,
+            description: this.description,
+            version: this.version,
+            fields: this.fields,
+            editableFields: Object.assign(Object.assign({}, this.editableFields), overrides)
+        });
+    }
+    static create(args) {
+        // create new collection with both field spec and unwrapped fields
+        return new Collection({
+            type: args.type,
+            tags: args.tags,
+            name: args.name,
+            description: args.description,
+            version: args.version,
+            fields: args.fields,
+            editableFields: Fields_1.Fields.unwrap(args.fields)
+        });
+    }
+}
+exports.Collection = Collection;
+// extension
+(function (Collection) {
+    let Id;
+    (function (Id) {
+        Id.draft = '__draft';
+    })(Id = Collection.Id || (Collection.Id = {}));
+    let Data;
+    (function (Data) {
+        // props (used to reduce risk of losing data across platform)
+        let Props;
+        (function (Props) {
+            Props.id = ['id', 'groupId', 'type', 'brand', 'language', 'version', 'name', 'tags'];
+            Props.content = ['fields'];
+            Props.links = ['files', 'collections', 'pageIds'];
+            Props.audit = ['state', 'errors', 'changeSetId', 'snapshotId', 'createdOn', 'updatedOn', 'publishedOn'];
+            Props.backup = ['snapshot'];
+            Props.all = [
+                ...Props.id,
+                ...Props.content,
+                ...Props.links,
+                ...Props.audit,
+                ...Props.backup
+            ];
+        })(Props = Data.Props || (Data.Props = {}));
+        let AsDraft;
+        (function (AsDraft) {
+            AsDraft.props = [
+                ...Props.id.filter(prop => prop !== 'id'),
+                'changeSetId'
+            ];
+        })(AsDraft = Data.AsDraft || (Data.AsDraft = {}));
+        let AsNew;
+        (function (AsNew) {
+            AsNew.props = [
+                ...Props.id.filter(prop => prop !== 'id' && prop !== 'groupId'),
+                'changeSetId'
+            ];
+        })(AsNew = Data.AsNew || (Data.AsNew = {}));
+        let AsNewLanguage;
+        (function (AsNewLanguage) {
+            AsNewLanguage.props = ['type', 'brand', 'groupId', 'version', 'language', 'changeSetId'];
+            // type guard
+            function filter(page) {
+                return 'groupId' in page;
+            }
+            AsNewLanguage.filter = filter;
+        })(AsNewLanguage = Data.AsNewLanguage || (Data.AsNewLanguage = {}));
+        let AsRef;
+        (function (AsRef) {
+            AsRef.props = [...Props.id, ...Props.audit];
+        })(AsRef = Data.AsRef || (Data.AsRef = {}));
+        let AsLink;
+        (function (AsLink) {
+            AsLink.props = [...Props.id, ...Props.content, 'pageIds', ...Props.audit];
+        })(AsLink = Data.AsLink || (Data.AsLink = {}));
+        let AsContent;
+        (function (AsContent) {
+            AsContent.props = [...Props.id, ...Props.content, ...Props.links, ...Props.audit];
+        })(AsContent = Data.AsContent || (Data.AsContent = {}));
+        let AsGroup;
+        (function (AsGroup) {
+            let Instance;
+            (function (Instance) {
+                Instance.props = ['id', 'language', 'version', 'tags'];
+            })(Instance = AsGroup.Instance || (AsGroup.Instance = {}));
+        })(AsGroup = Data.AsGroup || (Data.AsGroup = {}));
+        let AsInline;
+        (function (AsInline) {
+            AsInline.props = [
+                'type', 'version', 'name', 'tags',
+                ...Props.content
+            ];
+        })(AsInline = Data.AsInline || (Data.AsInline = {}));
+        // guard
+        function filter(value) {
+            return utils_1.Value.typeOf(value) === 'object'
+                && '__root' in value
+                && value.__root === 'collection';
+        }
+        Data.filter = filter;
+    })(Data = Collection.Data || (Collection.Data = {}));
+})(Collection || (exports.Collection = Collection = {}));

package/dist/schema/CollectionModel.d.ts

@@ -0,0 +1,30 @@
+import { Collection } from './Collection';
+export declare class CollectionModel {
+    readonly data: Collection.Data;
+    constructor(data: Collection.Data);
+    /**
+     * Synchronizes computed properties with the latest `CollectionModel` data (e.g. updating `name`)
+     */
+    sync(): void;
+    /**
+     * Applies updates *in place* to the underlying `Collection.Data`.
+     *
+     * @param updates - a collection of updates to be applied to this collection.
+     */
+    update(updates: ReadonlyArray<Collection.Update>): void;
+    private updateName;
+    private updateTags;
+    private updateObjectInsert;
+    private updateArrayInsert;
+    private updateArrayDelete;
+    private updateArrayReorder;
+    private updateValue;
+    private setValue;
+    private find;
+    private findInValue;
+    static from(data: Collection.Data): CollectionModel;
+    static fromDraft(data: Collection.Data.AsDraft): CollectionModel;
+}
+export declare namespace CollectionModel {
+    type TargetPath = `${Collection.Data.Props.All}` | `fields.${string}` | `fields.${string}.${string}` | `fields.${string}.${string}.${string}`;
+}