@nascentdigital/funnel-cms 4.4.4

package/dist/models/User.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const Role_1 = require("./Role");
+// class
+class User {
+    constructor(data) {
+        this.data = data;
+        // get a role instance from the role id
+        this.role = Role_1.Role.fromId(data.role);
+    }
+    get isOwner() {
+        const { role } = this;
+        return role.id === 'owner';
+    }
+    get isAdmin() {
+        const { role } = this;
+        return role.id === 'owner' || role.id === 'admin';
+    }
+    get isEditor() {
+        return this.role.id === 'editor';
+    }
+    get isViewer() {
+        return this.role.id === 'viewer';
+    }
+    get id() {
+        return this.data.id;
+    }
+    get brands() {
+        return this.data.brands;
+    }
+    get username() {
+        return this.data.username;
+    }
+    get email() {
+        return this.data.email;
+    }
+    get blocked() {
+        return this.data.blocked;
+    }
+    has(...privileges) {
+        return this.role.has(...privileges);
+    }
+    hasAny(...privileges) {
+        return this.role.hasAny(...privileges);
+    }
+    compareTo(that) {
+        // same if equivalent
+        if (this.id === that.id) {
+            return 0;
+        }
+        // or compare role
+        const roleComparison = this.role.compareTo(that.role);
+        return roleComparison === 0
+            ? this.username.localeCompare(that.username)
+            : roleComparison;
+    }
+}
+exports.User = User;
+// extension
+(function (User) {
+    // constant for unauthenticated user
+    User.UNAUTHENTICATED = new User({
+        id: 'unauthenticated',
+        username: 'unauthenticated',
+        email: 'unauthenticated',
+        blocked: true,
+        brands: [],
+        role: 'public'
+    });
+})(User || (exports.User = User = {}));

package/dist/models/Versioned.d.ts

@@ -0,0 +1,22 @@
+import { Entity } from './Entity';
+export declare class Versioned<TEntity extends Entity<unknown>> {
+    readonly published: TEntity | undefined;
+    readonly draft: TEntity;
+    constructor({ published, draft }: Versioned.ConstructorArgs<TEntity>);
+    get state(): Versioned.State;
+    /**
+     * Returns draft/modified version if new/changed, otherwise this return the last published version.
+     */
+    get current(): TEntity;
+    get id(): TEntity['id'];
+    toData(): Versioned.Data<TEntity>;
+}
+export declare namespace Versioned {
+    type Target = 'published' | 'draft' | 'all';
+    type State = 'draft' | 'published' | 'modified';
+    type ConstructorArgs<TEntity extends Entity<unknown>> = Data<TEntity>;
+    type Data<TEntity extends Entity<unknown>> = {
+        published?: TEntity;
+        draft: TEntity;
+    };
+}

package/dist/models/Versioned.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Versioned = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class Versioned {
+    constructor({ published, draft }) {
+        // initialize instance variables
+        this.published = published;
+        this.draft = draft;
+        // verify the args
+        if (!published && !draft) {
+            throw new funnel_core_1.IllegalStateError('Versioned entity must have either published or draft value');
+        }
+    }
+    get state() {
+        const { published, draft } = this;
+        return published
+            ? draft
+                ? 'modified'
+                : 'published'
+            : 'draft';
+    }
+    /**
+     * Returns draft/modified version if new/changed, otherwise this return the last published version.
+     */
+    get current() {
+        // get id (or throw)
+        const { published, draft } = this;
+        const current = draft !== null && draft !== void 0 ? draft : published;
+        if (!current) {
+            throw new funnel_core_1.IllegalStateError('Versioned entity must have either published or draft value');
+        }
+        // return latest
+        return current;
+    }
+    get id() {
+        return this.current.id;
+    }
+    toData() {
+        const { published, draft } = this;
+        return { published, draft };
+    }
+}
+exports.Versioned = Versioned;

package/dist/models/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Entity';
+export * from './Environment';
+export * from './Pagination';
+export * from './Privilege';
+export * from './Role';
+export * from './SiteConfig';
+export * from './Upgrade';
+export * from './User';
+export * from './Versioned';

package/dist/models/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entity"), exports);
+__exportStar(require("./Environment"), exports);
+__exportStar(require("./Pagination"), exports);
+__exportStar(require("./Privilege"), exports);
+__exportStar(require("./Role"), exports);
+__exportStar(require("./SiteConfig"), exports);
+__exportStar(require("./Upgrade"), exports);
+__exportStar(require("./User"), exports);
+__exportStar(require("./Versioned"), exports);

package/dist/strapi/IStrapiContentClient.d.ts

@@ -0,0 +1,39 @@
+import { Callback } from '@nascentdigital/funnel-core';
+import { StrapiClient } from '@strapi/client';
+import { Jsonify, JsonValue } from 'type-fest';
+import { AuthClient } from '../api';
+import { CollectionData, PageData } from './serialization';
+import type { StrapiAssetClient } from './StrapiAssetClient';
+import type { StrapiAuthClient } from './StrapiAuthClient';
+import type { StrapiChangeSetClient } from './StrapiChangeSetClient';
+import type { StrapiCollectionClient } from './StrapiCollectionClient';
+import type { StrapiPageClient } from './StrapiPageClient';
+import type { StrapiSiteConfigClient } from './StrapiSiteConfigClient';
+import type { StrapiUserClient } from './StrapiUserClient';
+export interface IStrapiContentClient {
+    readonly token: AuthClient.AccessToken;
+    readonly client: StrapiClient;
+    readonly auth: StrapiAuthClient;
+    readonly changeSets: StrapiChangeSetClient;
+    readonly files: StrapiAssetClient;
+    readonly pages: StrapiPageClient;
+    readonly collections: StrapiCollectionClient;
+    readonly users: StrapiUserClient;
+    readonly siteConfig: StrapiSiteConfigClient;
+    customRequest<TResult extends JsonValue = JsonValue, TError extends JsonValue = JsonValue>(args: IStrapiContentClient.CustomRequestArgs<TError>): Promise<TResult>;
+}
+export declare namespace IStrapiContentClient {
+    type CustomRequestArgs<TError extends JsonValue = JsonValue> = {
+        command: CustomCommand;
+        params?: Record<string, unknown>;
+        data?: string;
+        method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+        onError?: Callback<TError>;
+    };
+    type CustomCommand = 'changeset/query' | 'changeset/commit' | 'changeset/revert' | 'query/pages' | 'query/rank-pages' | 'query/collections' | 'query/collection' | 'publish' | 'unpublish' | 'version';
+    type UnpublishErrorData = Jsonify<{
+        error: true;
+        pageRefs: PageData.Ref[];
+        collectionRefs: CollectionData.Ref[];
+    }>;
+}

package/dist/strapi/IStrapiContentClient.js

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

package/dist/strapi/Strapi.d.ts

@@ -0,0 +1,37 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { API as StrapiApi, CollectionTypeManager, StrapiClient } from '@strapi/client';
+import { StringKeyOf } from 'type-fest';
+import { Pagination } from '../models';
+import { StrapiData } from './models';
+import { CollectionData, PageData } from './serialization';
+export declare namespace Strapi {
+    type PaginateArgs<TCollection extends StrapiData> = Omit<StrapiApi.BaseQueryParams, 'fields' | 'locale' | 'pagination'> & {
+        collection: CollectionTypeManager;
+        pagination: Pagination;
+        fields?: Array<StringKeyOf<TCollection>>;
+    };
+    function paginate<TCollection extends StrapiData>({ collection, pagination, status, fields, ...query }: PaginateArgs<TCollection>): Promise<Pagination.Paginated<TCollection>>;
+    namespace TranslateReferences {
+        type Args = {
+            client: StrapiClient;
+            targetLanguage: Language;
+            pageRefs?: PageData.Ref[];
+            collectionRefs?: CollectionData.Ref[];
+        };
+        type Result = {
+            pageIdMappings: IdMapping<Schema.Page.Id>[];
+            collectionIdMappings: IdMapping<Schema.Collection.Id>[];
+        };
+    }
+    function translateReferences({ client, targetLanguage, pageRefs, collectionRefs }: TranslateReferences.Args): Promise<TranslateReferences.Result>;
+    type UpdateRefsArgs<T> = {
+        value: T;
+        pageIdMappings?: IdMapping<Schema.Page.Id>[];
+        collectionIdMappings?: IdMapping<Schema.Collection.Id>[];
+    };
+    function updateRefs<T>({ value, pageIdMappings, collectionIdMappings }: UpdateRefsArgs<T>): T;
+    type IdMapping<T extends string> = {
+        sourceId: T;
+        targetId: T;
+    };
+}

package/dist/strapi/Strapi.js

@@ -0,0 +1,156 @@
+"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.Strapi = void 0;
+const errors_1 = require("../errors");
+const serialization_1 = require("./serialization");
+// extension
+var Strapi;
+(function (Strapi) {
+    async function paginate(_a) {
+        var _b, _c, _d, _e;
+        var { collection, pagination, status = 'published', fields } = _a, query = __rest(_a, ["collection", "pagination", "status", "fields"]);
+        // drain all pages while there are more pages
+        const items = [];
+        let hasMorePages = true;
+        let page = pagination === 'all' ? 1 : pagination.page;
+        const pageSize = pagination === 'all' ? 100 : pagination.pageSize;
+        let totalItemCount = 0;
+        let pageCount = 1;
+        do {
+            // get next page
+            const { data, meta } = await collection.find(Object.assign(Object.assign({}, query), { fields,
+                status, pagination: {
+                    page,
+                    pageSize
+                } }));
+            // merge results
+            items.push(...data);
+            // update paging info
+            pageCount = (_c = (_b = meta === null || meta === void 0 ? void 0 : meta.pagination) === null || _b === void 0 ? void 0 : _b.pageCount) !== null && _c !== void 0 ? _c : 0;
+            totalItemCount = (_e = (_d = meta === null || meta === void 0 ? void 0 : meta.pagination) === null || _d === void 0 ? void 0 : _d.total) !== null && _e !== void 0 ? _e : 0;
+            hasMorePages = pagination === 'all'
+                ? ++page <= pageCount
+                : false;
+        } while (hasMorePages);
+        // return results
+        return {
+            items,
+            page: pagination === 'all' ? 1 : page,
+            pageCount: pagination === 'all' ? 1 : pageCount,
+            totalItemCount
+        };
+    }
+    Strapi.paginate = paginate;
+    async function translateReferences({ client, targetLanguage, pageRefs = [], collectionRefs = [] }) {
+        // setup return values
+        const pageIdMappings = [];
+        const collectionIdMappings = [];
+        // bail if no refs
+        if (pageRefs.length === 0 && collectionRefs.length === 0) {
+            return { pageIdMappings, collectionIdMappings };
+        }
+        // setup collections
+        const pageCollection = client.collection('pages');
+        const collectionCollection = client.collection('collections');
+        // try to find each item in target language
+        const [{ items: pagesInTargetLang }, { items: collectionsInTargetLang }] = await Promise.all([
+            Strapi.paginate({
+                collection: pageCollection,
+                pagination: 'all',
+                filters: {
+                    groupId: { $in: pageRefs.map(ref => ref.groupId) },
+                    lang: targetLanguage
+                },
+                status: 'draft'
+            }),
+            Strapi.paginate({
+                collection: collectionCollection,
+                pagination: 'all',
+                filters: {
+                    groupId: { $in: collectionRefs.map(ref => ref.groupId) },
+                    lang: targetLanguage
+                },
+                status: 'draft'
+            })
+        ]);
+        // go through each item to map ref to target language ref
+        const pageRefsMap = pageRefs.map(pageRef => {
+            const pageInTargetLang = pagesInTargetLang
+                .find(page => page.groupId === pageRef.groupId);
+            return { sourceRef: pageRef, targetRef: pageInTargetLang };
+        });
+        const collectionRefsMap = collectionRefs.map(collectionRef => {
+            const collectionInTargetLang = collectionsInTargetLang
+                .find(collection => collection.groupId === collectionRef.groupId);
+            return { sourceRef: collectionRef, targetRef: collectionInTargetLang };
+        });
+        console.debug('[TargetLanguageRefs] fetched ref groups', { pageRefsMap, collectionRefsMap });
+        // find refs with missing target language
+        const missingPageRefs = pageRefsMap
+            .filter(map => map.targetRef === undefined)
+            .map(map => map.sourceRef);
+        const missingCollectionRefs = collectionRefsMap
+            .filter(map => map.targetRef === undefined)
+            .map(map => map.sourceRef);
+        console.debug('[TargetLanguageRefs] missing refs', { missingPageRefs, missingCollectionRefs });
+        // throw if there are any missing refs in target language
+        if (missingPageRefs.length > 0 || missingCollectionRefs.length > 0) {
+            console.error('[TargetLanguageRefs] missing target refs', { missingPageRefs, missingCollectionRefs });
+            throw new errors_1.TranslateReferencesError({
+                message: 'Missing references in target language',
+                untranslatedPages: missingPageRefs.map(ref => serialization_1.PageData.deserializeRef(ref)),
+                untranslatedCollections: missingCollectionRefs.map(ref => serialization_1.CollectionData.deserializeRef(ref)),
+                targetLanguage,
+            });
+        }
+        // build mappings
+        for (const { sourceRef, targetRef } of pageRefsMap) {
+            // shouldn't happen because of check above
+            if (!targetRef) {
+                throw new Error('something went wrong');
+            }
+            pageIdMappings.push({
+                sourceId: sourceRef.documentId,
+                targetId: targetRef.documentId
+            });
+        }
+        for (const { sourceRef, targetRef } of collectionRefsMap) {
+            // shouldn't happen because of check above
+            if (!targetRef) {
+                throw new Error('something went wrong');
+            }
+            collectionIdMappings.push({
+                sourceId: sourceRef.documentId,
+                targetId: targetRef.documentId
+            });
+        }
+        // return results
+        return { pageIdMappings, collectionIdMappings };
+    }
+    Strapi.translateReferences = translateReferences;
+    function updateRefs({ value, pageIdMappings = [], collectionIdMappings = [] }) {
+        // return original value if there is no mappings
+        if (pageIdMappings.length === 0 && collectionIdMappings.length === 0) {
+            return value;
+        }
+        // TODO: recurse through object instead of using string replaceAll
+        // otherwise find/replace ids
+        let serialized = JSON.stringify(value);
+        for (const { sourceId, targetId } of [...pageIdMappings, ...collectionIdMappings]) {
+            serialized = serialized.replaceAll(sourceId, targetId);
+        }
+        return JSON.parse(serialized);
+    }
+    Strapi.updateRefs = updateRefs;
+})(Strapi || (exports.Strapi = Strapi = {}));

package/dist/strapi/StrapiAssetClient.d.ts

@@ -0,0 +1,11 @@
+import { AssetClient } from '../api';
+import type { IStrapiContentClient } from './IStrapiContentClient';
+export declare class StrapiAssetClient implements AssetClient {
+    private readonly provider;
+    constructor(provider: IStrapiContentClient);
+    getAssets({ brand, fileType, scope, tags, pagination }: AssetClient.GetAssets.Args): Promise<AssetClient.GetAssets.Result>;
+    getAsset(id: AssetClient.GetAsset.Args): Promise<AssetClient.GetAsset.Result>;
+    createAsset({ tags, ...asset }: AssetClient.CreateAsset.Args): Promise<AssetClient.CreateAsset.Result>;
+    updateAsset({ id, tags, ...update }: AssetClient.UpdateAsset.Args): Promise<AssetClient.UpdateAsset.Result>;
+    deleteAsset(id: AssetClient.DeleteAsset.Args): Promise<AssetClient.DeleteAsset.Result>;
+}

package/dist/strapi/StrapiAssetClient.js

@@ -0,0 +1,143 @@
+"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.StrapiAssetClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const models_1 = require("./models");
+const serialization_1 = require("./serialization");
+const Strapi_1 = require("./Strapi");
+// class
+class StrapiAssetClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async getAssets({ brand, fileType = [], scope, tags = [], pagination }) {
+        // build filters
+        const filters = [
+            {
+                $or: [
+                    { brand: { $eq: brand } },
+                    { brand: { $null: true } }
+                ]
+            }
+        ];
+        // filter mime types (if any)
+        const fileTypes = Array.isArray(fileType)
+            ? fileType
+            : [fileType];
+        if (fileTypes.length > 0) {
+            filters.push({
+                file: { mime: {
+                        $in: new Set(fileTypes.flatMap(fileType => funnel_core_1.MimeType.forFileType(fileType))).values().toArray()
+                    }
+                }
+            });
+        }
+        // filter scope (if any)
+        if ((scope === null || scope === void 0 ? void 0 : scope.target) === 'page') {
+            filters.push({
+                $or: [
+                    { scope: { $eq: funnel_core_1.Schema.AssetScope.global.data } },
+                    { scope: { $eq: new funnel_core_1.Schema.PageTypeAssetScope(scope.type).data } },
+                    { scope: { $eq: new funnel_core_1.Schema.PageInstanceAssetScope(scope.groupId).data } }
+                ]
+            });
+        }
+        else if ((scope === null || scope === void 0 ? void 0 : scope.target) === 'collection') {
+            filters.push({
+                $or: [
+                    { scope: { $eq: funnel_core_1.Schema.AssetScope.global.data } },
+                    { scope: { $eq: new funnel_core_1.Schema.CollectionTypeAssetScope(scope.type).data } },
+                    { scope: { $eq: new funnel_core_1.Schema.CollectionInstanceAssetScope(scope.groupId).data } }
+                ]
+            });
+        }
+        // filter tags (if any)
+        if (tags.length === 1) {
+            filters.push({ tags: { $contains: `"${tags[0]}"` } });
+        }
+        else if (tags.length > 1) {
+            filters.push({
+                $or: tags
+                    .filter((tag) => !!tag)
+                    .map((tag) => ({ tags: { $contains: `"${tag}"` } }))
+            });
+        }
+        // fetch all assets
+        const { client } = this.provider;
+        const collection = client.collection('assets');
+        const _a = await Strapi_1.Strapi.paginate({
+            collection,
+            pagination,
+            filters: filters.length > 1 ? { $and: filters } : filters[0],
+            populate: '*',
+            sort: ['updatedAt:desc']
+        }), { items } = _a, paginated = __rest(_a, ["items"]);
+        // transform to dtos
+        return Object.assign({ items: items
+                .map(data => serialization_1.StrapiAssetData.deserialize(data, client.baseURL))
+                .filter(funnel_core_1.Value.isDefined) }, paginated);
+    }
+    async getAsset(id) {
+        // fetch asset
+        const { client } = this.provider;
+        const collection = client.collection('assets');
+        const { data } = await collection.findOne(id, { populate: '*' });
+        console.debug('[StrapiAssetClient] found asset', data);
+        // return it (transformed)
+        return data
+            ? serialization_1.StrapiAssetData.deserialize(data, client.baseURL)
+            : undefined;
+    }
+    async createAsset(_a) {
+        var { tags } = _a, asset = __rest(_a, ["tags"]);
+        console.debug('[StrapiAssetClient/createAsset] creating file', Object.assign(Object.assign({}, asset), { tags }));
+        // create asset
+        const { client } = this.provider;
+        const collection = client.collection('assets');
+        const { data } = await collection.create(Object.assign(Object.assign({}, asset), { brand: funnel_core_1.AppConfig.brand(), tags: JSON.stringify(tags) }));
+        // return asset partial
+        return serialization_1.StrapiAssetData.deserialize(data, client.baseURL);
+    }
+    async updateAsset(_a) {
+        var { id, tags } = _a, update = __rest(_a, ["id", "tags"]);
+        console.debug('[StrapiAssetClient/updateAsset] updating file', Object.assign({ id }, update));
+        // create asset
+        const { client } = this.provider;
+        const collection = client.collection('assets');
+        const { data } = await collection.update(id, Object.assign(Object.assign({}, update), { tags: tags ? JSON.stringify(tags) : undefined }), { status: 'draft', populate: '*' });
+        // return asset
+        return serialization_1.StrapiAssetData.deserialize(data, client.baseURL);
+    }
+    async deleteAsset(id) {
+        var _a;
+        console.debug('[StrapiAssetClient/deleteAsset] deleting asset:', id);
+        // get asset (skip if it doesn't exist)
+        const { client } = this.provider;
+        const collection = client.collection('assets');
+        const asset = await this.getAsset(id);
+        if (!asset) {
+            console.debug('[StrapiAssetClient/deleteAsset] no asset to delete:', id);
+            return;
+        }
+        // delete asset
+        await collection.delete(id);
+        // delete underlying media file (if we have any - might be a zombie)
+        const { value } = asset;
+        if (models_1.StrapiAsset.filter(value) && ((_a = value.__internal) === null || _a === void 0 ? void 0 : _a.fileId)) {
+            console.debug('[StrapiAssetClient/deleteAsset] deleting associated file:', value.__internal.fileId);
+            await client.files.delete(value.__internal.fileId);
+        }
+    }
+}
+exports.StrapiAssetClient = StrapiAssetClient;

package/dist/strapi/StrapiAssetUploadClient.d.ts

@@ -0,0 +1,6 @@
+import { AssetUploadClient } from '../api';
+export declare class StrapiAssetUploadClient extends AssetUploadClient {
+    private readonly strapiUrl;
+    constructor(strapiUrl: string);
+    onUpload({ api, file: blob, brand, type, size, name, description, scope, tags, metadata }: AssetUploadClient.OnUpload.Args): Promise<AssetUploadClient.OnUpload.Result>;
+}