@nascentdigital/funnel-cms 4.4.4

package/dist/strapi/StrapiAssetUploadClient.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiAssetUploadClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const api_1 = require("../api");
+const models_1 = require("./models");
+// class
+class StrapiAssetUploadClient extends api_1.AssetUploadClient {
+    constructor(strapiUrl) {
+        // construct base
+        super();
+        this.strapiUrl = strapiUrl;
+    }
+    async onUpload({ api, file: blob, brand, type, size, name, description, scope, tags, metadata }) {
+        var _a, _b, _c;
+        console.debug(`[StrapiAssetUploadClient] creating initial asset for "${name}"`, { type, size, scope, tags, metadata });
+        // get existing asset if we're replacing the asset
+        let assetRef = await api.createAsset({
+            brand,
+            type,
+            size,
+            name,
+            description,
+            scope,
+            tags,
+            metadata
+        });
+        if (!assetRef) {
+            throw new funnel_core_1.IllegalStateError(`Unable to create new Asset for "${name}"`);
+        }
+        console.debug('[StrapiAssetUploadClient] created new asset', assetRef);
+        // throw if we don't have a strapi asset
+        const { value: partialAsset } = assetRef;
+        if (!models_1.StrapiAsset.filter(partialAsset)) {
+            console.error('[StrapiAssetUploadClient] invalid asset', assetRef);
+            throw new funnel_core_1.IllegalStateError('Asset is missing strapi internals');
+        }
+        // upload + link asset
+        const assetId = assetRef.value.id;
+        try {
+            // create file submission
+            const formData = new FormData();
+            formData.append('files', blob);
+            formData.append('ref', 'api::asset.asset');
+            formData.append('refId', `${partialAsset.__internal.assetId}`);
+            formData.append('field', 'file');
+            console.debug('[StrapiAssetUploadClient] uploading file', Array.from(formData.entries()));
+            // upload file
+            const url = new URL('/api/upload', this.strapiUrl);
+            url.searchParams.set('funnel_token', (_a = api.token) !== null && _a !== void 0 ? _a : '');
+            const response = await fetch(url.href, {
+                method: 'POST',
+                body: formData
+            });
+            // handle upload errors (remember we're on the client-side)
+            const json = await response.json();
+            if (!response.ok || json.error) {
+                throw new funnel_core_1.DependencyError('Failed to upload file: ' + ((_c = (_b = json.error) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : json.statusText));
+            }
+            const file = json[0];
+            console.debug('[StrapiAssetUploadClient] uploaded asset file', file);
+            // update asset with missing details
+            assetRef = await api.updateAsset(getAssetUpdate({ asset: assetRef.value, file }));
+            // return asset
+            return assetRef;
+        }
+        // cleanup on error
+        catch (e) {
+            console.error('[StrapiAssetUpload] failed to upload asset - deleting file', e);
+            // delete zombie
+            await api.deleteAsset(assetId);
+            // rethrow
+            if (e instanceof funnel_core_1.IsometricError) {
+                console.error('[StrapiAssetUploadClient] file upload failed', e.message);
+                throw e;
+            }
+            // or create new error
+            else {
+                console.error('[StrapiAssetUploadClient] asset upload failed for unknown reason', e);
+                throw new funnel_core_1.DependencyError('Asset upload failed');
+            }
+        }
+    }
+}
+exports.StrapiAssetUploadClient = StrapiAssetUploadClient;
+function getAssetUpdate({ asset, file }) {
+    var _a, _b, _c;
+    // create base
+    const update = {
+        id: asset.id,
+        url: file.url,
+    };
+    // add metadata based on type
+    const metadata = Object.assign({}, ((_a = asset.metadata) !== null && _a !== void 0 ? _a : {}));
+    const fileType = funnel_core_1.FileType.coerce(asset.type);
+    console.debug('[StrapiAssetUploadClient/getAssetUpdate] getting update', { fileType, metadata });
+    switch (fileType) {
+        case 'image': {
+            metadata.thumbUrl = (_c = (_b = file.formats) === null || _b === void 0 ? void 0 : _b.thumbnail) === null || _c === void 0 ? void 0 : _c.url;
+            update.metadata = metadata;
+            break;
+        }
+        default:
+            break;
+    }
+    console.debug('[StrapiAssetUploadClient/getAssetUpdate] getting update', update);
+    // return update
+    return update;
+}

package/dist/strapi/StrapiAuthClient.d.ts

@@ -0,0 +1,9 @@
+import { AuthClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiAuthClient implements AuthClient {
+    private readonly provider;
+    constructor(provider: IStrapiContentClient);
+    identify(token: AuthClient.Identify.Args): Promise<AuthClient.Identify.Result>;
+    login({ email, password }: AuthClient.Login.Args): Promise<AuthClient.Login.Result>;
+    authorize(token: AuthClient.Authorize.Args): Promise<AuthClient.Authorize.Result>;
+}

package/dist/strapi/StrapiAuthClient.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiAuthClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const serialization_1 = require("./serialization");
+// class
+class StrapiAuthClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async identify(token) {
+        // fetch me
+        const { client } = this.provider;
+        const response = await client.fetch('/users/me?populate=*', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        // return undefined if auth failed
+        if (!response.ok) {
+            return undefined;
+        }
+        // create user from response
+        const data = await response.json();
+        return serialization_1.UserData.deserialize(data);
+    }
+    async login({ email, password }) {
+        // make google authentication request
+        const { client } = this.provider;
+        const url = new URL('/api/auth/local', client.baseURL);
+        const response = await fetch(url.href, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ identifier: email, password })
+        });
+        // return undefined if auth failed
+        if (!response.ok) {
+            throw new funnel_core_1.NotAuthenticatedError('Invalid email or password');
+        }
+        // fetch jwt from response
+        const { jwt } = await response.json();
+        // return jwt
+        return jwt;
+    }
+    async authorize(token) {
+        // make google authentication request
+        const { client } = this.provider;
+        const url = new URL('/api/funnel/google/authenticate', client.baseURL);
+        url.searchParams.append('token', token);
+        const response = await fetch(url.href, {
+            headers: { 'Content-Type': 'application/json' }
+        });
+        // return undefined if auth failed
+        if (!response.ok) {
+            throw new funnel_core_1.ArgumentError('Invalid google token');
+        }
+        // fetch jwt from response
+        const { jwt } = await response.json();
+        // return jwt
+        return jwt;
+    }
+}
+exports.StrapiAuthClient = StrapiAuthClient;

package/dist/strapi/StrapiChangeSetClient.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { ChangeSetClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiChangeSetClient implements ChangeSetClient {
+    private readonly provider;
+    constructor(provider: IStrapiContentClient);
+    resolve({ id, fallbackToGlobal }?: StrapiChangeSetClient.ResolveArgs): Promise<Schema.ChangeSet>;
+    current({ brand, groupId }: ChangeSetClient.Current.Args): Promise<ChangeSetClient.Current.Result>;
+    listGroups({ brand }: ChangeSetClient.ListGroups.Args): Promise<ChangeSetClient.ListGroups.Result>;
+    list({ brand, groupId, scope, pagination }: ChangeSetClient.List.Args): Promise<ChangeSetClient.List.Result>;
+    get(changeSetId: ChangeSetClient.Get.Args): Promise<ChangeSetClient.Get.Result>;
+    update({ id, name, changes, publishedOn }: ChangeSetClient.Update.Args): Promise<ChangeSetClient.Update.Result>;
+    delete(args: ChangeSetClient.Delete.Args): Promise<ChangeSetClient.Delete.Result>;
+    commit(changeSetId: ChangeSetClient.Commit.Args): Promise<ChangeSetClient.Commit.Result>;
+    revert({ changeSetId, changeIds }: ChangeSetClient.Revert.Args): Promise<ChangeSetClient.Revert.Result>;
+}
+export declare namespace StrapiChangeSetClient {
+    type ResolveArgs = {
+        id?: Schema.ChangeSet.Id;
+        fallbackToGlobal?: boolean;
+    };
+}

package/dist/strapi/StrapiChangeSetClient.js

@@ -0,0 +1,218 @@
+"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.StrapiChangeSetClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const serialization_1 = require("./serialization");
+const Strapi_1 = require("./Strapi");
+// class
+class StrapiChangeSetClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async resolve({ id, fallbackToGlobal = false } = {}) {
+        // get specific changeset
+        let changeSetData;
+        if (id) {
+            try {
+                changeSetData = await this.get(id);
+            }
+            catch (e) {
+                // fallback if allowed
+                if (fallbackToGlobal) {
+                    changeSetData = await this.current({ brand: funnel_core_1.AppConfig.brand() });
+                }
+                // or throw
+                else {
+                    throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+                }
+            }
+        }
+        // or resolve current changeset (might create one)
+        else {
+            changeSetData = await this.current({ brand: funnel_core_1.AppConfig.brand() });
+        }
+        // convert to change set instance
+        return new funnel_core_1.Schema.ChangeSet(changeSetData);
+    }
+    async current({ brand, groupId = funnel_core_1.Schema.ChangeSet.GroupId.global }) {
+        // get latest changeset
+        const client = this.provider.client;
+        const collection = client.collection('change-sets');
+        let { data: [changeSetData] } = await collection.find({
+            filters: {
+                $and: [
+                    { brand: { $eq: brand } },
+                    { groupId: { $eq: groupId } },
+                    { publishedOn: { $null: true } }
+                ]
+            },
+            sort: ['updatedAt:desc'],
+            pagination: {
+                start: 0,
+                limit: 1
+            }
+        });
+        // create change set if it doesn't exist
+        if (!changeSetData) {
+            // create new changeset
+            const { data } = await collection.create(Object.assign({}, (serialization_1.ChangeSetData.serialize({
+                brand: funnel_core_1.AppConfig.brand(),
+                name: groupId === '__global' ? 'Global' : funnel_core_1.StringUtils.capitalize(groupId),
+                groupId
+            }))));
+            // capture new changeset
+            changeSetData = data;
+        }
+        // return new changeset
+        return serialization_1.ChangeSetData.deserialize(changeSetData);
+    }
+    async listGroups({ brand }) {
+        // fetch data
+        const data = await this.provider.customRequest({
+            command: 'changeset/query',
+            params: { brand }
+        });
+        console.debug('[StrapiChangeSetClient] listing groups', data);
+        // return deserialized
+        return data.map((_a) => {
+            var { latest } = _a, data = __rest(_a, ["latest"]);
+            return (Object.assign(Object.assign({}, data), { latest: serialization_1.ChangeSetData.deserialize(latest) }));
+        });
+    }
+    async list({ brand, groupId, scope = 'all', pagination }) {
+        // create filters
+        const filters = [
+            { brand: { $eq: brand } }
+        ];
+        if (groupId) {
+            filters.push({ groupId: { $eq: groupId } });
+        }
+        if (scope !== 'all') {
+            filters.push(scope === 'published'
+                ? { publishedOn: { $notNull: true } }
+                : { publishedOn: { $null: true } });
+        }
+        // fetch items
+        const { client } = this.provider;
+        const collection = client.collection('change-sets');
+        const _a = await Strapi_1.Strapi.paginate({
+            collection,
+            pagination,
+            filters: filters.length === 1
+                ? filters[0]
+                : { $and: filters },
+            sort: ['updatedAt:desc']
+        }), { items } = _a, paginated = __rest(_a, ["items"]);
+        // transform and return them
+        return Object.assign({ items: items
+                .map(data => serialization_1.ChangeSetData.deserialize(data)) }, paginated);
+    }
+    async get(changeSetId) {
+        // fetch changeset
+        const client = this.provider.client;
+        const collection = client.collection('change-sets');
+        const { data } = await collection.findOne(changeSetId);
+        // throw if it isn't found
+        if (!data) {
+            throw new funnel_core_1.NotFoundError();
+        }
+        // or return changeset
+        return serialization_1.ChangeSetData.deserialize(data);
+    }
+    async update({ id, name, changes, publishedOn }) {
+        // fetch changeset
+        const client = this.provider.client;
+        const collection = client.collection('change-sets');
+        const { data } = await collection.update(id, {
+            name,
+            changes,
+            errors: changes === null || changes === void 0 ? void 0 : changes.some(change => change.errors),
+            publishedOn: publishedOn === null || publishedOn === void 0 ? void 0 : publishedOn.toString()
+        });
+        // return update
+        return serialization_1.ChangeSetData.deserialize(data);
+    }
+    async delete(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async commit(changeSetId) {
+        // fetch changeset
+        const changeSet = await this.resolve({ id: changeSetId });
+        const { pageChanges, collectionChanges, assetChanges, errors, publishedOn } = changeSet;
+        // throw if changeset is already published
+        if (publishedOn) {
+            throw new funnel_core_1.ConflictError('ChangeSet already published');
+        }
+        // throw if changeset is empty (shouldn't happen)
+        else if (pageChanges.length === 0 && collectionChanges.length === 0) {
+            throw new funnel_core_1.NotFoundError('No changes to publish in ChangeSet');
+        }
+        // or throw if changeset has errors
+        else if (errors) {
+            throw new funnel_core_1.DependencyError('Cannot publish ChangeSet with errors');
+        }
+        // try to publish
+        try {
+            // publish changeset (transactional)
+            const data = await this.provider.customRequest({
+                command: 'changeset/commit',
+                method: 'POST',
+                params: { changeSetId }
+            });
+            console.debug('[StrapiChangeSetClient] publish complete:', data);
+            // update changeset
+            return serialization_1.ChangeSetData.deserialize(data);
+        }
+        // handle errors
+        catch (e) {
+            throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+        }
+    }
+    async revert({ changeSetId, changeIds = [] }) {
+        // fetch changeset
+        const changeSet = await this.resolve({ id: changeSetId });
+        const { pageChanges, collectionChanges, publishedOn } = changeSet;
+        // throw if changeset is already published
+        if (publishedOn) {
+            throw new funnel_core_1.InvalidOperationError('Cannot revert changes of published ChangeSet');
+        }
+        // throw if changeset is empty (shouldn't happen)
+        else if (pageChanges.length === 0 && collectionChanges.length === 0) {
+            throw new funnel_core_1.NotFoundError('No changes to in ChangeSet to revert');
+        }
+        // or throw if a change isn't found in the set
+        else if (changeIds.length > 0
+            && !changeIds.some(changeId => pageChanges.some(change => change.id === changeId)
+                || collectionChanges.some(change => change.id === changeId))) {
+            throw new RangeError('Some changes don\'t exist in the ChangeSet');
+        }
+        // try to revert
+        try {
+            // revert changeset (transactional)
+            const data = await this.provider.customRequest({
+                command: 'changeset/revert',
+                method: 'POST',
+                params: { changeSetId },
+                data: JSON.stringify(changeIds)
+            });
+            // update changeset
+            return data ? serialization_1.ChangeSetData.deserialize(data) : false;
+        }
+        // handle errors
+        catch (e) {
+            throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+        }
+    }
+}
+exports.StrapiChangeSetClient = StrapiChangeSetClient;

package/dist/strapi/StrapiCollectionClient.d.ts

@@ -0,0 +1,18 @@
+import { CollectionClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiCollectionClient implements CollectionClient {
+    private readonly provider;
+    constructor(provider: IStrapiContentClient);
+    getOverview({ brand, version }: CollectionClient.GetOverview.Args): Promise<CollectionClient.GetOverview.Result>;
+    getItems({ brand, type, language, tags, version }: CollectionClient.GetItems.Args): Promise<CollectionClient.GetItems.Result>;
+    find({ pagination, ...args }: CollectionClient.Find.Args): Promise<CollectionClient.Find.Result>;
+    getGroup({ version, type, brand, groupId, language }: CollectionClient.GetGroup.Args): Promise<CollectionClient.GetGroup.Result>;
+    get({ version, id }: CollectionClient.Get.Args): Promise<CollectionClient.Get.Result>;
+    create(args: CollectionClient.Create.Args): Promise<CollectionClient.Create.Result>;
+    duplicate({ source: collectionId, targetCollection, targetLanguage }: CollectionClient.Duplicate.Args): Promise<CollectionClient.Duplicate.Result>;
+    update({ id: collectionId, errors, updates }: CollectionClient.Update.Args): Promise<CollectionClient.Update.Result>;
+    replace({ updatedCollection, version, skipSync }: CollectionClient.Replace.Args): Promise<CollectionClient.Replace.Result>;
+    unpublish(collectionId: CollectionClient.Unpublish.Args): Promise<CollectionClient.Unpublish.Result>;
+    getDependants({ id: collectionId, version }: CollectionClient.GetDependants.Args): Promise<CollectionClient.GetDependants.Result>;
+    getDependencies({ id: collectionId, version }: CollectionClient.GetDependencies.Args): Promise<CollectionClient.GetDependencies.Result>;
+}