@nascentdigital/funnel-cms 4.6.7 → 5.0.2

package/dist/contentful/IContentfulContentClient.d.ts

@@ -0,0 +1,52 @@
+import { CMAClient } from '@contentful/app-sdk';
+import { PlainClientAPI, QueryOptions } from 'contentful-management';
+import { Environment, User } from '../models';
+import type { ContentfulAssetClient } from './ContentfulAssetClient';
+import type { ContentfulAuthClient } from './ContentfulAuthClient';
+import type { ContentfulChangeSetClient } from './ContentfulChangeSetClient';
+import type { ContentfulCollectionClient } from './ContentfulCollectionClient';
+import type { ContentfulPageClient } from './ContentfulPageClient';
+import type { ContentfulSiteConfigClient } from './ContentfulSiteConfigClient';
+import type { ContentfulUserClient } from './ContentfulUserClient';
+import { ContentfulData } from './models';
+export interface IContentfulContentClient {
+    readonly user: User;
+    readonly locale: 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 users: ContentfulUserClient;
+    readonly siteConfig: ContentfulSiteConfigClient;
+    createEntry<TEntry extends ContentfulData>(contentType: string, entry: ContentfulData.Draft<TEntry>): Promise<TEntry>;
+    getEntry<TEntry extends ContentfulData>(args: IContentfulContentClient.GetEntry.Args<TEntry>): Promise<IContentfulContentClient.GetEntry.Result<TEntry>>;
+    getEntries<TEntry extends ContentfulData>(args: IContentfulContentClient.GetEntries.Args<TEntry>): Promise<IContentfulContentClient.GetEntries.Result<TEntry>>;
+}
+export declare namespace IContentfulContentClient {
+    type EntryQueryOptions = {
+        includeLinks?: boolean | number;
+        version?: Environment;
+    };
+    namespace GetEntry {
+        type Args<TEntry extends ContentfulData> = EntryQueryOptions & {
+            entryId: ContentfulData.EntryId<TEntry>;
+        };
+        type Result<TEntry extends ContentfulData> = {
+            entry: TEntry;
+            references: ContentfulData[];
+        };
+    }
+    namespace GetEntries {
+        type Args<TEntry extends ContentfulData> = Omit<QueryOptions, 'content_type' | 'include'> & EntryQueryOptions & {
+            content_type: ContentfulData.ContentType<TEntry>;
+        };
+        type Result<TEntry extends ContentfulData> = {
+            entries: TEntry[];
+            references: ContentfulData[];
+        };
+    }
+}

package/dist/contentful/IContentfulContentClient.js

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

package/dist/contentful/api/ContentfulApi.d.ts

@@ -0,0 +1,10 @@
+import 'server-only';
+import type { NextRequest, NextResponse as NextResponseType } from 'next/server';
+import { ContentfulApiCommand } from '../ContentfulApiCommand';
+export declare namespace ContentfulApi {
+    function process(request: NextRequest, NextResponse: typeof NextResponseType): Promise<NextResponseType<{
+        data: ContentfulApiCommand.GetAccessTokens.Result;
+    }> | NextResponseType<{
+        error: import("@nascentdigital/funnel-core").SerializedIsometricError;
+    }>>;
+}

package/dist/contentful/api/ContentfulApi.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulApi = void 0;
+require("server-only");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const api_1 = require("../../api");
+const ContentfulAccess_1 = require("../ContentfulAccess");
+const ContentfulApiCommand_1 = require("../ContentfulApiCommand");
+// namespace
+var ContentfulApi;
+(function (ContentfulApi) {
+    // methods
+    async function process(request, NextResponse) {
+        // process command
+        try {
+            const data = await processCommand(request);
+            return NextResponse.json({ data });
+        }
+        // or return error on failure
+        catch (e) {
+            console.error('[ContentfulApi] caught error processing request', e);
+            // handle API error
+            if (e instanceof funnel_core_1.ApiError) {
+                return NextResponse.json({ error: e.serialize() }, { status: e.status });
+            }
+            // or handle other isometric errors
+            else {
+                return NextResponse.json({
+                    error: e instanceof funnel_core_1.IsometricError
+                        ? e.serialize()
+                        : new funnel_core_1.ServerError().serialize()
+                }, { status: 500 });
+            }
+        }
+    }
+    ContentfulApi.process = process;
+})(ContentfulApi || (exports.ContentfulApi = ContentfulApi = {}));
+// handler
+async function processCommand(request) {
+    // parse payload (throw if not valid)
+    const command = await parseCommand(request);
+    // process command
+    switch (command.type) {
+        case 'GetAccessTokens': {
+            const { deliveryAccessToken, previewAccessToken } = api_1.ContentClient.Factory.get().forServer();
+            return { deliveryAccessToken, previewAccessToken };
+        }
+        default:
+            throw new funnel_core_1.NotImplementedError();
+    }
+}
+// helpers
+async function parseCommand(request) {
+    // throw if it's not a post
+    if (request.method !== 'POST') {
+        throw new funnel_core_1.InvalidOperationError();
+    }
+    // parse payload (throw if not valid)
+    const command = await request.json();
+    if (!ContentfulApiCommand_1.ContentfulApiCommand.filter(command)) {
+        throw new funnel_core_1.ArgumentError('Invalid command');
+    }
+    // get site config
+    const brand = funnel_core_1.AppConfig.brand();
+    const client = api_1.ContentClient.Factory.get().forServer();
+    const siteConfig = await client.siteConfig.get({ brand });
+    // fail if config can't be resolved
+    if (!siteConfig) {
+        throw new funnel_core_1.ServerError('Unable to resolve site config');
+    }
+    // fail if not a match
+    else if (!(command.userId in siteConfig.access)) {
+        throw new funnel_core_1.NotAuthenticatedError();
+    }
+    // verify access
+    const access = new ContentfulAccess_1.ContentfulAccess(siteConfig.access[command.userId]);
+    if (access.token !== command.token || access.isExpired) {
+        throw new funnel_core_1.NotAuthenticatedError();
+    }
+    // return command
+    return command;
+}

package/dist/contentful/index.d.ts

@@ -0,0 +1,12 @@
+export * from './models';
+export * from './ContentfulAssetClient';
+export * from './ContentfulAuthClient';
+export * from './ContentfulChangeSetClient';
+export * from './ContentfulCollectionClient';
+export * from './ContentfulContentClient';
+export * from './ContentfulContentClientFactory';
+export * from './ContentfulPageClient';
+export * from './ContentfulSiteConfigClient';
+export * from './ContentfulUpgradeClient';
+export * from './ContentfulUserClient';
+export * from './IContentfulContentClient';

package/dist/contentful/index.js

@@ -0,0 +1,28 @@
+"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("./models"), exports);
+__exportStar(require("./ContentfulAssetClient"), exports);
+__exportStar(require("./ContentfulAuthClient"), exports);
+__exportStar(require("./ContentfulChangeSetClient"), exports);
+__exportStar(require("./ContentfulCollectionClient"), exports);
+__exportStar(require("./ContentfulContentClient"), exports);
+__exportStar(require("./ContentfulContentClientFactory"), exports);
+__exportStar(require("./ContentfulPageClient"), exports);
+__exportStar(require("./ContentfulSiteConfigClient"), exports);
+__exportStar(require("./ContentfulUpgradeClient"), exports);
+__exportStar(require("./ContentfulUserClient"), exports);
+__exportStar(require("./IContentfulContentClient"), exports);

package/dist/contentful/models/ContentfulAssetData.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { ContentfulData } from './ContentfulData';
+export type ContentfulAssetData = ContentfulData<ContentfulAssetData.ContentType, Schema.Asset.Id> & Omit<Schema.AssetField.LinkedValue, 'id'>;
+export declare namespace ContentfulAssetData {
+    const contentType: "asset";
+    type ContentType = typeof contentType;
+    function deserialize(data: ContentfulAssetData): Schema.Asset.Linked;
+}

package/dist/contentful/models/ContentfulAssetData.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulAssetData = void 0;
+// extension
+var ContentfulAssetData;
+(function (ContentfulAssetData) {
+    // constants
+    ContentfulAssetData.contentType = 'asset';
+    // deserialize
+    function deserialize(data) {
+        // return asset
+        return {
+            __root: 'asset',
+            type: 'asset',
+            value: {
+                id: data.id,
+                url: data.url,
+                type: data.type,
+                size: data.size,
+                name: data.name,
+                description: data.description,
+                scope: data.scope,
+                tags: data.tags,
+                metadata: data.metadata
+            }
+        };
+    }
+    ContentfulAssetData.deserialize = deserialize;
+})(ContentfulAssetData || (exports.ContentfulAssetData = ContentfulAssetData = {}));

package/dist/contentful/models/ContentfulCollectionData.d.ts

@@ -0,0 +1,11 @@
+import { RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { ContentfulData } from './ContentfulData';
+export type ContentfulCollectionData = ContentfulData<ContentfulCollectionData.ContentType, Schema.Collection.Id> & Omit<Schema.Collection.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'>;
+export declare namespace ContentfulCollectionData {
+    const contentType: "collection";
+    type ContentType = typeof contentType;
+    type ForSchema = Schema.Collection.Data & Pick<ContentfulData, 'references'>;
+    type Potential = RequiredBy<Partial<ContentfulCollectionData>, keyof ContentfulData<ContentfulCollectionData.ContentType, Schema.Collection.Id>>;
+    function deserialize(data: Potential, props?: ReadonlyArray<Schema.Collection.Data.Props.All>): ForSchema;
+    function deserializeRefs(refs: ContentfulData[]): Schema.Collection.References;
+}

package/dist/contentful/models/ContentfulCollectionData.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCollectionData = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const ContentfulAssetData_1 = require("./ContentfulAssetData");
+// extension
+var ContentfulCollectionData;
+(function (ContentfulCollectionData) {
+    // constants
+    ContentfulCollectionData.contentType = 'collection';
+    function deserialize(data, props = funnel_core_1.Schema.Collection.Data.Props.all) {
+        var _a;
+        // create base collection
+        const collection = {
+            __root: 'collection',
+            id: data.id,
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn,
+            references: (_a = data.references) !== null && _a !== void 0 ? _a : []
+        };
+        // helper
+        const bindProp = (prop, target, transform) => {
+            if (prop in data) {
+                collection[target] = transform(data[prop]);
+            }
+        };
+        // bind required props to page
+        for (const prop of props) {
+            switch (prop) {
+                // handled by base
+                case 'id':
+                case 'createdOn':
+                case 'updatedOn':
+                    break;
+                // direct transforms
+                case 'groupId':
+                case 'type':
+                case 'brand':
+                case 'language':
+                case 'version':
+                case 'name':
+                case 'state':
+                case 'errors':
+                case 'pageIds':
+                case 'tags':
+                case 'publishedOn':
+                    bindProp(prop, prop, value => value !== null && value !== void 0 ? value : undefined);
+                    break;
+                // content
+                case 'fields':
+                    bindProp(prop, prop, value => value !== null && value !== void 0 ? value : {});
+                    break;
+                // ignore
+                case 'files':
+                case 'collections':
+                case 'snapshot':
+                case 'snapshotId':
+                case 'changeSetId':
+                    break;
+                // unhandled
+                default:
+                    throw new funnel_core_1.NotImplementedError(`Missing support for transforming collection "${prop}" prop`);
+            }
+        }
+        // return collection
+        return collection;
+    }
+    ContentfulCollectionData.deserialize = deserialize;
+    // deserialize references
+    function deserializeRefs(refs) {
+        // setup
+        const files = {};
+        const collections = {};
+        // loop over references and serialize
+        for (const ref of refs) {
+            switch (ref.__type) {
+                // asset
+                case ContentfulAssetData_1.ContentfulAssetData.contentType: {
+                    const assetRef = ref;
+                    files[assetRef.id] = ContentfulAssetData_1.ContentfulAssetData.deserialize(assetRef);
+                    break;
+                }
+                // collection
+                case ContentfulCollectionData.contentType: {
+                    const collectionRef = ref;
+                    collections[collectionRef.id] = ContentfulCollectionData.deserialize(collectionRef, funnel_core_1.Schema.Collection.Data.AsLink.props);
+                    break;
+                }
+            }
+        }
+        // return
+        return {
+            files,
+            collections
+        };
+    }
+    ContentfulCollectionData.deserializeRefs = deserializeRefs;
+})(ContentfulCollectionData || (exports.ContentfulCollectionData = ContentfulCollectionData = {}));

package/dist/contentful/models/ContentfulData.d.ts

@@ -0,0 +1,40 @@
+import type { EntryAPI } from '@contentful/app-sdk';
+import type { Entry } from 'contentful';
+import type { EntryProps } from 'contentful-management';
+export type ContentfulData<TType extends string = string, TId extends string = string> = {
+    __type: TType;
+    __version: number;
+    id: TId;
+    createdOn: number;
+    updatedOn: number;
+    references: ContentfulData.References;
+};
+export declare namespace ContentfulData {
+    type ContentType<T extends ContentfulData> = T['__type'];
+    type EntryId<T extends ContentfulData> = T['id'];
+    type References = Array<Link.Entry | Link.Asset>;
+    type Draft<T extends ContentfulData> = Omit<T, keyof ContentfulData>;
+    type Link<TType extends Link.Type = Link.Type> = {
+        sys: {
+            type: 'Link';
+            linkType: TType;
+            id: string;
+        };
+    };
+    namespace Link {
+        type Type = 'Asset' | 'Entry' | 'Upload';
+        type Asset = Link<'Asset'>;
+        type Entry = Link<'Entry'>;
+        function create<TType extends Type>(id: string, linkType: TType): Link<TType>;
+    }
+    type Fields<TData extends Record<string, any>> = {
+        [TKey in Exclude<keyof TData, keyof ContentfulData>]: {
+            [locale: string]: TData[TKey];
+        };
+    };
+    function toEntryData<T extends Record<string, any>>(entry: T, locale: string): Fields<T>;
+    function fromEntryData<T extends ContentfulData>(entry: EntryAPI): T;
+    function fromCdaData<T extends ContentfulData>({ sys, fields }: Entry): T;
+    function fromCmaData<T extends ContentfulData>({ sys, fields }: EntryProps, locale: string): T;
+    function findReferences(source: object): References;
+}

package/dist/contentful/models/ContentfulData.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulData = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+var ContentfulData;
+(function (ContentfulData) {
+    let Link;
+    (function (Link) {
+        // helpers
+        function create(id, linkType) {
+            return {
+                sys: {
+                    type: 'Link',
+                    linkType,
+                    id
+                }
+            };
+        }
+        Link.create = create;
+    })(Link = ContentfulData.Link || (ContentfulData.Link = {}));
+    // helpers
+    function toEntryData(entry, locale) {
+        return Object.entries(entry).reduce((entryData, [keyRaw, value]) => {
+            // map entry (bucket under locale)
+            const key = keyRaw;
+            entryData[key] = { [locale]: value };
+            // keep reducing
+            return entryData;
+        }, {});
+    }
+    ContentfulData.toEntryData = toEntryData;
+    function fromEntryData(entry) {
+        // get sys
+        const sys = entry.getSys();
+        // simplify fields (remove locale)
+        const normalizedFields = {};
+        for (const key in entry.fields) {
+            normalizedFields[key] = entry.fields[key].getValue();
+        }
+        // return normalized form
+        return Object.assign({ __type: sys.contentType.sys.id, __version: sys.version, id: sys.id, createdOn: new Date(sys.createdAt).getTime(), updatedOn: new Date(sys.updatedAt).getTime() }, normalizedFields);
+    }
+    ContentfulData.fromEntryData = fromEntryData;
+    function fromCdaData({ sys, fields }) {
+        // simplify fields (remove locale)
+        const normalizedFields = {};
+        for (const key in fields) {
+            normalizedFields[key] = fields[key];
+        }
+        // return normalized form
+        return Object.assign({ __type: sys.contentType.sys.id, __version: sys.revision, id: sys.id, createdOn: new Date(sys.createdAt).getTime(), updatedOn: new Date(sys.updatedAt).getTime() }, normalizedFields);
+    }
+    ContentfulData.fromCdaData = fromCdaData;
+    function fromCmaData({ sys, fields }, locale) {
+        // simplify fields (remove locale)
+        const normalizedFields = {};
+        for (const key in fields) {
+            normalizedFields[key] = fields[key][locale];
+        }
+        // return normalized form
+        return Object.assign({ __type: sys.contentType.sys.id, __version: sys.version, id: sys.id, createdOn: new Date(sys.createdAt).getTime(), updatedOn: new Date(sys.updatedAt).getTime() }, normalizedFields);
+    }
+    ContentfulData.fromCmaData = fromCmaData;
+    function findReferences(source) {
+        // prepare sets
+        const references = [];
+        // extract actual refs
+        funnel_core_1.ObjectUtils.walk(source, ({ value }) => {
+            // track assets
+            if (funnel_core_1.Schema.Asset.filter(value)) {
+                // track file (if it's real)
+                const assetId = funnel_core_1.Schema.Asset.getId(value);
+                if (assetId) {
+                    references.push(ContentfulData.Link.create(assetId, 'Entry'));
+                }
+                // don't recurse
+                return false;
+            }
+            // track page links
+            else if (funnel_core_1.Schema.Field.Data.InternalLink.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.InternalLink.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    references.push(ContentfulData.Link.create(pageId, 'Entry'));
+                }
+                // don't recurse
+                return false;
+            }
+            // transform collection refs
+            else if (funnel_core_1.Schema.Field.Data.Collection.Ref.filter(value)) {
+                // track collection (only if the id's real)
+                const collectionId = funnel_core_1.Schema.Field.Data.Collection.Ref.getId(value);
+                if (collectionId && collectionId !== funnel_core_1.Schema.Collection.Id.draft) {
+                    references.push(ContentfulData.Link.create(collectionId, 'Entry'));
+                }
+                // don't recurse
+                return false;
+            }
+            // transform page refs
+            else if (funnel_core_1.Schema.Field.Data.Page.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.Page.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    references.push(ContentfulData.Link.create(pageId, 'Entry'));
+                }
+                // don't recurse
+                return false;
+            }
+            // otherwise recurse deeper
+            else {
+                return true;
+            }
+        });
+        // return references
+        return references;
+    }
+    ContentfulData.findReferences = findReferences;
+})(ContentfulData || (exports.ContentfulData = ContentfulData = {}));

package/dist/contentful/models/ContentfulPageData.d.ts

@@ -0,0 +1,17 @@
+import { RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { ContentfulData } from './ContentfulData';
+export type ContentfulPageData = ContentfulData<ContentfulPageData.ContentType, Schema.Page.Id> & Omit<Schema.Page.Data, 'id' | 'changeSetId' | 'snapshotId' | 'snapshot'>;
+export declare namespace ContentfulPageData {
+    const contentType: "page";
+    type ContentType = typeof contentType;
+    const referencesSpec: {
+        readonly page: "pages";
+        readonly collection: "collections";
+        readonly asset: "files";
+    };
+    type ReferencesSpec = typeof referencesSpec;
+    type ForSchema = Schema.Page.Data & Pick<ContentfulData, 'references'>;
+    type Potential = RequiredBy<Partial<ContentfulPageData>, keyof ContentfulData<ContentfulPageData.ContentType, Schema.Page.Id>>;
+    function deserialize(data: Potential, props?: ReadonlyArray<Schema.Page.Data.Props.All>): ForSchema;
+    function deserializeRefs(refs: ContentfulData[]): Schema.Page.References;
+}

package/dist/contentful/models/ContentfulPageData.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulPageData = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const ContentfulAssetData_1 = require("./ContentfulAssetData");
+const ContentfulCollectionData_1 = require("./ContentfulCollectionData");
+// extension
+var ContentfulPageData;
+(function (ContentfulPageData) {
+    // constants
+    ContentfulPageData.contentType = 'page';
+    ContentfulPageData.referencesSpec = {
+        'page': 'pages',
+        'collection': 'collections',
+        'asset': 'files'
+    };
+    function deserialize(data, props = funnel_core_1.Schema.Page.Data.Props.all) {
+        var _a;
+        // create base page
+        const page = {
+            __root: 'page',
+            id: data.id,
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn,
+            references: (_a = data.references) !== null && _a !== void 0 ? _a : []
+        };
+        // helper
+        const bindProp = (prop, target, transform) => {
+            if (prop in data) {
+                page[target] = transform(data[prop]);
+            }
+        };
+        // bind required props to page
+        for (const prop of props) {
+            switch (prop) {
+                // handled by base
+                case 'id':
+                case 'createdOn':
+                case 'updatedOn':
+                    break;
+                // direct transforms
+                case 'groupId':
+                case 'brand':
+                case 'region':
+                case 'language':
+                case 'type':
+                case 'slug':
+                case 'url':
+                case 'name':
+                case 'preview':
+                case 'state':
+                case 'errors':
+                case 'tags':
+                case 'publishedOn':
+                case 'publication':
+                    bindProp(prop, prop, value => value !== null && value !== void 0 ? value : undefined);
+                    break;
+                // content
+                case 'discover':
+                case 'content':
+                    bindProp(prop, prop, value => value !== null && value !== void 0 ? value : {});
+                    break;
+                // ignore
+                case 'files':
+                case 'pages':
+                case 'collections':
+                case 'snapshot':
+                case 'snapshotId':
+                case 'changeSetId':
+                    break;
+                // unhandled
+                default:
+                    throw new funnel_core_1.NotImplementedError(`Missing support for transforming page "${prop}" prop`);
+            }
+        }
+        // return page
+        return page;
+    }
+    ContentfulPageData.deserialize = deserialize;
+    // deserialize references
+    function deserializeRefs(refs) {
+        // setup
+        const files = {};
+        const collections = {};
+        const pages = {};
+        // loop over references and serialize
+        for (const ref of refs) {
+            switch (ref.__type) {
+                // asset
+                case ContentfulAssetData_1.ContentfulAssetData.contentType: {
+                    const assetRef = ref;
+                    files[assetRef.id] = ContentfulAssetData_1.ContentfulAssetData.deserialize(assetRef);
+                    break;
+                }
+                // collection
+                case ContentfulCollectionData_1.ContentfulCollectionData.contentType: {
+                    const collectionRef = ref;
+                    collections[collectionRef.id] = ContentfulCollectionData_1.ContentfulCollectionData.deserialize(collectionRef, funnel_core_1.Schema.Collection.Data.AsLink.props);
+                    break;
+                }
+                // page
+                case ContentfulPageData.contentType: {
+                    const pageRef = ref;
+                    pages[pageRef.id] = ContentfulPageData.deserialize(pageRef, funnel_core_1.Schema.Page.Data.Props.all);
+                    break;
+                }
+            }
+        }
+        // return
+        return {
+            files,
+            collections,
+            pages
+        };
+    }
+    ContentfulPageData.deserializeRefs = deserializeRefs;
+})(ContentfulPageData || (exports.ContentfulPageData = ContentfulPageData = {}));

package/dist/contentful/models/ContentfulSiteConfigData.d.ts

@@ -0,0 +1,10 @@
+import { SiteConfig, User } from '../../models';
+import { ContentfulAccess } from '../ContentfulAccess';
+import { ContentfulData } from './ContentfulData';
+export type ContentfulSiteConfigData = Omit<SiteConfig.Data, 'id'> & ContentfulData<ContentfulSiteConfigData.ContentType, SiteConfig.Id> & {
+    access: Record<User.Id, ContentfulAccess.Data>;
+};
+export declare namespace ContentfulSiteConfigData {
+    const contentType: "siteConfig";
+    type ContentType = typeof contentType;
+}

package/dist/contentful/models/ContentfulSiteConfigData.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulSiteConfigData = void 0;
+// extension
+var ContentfulSiteConfigData;
+(function (ContentfulSiteConfigData) {
+    // constants
+    ContentfulSiteConfigData.contentType = 'siteConfig';
+})(ContentfulSiteConfigData || (exports.ContentfulSiteConfigData = ContentfulSiteConfigData = {}));

package/dist/contentful/models/ContentfulUserData.d.ts

@@ -0,0 +1,6 @@
+import { UserAPI } from '@contentful/app-sdk';
+import { Role } from '../../models';
+export type ContentfulUserData = UserAPI;
+export declare namespace ContentfulUserData {
+    function parseRole(role: string): Role;
+}