@nascentdigital/funnel-cms 4.4.4

package/dist/strapi/StrapiSiteConfigClient.d.ts

@@ -0,0 +1,8 @@
+import { SiteConfigClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiSiteConfigClient implements SiteConfigClient {
+    private readonly provider;
+    constructor(provider: IStrapiContentClient);
+    get({ brand }: SiteConfigClient.Get.Args): Promise<SiteConfigClient.Get.Result>;
+    update({ id, ...update }: SiteConfigClient.Update.Args): Promise<SiteConfigClient.Update.Result>;
+}

package/dist/strapi/StrapiSiteConfigClient.js

@@ -0,0 +1,50 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiSiteConfigClient = void 0;
+const serialization_1 = require("./serialization");
+// client extension
+class StrapiSiteConfigClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async get({ brand }) {
+        // fetch data
+        const client = this.provider.client;
+        const collection = client.collection('sites');
+        let { data: [data] } = await collection.find({
+            filters: { brand: { $eq: brand } },
+            pagination: {
+                start: 0,
+                limit: 1
+            }
+        });
+        // or create if it doesn't exist
+        if (!data) {
+            const { data: newData } = await collection.create(serialization_1.SiteConfigData.serialize({ brand, lockdownEditor: false }));
+            data = newData;
+        }
+        // return config
+        return serialization_1.SiteConfigData.deserialize(data);
+    }
+    async update(_a) {
+        var { id } = _a, update = __rest(_a, ["id"]);
+        // fetch data
+        const client = this.provider.client;
+        const collection = client.collection('sites');
+        const { data } = await collection.update(id, serialization_1.SiteConfigData.serialize(update));
+        // return config
+        return serialization_1.SiteConfigData.deserialize(data);
+    }
+}
+exports.StrapiSiteConfigClient = StrapiSiteConfigClient;

package/dist/strapi/StrapiUpgradeClient.d.ts

@@ -0,0 +1,13 @@
+import { UpgradeClient } from '../api';
+import { Upgrade } from '../models';
+import type { StrapiContentClient } from './StrapiContentClient';
+export declare class StrapiUpgradeClient implements UpgradeClient {
+    private readonly contentClient;
+    readonly cmsVersion: Upgrade.Version;
+    private readonly upgrades;
+    private readonly versions;
+    constructor(contentClient: StrapiContentClient);
+    status(): Promise<Upgrade.Status>;
+    private getCmsVersion;
+    upgrade(): Promise<Upgrade.Status>;
+}

package/dist/strapi/StrapiUpgradeClient.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiUpgradeClient = void 0;
+const serialization_1 = require("./serialization");
+// class
+class StrapiUpgradeClient {
+    constructor(contentClient) {
+        this.contentClient = contentClient;
+        this.cmsVersion = 3;
+        // initialize upgrades (needs to be ordered from oldest -> latest)
+        this.upgrades = [];
+        // versions (need to be sorted reversed from upgrades, latest -> oldest)
+        this.versions = this.upgrades.map(upgrade => upgrade.version).reverse();
+    }
+    async status() {
+        // query version info
+        const [versionsResult, dbReady] = await Promise.all([
+            // fetch latest version
+            this.contentClient.client.collection('versions').find({
+                sort: ['version:desc']
+            }),
+            // fetch server version
+            this.getCmsVersion()
+                .then(version => version === this.cmsVersion)
+        ]);
+        // return status from version
+        return serialization_1.VersionData.deserialize(versionsResult.data, this.versions, dbReady);
+    }
+    async getCmsVersion() {
+        try {
+            // send request to get version
+            const { client, token } = this.contentClient;
+            const url = new URL('/api/funnel/version', client.baseURL);
+            const response = await fetch(url.href, {
+                headers: {
+                    Authorization: `Bearer ${token}`
+                }
+            });
+            // return undefined if api call failed
+            if (!response.ok) {
+                console.warn('[StrapiUpgradeClient/getCmsVersion] failed to get version', response.statusText);
+                return undefined;
+            }
+            // deserialize result
+            const data = await response.json();
+            return Number.parseInt(data);
+        }
+        catch (e) {
+            console.warn('[StrapiUpgradeClient/getCmsVersion] failed to get version', e);
+            return undefined;
+        }
+    }
+    async upgrade() {
+        var _a;
+        // check status (fail if active/complete)
+        const status = await this.status();
+        switch (status.status) {
+            case 'upgrading':
+            case 'up-to-date':
+                return status;
+        }
+        // track existing status if we're retrying something that's failed
+        const retryVersion = status.status === 'failed'
+            ? status.failed
+            : undefined;
+        // try to upgrade all versions
+        const statusCollection = this.contentClient.client.collection('versions');
+        let lastUpgrade;
+        let lastStatusId;
+        try {
+            // start upgrades
+            const currentVersion = status.current;
+            for (const upgrade of this.upgrades) {
+                // skip if already installed
+                if (currentVersion !== undefined && upgrade.version <= currentVersion) {
+                    console.debug(`[Upgrader] ignoring previously installed v${upgrade.version}`);
+                    // skip
+                    continue;
+                }
+                // track upgrade
+                lastUpgrade = upgrade;
+                // update existing status if it had previously failed
+                let statusId;
+                if (upgrade.version === retryVersion && status.status === 'failed') {
+                    statusId = status.id;
+                    await statusCollection.update(statusId, serialization_1.VersionData.serializeUpdate({ status: 'upgrading' }));
+                }
+                // or create a new version entry
+                else {
+                    const { data } = await statusCollection.create(serialization_1.VersionData.serializeCreate({
+                        version: upgrade.version,
+                        status: 'upgrading'
+                    }));
+                    statusId = data.documentId;
+                }
+                // track upgrade status id (required for error handling below)
+                lastStatusId = statusId;
+                // run upgrade
+                await upgrade.execute();
+                // mark as complete if we made it here
+                lastStatusId = undefined;
+                await statusCollection.update(statusId, serialization_1.VersionData.serializeUpdate({ status: 'up-to-date' }));
+            }
+        }
+        // handler error
+        catch (e) {
+            // log issue
+            console.error(`[Upgrader] upgrade for v${(_a = lastUpgrade === null || lastUpgrade === void 0 ? void 0 : lastUpgrade.version) !== null && _a !== void 0 ? _a : '?'} failed`, e);
+            // persist failure (if possible)
+            if (lastStatusId) {
+                await statusCollection.update(lastStatusId, serialization_1.VersionData.serializeUpdate({ status: 'failed' }));
+            }
+        }
+        // return a final status
+        return this.status();
+    }
+}
+exports.StrapiUpgradeClient = StrapiUpgradeClient;

package/dist/strapi/StrapiUserClient.d.ts

@@ -0,0 +1,17 @@
+import { IncomingWebhook } from '@slack/webhook';
+import type { UserClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiUserClient implements UserClient {
+    private readonly provider;
+    private readonly slack;
+    constructor(provider: IStrapiContentClient, slack: IncomingWebhook | undefined);
+    me(): Promise<UserClient.Me.Result>;
+    getUsers(args?: UserClient.GetUsers.Args): Promise<UserClient.GetUsers.Result>;
+    getUser(id: UserClient.GetUser.Args): Promise<UserClient.GetUser.Result>;
+    createUser({ password, ...user }: UserClient.CreateUser.Args): Promise<UserClient.CreateUser.Result>;
+    updateUser({ id, password, ...user }: UserClient.UpdateUser.Args): Promise<UserClient.UpdateUser.Result>;
+    resetUser({ email }: UserClient.ResetUser.Args): Promise<UserClient.ResetUser.Result>;
+    deleteUser(id: UserClient.DeleteUser.Args): Promise<UserClient.DeleteUser.Result>;
+    private getRoles;
+    private getLegacyId;
+}

package/dist/strapi/StrapiUserClient.js

@@ -0,0 +1,199 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiUserClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const crypto_1 = __importDefault(require("crypto"));
+const serialization_1 = require("./serialization");
+// class
+class StrapiUserClient {
+    constructor(provider, slack) {
+        this.provider = provider;
+        this.slack = slack;
+    }
+    async me() {
+        return this.provider.auth.identify(this.provider.token);
+    }
+    async getUsers(args = {}) {
+        // fetch all users
+        const users = this.provider.client.collection('users');
+        const result = await users.find({
+            populate: '*',
+            filters: args && args.brand
+                ? { brands: { $contains: `"${args.brand}"` } }
+                : undefined
+        });
+        // NOTE: strapi types are different for users for some reason
+        const usersData = result;
+        // return as users
+        return usersData.map(serialization_1.UserData.deserialize);
+    }
+    async getUser(id) {
+        // users collection
+        const users = this.provider.client.collection('users');
+        // get legacy id of user (users collection uses legacy id still)
+        const legacyId = await this.getLegacyId(id);
+        // find user by legacy id
+        const result = await users.findOne(legacyId, { populate: '*' });
+        // NOTE: strapi types are different for users for some reason
+        const userData = result;
+        // return user transformed
+        return userData
+            ? serialization_1.UserData.deserialize(userData)
+            : undefined;
+    }
+    async createUser(_a) {
+        var { password } = _a, user = __rest(_a, ["password"]);
+        // get user roles data for serializing (need the role id)
+        const rolesData = await this.getRoles();
+        // serialize user
+        // set a random password (strapi throws error otherwise), and set user to confirmed by default
+        const serializedUser = Object.assign(Object.assign({}, serialization_1.UserData.serialize(user, rolesData)), { password: password !== null && password !== void 0 ? password : crypto_1.default.randomBytes(32).toString('hex'), confirmed: true });
+        // fetch user list
+        const users = await this.getUsers();
+        // throw ConflictError if username or email is already used
+        for (const existingUser of users) {
+            if (existingUser.username === serializedUser.username ||
+                existingUser.email === serializedUser.email) {
+                throw new funnel_core_1.ConflictError('Username or email is already used');
+            }
+        }
+        // create user
+        // NOTE: strapi client users collections doesn't work for creating
+        const { client } = this.provider;
+        const response = await client.fetch(`/users`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.provider.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(serializedUser)
+        });
+        // user data is at the root of response
+        const userData = await response.json();
+        // return user
+        return serialization_1.UserData.deserialize(userData);
+    }
+    async updateUser(_a) {
+        var { id, password } = _a, user = __rest(_a, ["id", "password"]);
+        // get legacy id of user (users collection uses legacy id still)
+        const legacyId = await this.getLegacyId(id);
+        // get user roles data for serializing (need the role id)
+        const rolesData = await this.getRoles();
+        // serialize user
+        const serializedUser = serialization_1.UserData.serialize(user, rolesData);
+        if (password) {
+            serializedUser.password = password;
+        }
+        console.debug('[StrapiUserClient/updateUser] updating user with:', serializedUser);
+        // update user by legacy id
+        // NOTE: strapi client users collections don't work for updating
+        const { client } = this.provider;
+        const response = await client.fetch(`/users/${legacyId}`, {
+            method: 'PUT',
+            headers: {
+                Authorization: `Bearer ${this.provider.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(serializedUser)
+        });
+        // user data is at the root of response
+        const userData = await response.json();
+        // return user
+        return serialization_1.UserData.deserialize(userData);
+    }
+    async resetUser({ email }) {
+        // try to send request
+        try {
+            // just log if there's no webhook
+            const { slack } = this;
+            if (!slack) {
+                console.debug('[UserClient] requesting password reset for', email);
+            }
+            // or send via slack
+            else {
+                await slack.send({
+                    text: `A password reset has been requested for ${email}`,
+                    blocks: [
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'mrkdwn',
+                                text: `A password reset has been requested for \`${email}\`.`
+                            }
+                        }
+                    ]
+                });
+            }
+        }
+        // handle error
+        catch (e) {
+            throw new funnel_core_1.DependencyError('Unable to communicate with Slack server');
+        }
+    }
+    async deleteUser(id) {
+        // get legacy id of user (users collection uses legacy id still)
+        const legacyId = await this.getLegacyId(id);
+        const { client } = this.provider;
+        // dekete user by legacy id
+        // NOTE: strapi client users collections don't work for deleting
+        const response = await client.fetch(`/users/${legacyId}`, {
+            method: 'DELETE',
+            headers: {
+                Authorization: `Bearer ${this.provider.token}`,
+                'Content-Type': 'application/json',
+            }
+        });
+        // throw if operation failed
+        if (!response.ok) {
+            throw new funnel_core_1.ServerError('Failed to delete user:' + response.statusText);
+        }
+        // or return success
+        return true;
+    }
+    async getRoles() {
+        // get roles
+        const { client } = this.provider;
+        const response = await client.fetch('/users-permissions/roles', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.provider.token}`
+            }
+        });
+        // return roles data
+        const { roles } = await response.json();
+        return roles;
+    }
+    async getLegacyId(documentId) {
+        // search for user by document id
+        const users = this.provider.client.collection('users');
+        const result = await users.find({
+            filters: {
+                documentId
+            },
+            fields: ['id']
+        });
+        // NOTE: strapi types are different for users for some reason
+        const usersData = result;
+        // there should only be one result, throw if not
+        if (usersData.length !== 1) {
+            throw new Error(`Could not get legacy id for user "${documentId}"`);
+        }
+        // return the legacy id as string
+        return usersData[0].id.toString();
+    }
+}
+exports.StrapiUserClient = StrapiUserClient;

package/dist/strapi/client.d.ts

@@ -0,0 +1 @@
+export * from './StrapiAssetUploadClient';

package/dist/strapi/client.js

@@ -0,0 +1,17 @@
+"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("./StrapiAssetUploadClient"), exports);

package/dist/strapi/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Strapi';
+export * from './StrapiContentClient';
+export * from './StrapiContentClientFactory';

package/dist/strapi/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("./Strapi"), exports);
+__exportStar(require("./StrapiContentClient"), exports);
+__exportStar(require("./StrapiContentClientFactory"), exports);

package/dist/strapi/models/StrapiAsset.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { Entity } from '../../models';
+export type StrapiAsset = Entity.Extend<Schema.AssetField.LinkedValue, StrapiAsset.Data>;
+export declare namespace StrapiAsset {
+    type Data = {
+        assetId: number;
+        fileId?: number;
+    };
+    function filter(value: any): value is StrapiAsset;
+}

package/dist/strapi/models/StrapiAsset.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiAsset = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var StrapiAsset;
+(function (StrapiAsset) {
+    // helpers
+    function filter(value) {
+        return funnel_core_1.Schema.AssetField.LinkedValue.filter(value)
+            && '__internal' in value && typeof value.__internal === 'object'
+            && !!value.__internal && !Array.isArray(value.__internal)
+            && 'assetId' in value.__internal && typeof value.__internal.assetId === 'number';
+    }
+    StrapiAsset.filter = filter;
+})(StrapiAsset || (exports.StrapiAsset = StrapiAsset = {}));

package/dist/strapi/models/StrapiData.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObject } from 'type-fest';
+import type { Entity } from '../../models';
+export type StrapiData = {
+    id: number;
+    documentId: string;
+    createdAt: string;
+    updatedAt: string | null;
+    publishedAt: string | null;
+};
+export declare namespace StrapiData {
+    type Keys = keyof StrapiData;
+    function deserialize<TId, TInternal extends JsonObject = JsonObject>(data: StrapiData, internal?: Omit<TInternal, 'id'>): Entity<TId, TInternal>;
+}

package/dist/strapi/models/StrapiData.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiData = void 0;
+// extension
+var StrapiData;
+(function (StrapiData) {
+    // helper
+    function deserialize(data, internal) {
+        var _a;
+        return {
+            __internal: Object.assign({ id: data.id }, ((_a = internal) !== null && _a !== void 0 ? _a : {})),
+            id: data.documentId
+        };
+    }
+    StrapiData.deserialize = deserialize;
+})(StrapiData || (exports.StrapiData = StrapiData = {}));

package/dist/strapi/models/StrapiFile.d.ts

@@ -0,0 +1,18 @@
+import { MimeType } from '@nascentdigital/funnel-core';
+import { StrapiData } from './StrapiData';
+export type StrapiFile = StrapiData & StrapiFile.Base & {
+    formats: Record<StrapiFile.Size, StrapiFile.Base> | null;
+};
+export declare namespace StrapiFile {
+    type Base = {
+        name: string;
+        hash: string;
+        url: string;
+        ext: string;
+        mime: MimeType;
+        width: number | null;
+        height: number | null;
+        size: number;
+    };
+    type Size = 'thumbnail' | 'small' | 'medium' | 'large';
+}

package/dist/strapi/models/StrapiFile.js

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

package/dist/strapi/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './StrapiAsset';
+export * from './StrapiData';
+export * from './StrapiFile';

package/dist/strapi/models/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("./StrapiAsset"), exports);
+__exportStar(require("./StrapiData"), exports);
+__exportStar(require("./StrapiFile"), exports);

package/dist/strapi/serialization/ChangeSetData.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { StrapiData } from '../models';
+export type ChangeSetData = StrapiData & {
+    brand: string;
+    groupId: Schema.ChangeSet.GroupId | null;
+    name: string;
+    changes: Schema.ChangeSet.Change[];
+    errors: boolean;
+    publishedOn: string | null;
+};
+export declare namespace ChangeSetData {
+    function deserialize(data: ChangeSetData): Schema.ChangeSet.Data;
+    type Update = Omit<ChangeSetData, StrapiData.Keys>;
+    function serialize(changeSet: Schema.ChangeSet.Data.New | Schema.ChangeSet.Data): Update;
+}

package/dist/strapi/serialization/ChangeSetData.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetData = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const models_1 = require("../models");
+// extension
+var ChangeSetData;
+(function (ChangeSetData) {
+    // deserialize (handles all cases safely)
+    function deserialize(data) {
+        var _a, _b;
+        // create output
+        const changeSet = Object.assign({}, models_1.StrapiData.deserialize(data));
+        const createdOn = Date.parse(data.createdAt);
+        const updatedOn = data.updatedAt ? Date.parse(data.updatedAt) : createdOn;
+        // bind required props to changeset
+        for (const prop of funnel_core_1.Schema.ChangeSet.Data.props) {
+            switch (prop) {
+                // handled by base
+                case 'id':
+                    break;
+                // direct transforms
+                case 'brand':
+                case 'groupId':
+                case 'name':
+                case 'errors':
+                    changeSet[prop] = (_a = data[prop]) !== null && _a !== void 0 ? _a : undefined;
+                    break;
+                // content
+                case 'changes':
+                    changeSet[prop] = (_b = data[prop]) !== null && _b !== void 0 ? _b : {
+                        pages: {},
+                        collections: {},
+                        assets: {}
+                    };
+                    break;
+                // timestamps
+                case 'createdOn':
+                    changeSet.createdOn = createdOn;
+                    break;
+                case 'updatedOn':
+                    changeSet.updatedOn = updatedOn;
+                    break;
+                case 'publishedOn':
+                    changeSet.publishedOn = data.publishedOn
+                        ? parseInt(data.publishedOn)
+                        : undefined;
+                    break;
+                // unhandled
+                default:
+                    throw new funnel_core_1.NotImplementedError(`Missing support for transforming ChangeSet "${prop}" prop`);
+            }
+        }
+        // return change set
+        return changeSet;
+    }
+    ChangeSetData.deserialize = deserialize;
+    function serialize(changeSet) {
+        var _a, _b, _c, _d, _e, _f;
+        // serialize base changeset data
+        const base = {
+            brand: changeSet.brand,
+            groupId: (_a = changeSet.groupId) !== null && _a !== void 0 ? _a : null,
+            name: (_b = changeSet.name) !== null && _b !== void 0 ? _b : (changeSet.groupId ? funnel_core_1.StringUtils.capitalize(changeSet.groupId) : 'Default')
+        };
+        // serialize existing changeset
+        if ('id' in changeSet) {
+            return Object.assign(Object.assign({}, base), { changes: changeSet.changes, errors: changeSet.errors, publishedOn: (_d = (_c = changeSet.publishedOn) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : null });
+        }
+        // or a new one
+        else {
+            return Object.assign(Object.assign({}, base), { changes: (_e = changeSet.changes) !== null && _e !== void 0 ? _e : [], errors: (_f = changeSet.errors) !== null && _f !== void 0 ? _f : true, publishedOn: null });
+        }
+    }
+    ChangeSetData.serialize = serialize;
+})(ChangeSetData || (exports.ChangeSetData = ChangeSetData = {}));