strapi-plugin-navigation 2.0.13 → 2.1.0

package/server/i18n/navigationSetupStrategy.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nNavigationSetupStrategy = void 0;
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+const errors_1 = require("./errors");
+const i18nNavigationSetupStrategy = async ({ strapi, }) => {
+    const pluginStore = strapi.store({
+        type: "plugin",
+        name: "navigation",
+    });
+    const config = await pluginStore.get({
+        key: "config",
+    });
+    let currentNavigations = await getCurrentNavigations(strapi);
+    const localeService = strapi.plugin("i18n").service("locales");
+    const defaultLocale = await localeService.getDefaultLocale();
+    const allLocale = (await localeService.find({})).map(({ code }) => code);
+    (0, types_1.assertNotEmpty)(defaultLocale, new errors_1.DefaultLocaleMissingError());
+    if (config.i18nEnabled) {
+        const hasNotAnyLocale = ({ localeCode }) => !localeCode;
+        if (currentNavigations.length === 0) {
+            currentNavigations = [
+                await createDefaultI18nNavigation({ strapi, defaultLocale }),
+            ];
+        }
+        if (currentNavigations.some(hasNotAnyLocale)) {
+            currentNavigations = await Promise.all(currentNavigations.map(async (navigation) => {
+                return hasNotAnyLocale(navigation)
+                    ? await updateNavigation({
+                        strapi,
+                        current: navigation,
+                        payload: {
+                            localeCode: defaultLocale,
+                        },
+                        populate: utils_1.DEFAULT_POPULATE,
+                    })
+                    : navigation;
+            }));
+        }
+        await Promise.all(currentNavigations
+            .filter(({ localeCode }) => defaultLocale === localeCode)
+            .flatMap(async (rootNavigation) => {
+            const localizations = [
+                ...(rootNavigation.localizations ?? []).map((localization) => (0, types_1.assertEntity)(localization, "Navigation")),
+                rootNavigation,
+            ];
+            for (const locale of allLocale) {
+                if (!localizations.some(({ localeCode }) => localeCode === locale)) {
+                    localizations.push(await createNavigation({
+                        strapi,
+                        payload: {
+                            localeCode: locale,
+                            slug: `${rootNavigation.slug}-${locale}`,
+                            name: rootNavigation.name,
+                            visible: true,
+                        },
+                    }));
+                }
+            }
+            return await Promise.all(localizations.map((current) => updateNavigation({
+                strapi,
+                current,
+                payload: {
+                    localizations: localizations.filter(({ id }) => id !== current.id),
+                },
+            })));
+        }));
+    }
+    else {
+        if (config.pruneObsoleteI18nNavigations) {
+            await deleteNavigations({
+                strapi,
+                where: { localeCode: { $not: defaultLocale } },
+            });
+            await pluginStore.set({
+                key: "config",
+                value: {
+                    ...config,
+                    pruneObsoleteI18nNavigations: false,
+                },
+            });
+        }
+        const remainingNavigations = await getCurrentNavigations(strapi);
+        if (!remainingNavigations.length) {
+            await createDefaultI18nNavigation({ strapi, defaultLocale });
+        }
+    }
+    return getCurrentNavigations(strapi);
+};
+exports.i18nNavigationSetupStrategy = i18nNavigationSetupStrategy;
+const getCurrentNavigations = (strapi) => strapi.plugin("navigation").service("admin").get();
+const createNavigation = ({ strapi, payload, populate, }) => strapi.query("plugin::navigation.navigation").create({
+    data: {
+        ...payload,
+    },
+    populate,
+});
+const updateNavigation = ({ strapi, current, payload, populate, }) => strapi.query("plugin::navigation.navigation").update({
+    data: {
+        ...payload,
+    },
+    populate,
+    where: {
+        id: current.id,
+    },
+});
+const deleteNavigations = ({ strapi, where, }) => strapi.query("plugin::navigation.navigation").deleteMany({
+    where,
+});
+const createDefaultI18nNavigation = ({ strapi, defaultLocale }) => createNavigation({
+    strapi,
+    payload: {
+        ...utils_1.DEFAULT_NAVIGATION_ITEM,
+        localeCode: defaultLocale,
+    },
+    populate: utils_1.DEFAULT_POPULATE,
+});
+//# sourceMappingURL=navigationSetupStrategy.js.map

package/server/i18n/serviceEnhancers.d.ts

@@ -0,0 +1,13 @@
+import { AddI18NConfigFieldsInput, AddI18nWhereClause, HandleLocaleParamInput, I18nAwareEntityReadHandlerInput, I18NConfigFields, I18nNavigationContentsCopyInput, I18nNavigationItemReadInput } from "./types";
+export declare const addI18NConfigFields: <T>({ previousConfig, strapi, viaSettingsPage, }: AddI18NConfigFieldsInput<T>) => Promise<T & I18NConfigFields>;
+export declare const handleLocaleQueryParam: ({ locale, strapi, }: HandleLocaleParamInput) => Promise<string | undefined>;
+export declare const i18nAwareEntityReadHandler: <T extends {
+    localeCode?: string | null | undefined;
+    localizations?: T[] | null | undefined;
+}>({ entity, entityUid, localeCode, populate, strapi, whereClause, }: I18nAwareEntityReadHandlerInput<T>) => Promise<T | null | undefined>;
+export declare const addI18nWhereClause: <T>({ modelUid, previousWhere, query, strapi, }: AddI18nWhereClause<T>) => Promise<T & {
+    locale?: string | undefined;
+}>;
+export declare const i18nNavigationContentsCopy: ({ target, source, strapi, service, }: I18nNavigationContentsCopyInput) => Promise<void>;
+export declare const i18nNavigationItemRead: ({ target, source, path, strapi }: I18nNavigationItemReadInput) => Promise<Partial<any>>;
+//# sourceMappingURL=serviceEnhancers.d.ts.map

package/server/i18n/serviceEnhancers.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nNavigationItemRead = exports.i18nNavigationContentsCopy = exports.addI18nWhereClause = exports.i18nAwareEntityReadHandler = exports.handleLocaleQueryParam = exports.addI18NConfigFields = void 0;
+const utils_1 = require("@strapi/utils");
+const lodash_1 = require("lodash");
+const fp_1 = require("lodash/fp");
+const types_1 = require("../../types");
+const InvalidParamNavigationError_1 = require("../../utils/InvalidParamNavigationError");
+const utils_2 = require("../utils");
+const constant_1 = require("./constant");
+const errors_1 = require("./errors");
+const utils_3 = require("./utils");
+const addI18NConfigFields = async ({ previousConfig, strapi, viaSettingsPage = false, }) => {
+    const { enabled, hasI18NPlugin, defaultLocale } = await (0, utils_3.getI18nStatus)({
+        strapi,
+    });
+    return {
+        ...previousConfig,
+        defaultLocale,
+        i18nEnabled: enabled,
+        isI18NPluginEnabled: viaSettingsPage ? hasI18NPlugin : undefined,
+        pruneObsoleteI18nNavigations: false,
+    };
+};
+exports.addI18NConfigFields = addI18NConfigFields;
+const handleLocaleQueryParam = async ({ locale, strapi, }) => {
+    const { enabled } = await (0, utils_3.getI18nStatus)({ strapi });
+    if (locale) {
+        return locale;
+    }
+    const localeService = strapi.plugin("i18n").service("locales");
+    const defaultLocale = await localeService.getDefaultLocale();
+    (0, types_1.assertNotEmpty)(defaultLocale, new errors_1.DefaultLocaleMissingError());
+    return enabled ? defaultLocale : undefined;
+};
+exports.handleLocaleQueryParam = handleLocaleQueryParam;
+const i18nAwareEntityReadHandler = async ({ entity, entityUid, localeCode, populate = [], strapi, whereClause, }) => {
+    const { defaultLocale, enabled } = await (0, utils_3.getI18nStatus)({ strapi });
+    if (!enabled) {
+        return entity;
+    }
+    if (entity && (!localeCode || entity.localeCode === localeCode)) {
+        return entity;
+    }
+    const locale = localeCode || defaultLocale;
+    const rerun = await strapi.query(entityUid).findOne({
+        where: whereClause,
+        populate: [...populate, ...constant_1.I18N_DEFAULT_POPULATE],
+    });
+    if (rerun) {
+        if (rerun.localeCode === locale) {
+            return rerun;
+        }
+        return rerun.localizations?.find((localization) => localization.localeCode === locale);
+    }
+};
+exports.i18nAwareEntityReadHandler = i18nAwareEntityReadHandler;
+const addI18nWhereClause = async ({ modelUid, previousWhere, query, strapi, }) => {
+    const { enabled } = await (0, utils_3.getI18nStatus)({ strapi });
+    const modelSchema = strapi.getModel(modelUid);
+    if (enabled && query.localeCode && modelSchema.attributes.locale) {
+        return {
+            ...previousWhere,
+            locale: query.localeCode,
+        };
+    }
+    return previousWhere;
+};
+exports.addI18nWhereClause = addI18nWhereClause;
+const i18nNavigationContentsCopy = async ({ target, source, strapi, service, }) => {
+    const sourceItems = source.items ?? [];
+    if (target.items?.length) {
+        throw new errors_1.FillNavigationError("Current navigation is non-empty");
+    }
+    if (!target.localeCode) {
+        throw new errors_1.FillNavigationError("Current navigation does not have specified locale");
+    }
+    if (!sourceItems.length) {
+        throw new errors_1.FillNavigationError("Source navigation is empty");
+    }
+    const newItems = await Promise.all(sourceItems.map(processItems({
+        master: target,
+        localeCode: target.localeCode,
+        strapi,
+    })));
+    await service.createBranch(newItems, target, null, { create: true });
+};
+exports.i18nNavigationContentsCopy = i18nNavigationContentsCopy;
+const i18nNavigationItemRead = async ({ target, source, path, strapi }) => {
+    const pickFields = (0, fp_1.pick)(['path', 'related', 'type', 'uiRouterKey', 'title', 'externalPath']);
+    const structurePath = path.split('.').map(p => parseInt(p, 10));
+    if (!structurePath.some(Number.isNaN) || !structurePath.length) {
+        new InvalidParamNavigationError_1.InvalidParamNavigationError("Path is invalid");
+    }
+    let result = (0, lodash_1.get)(source.items, (0, utils_2.intercalate)("items", structurePath.map(lodash_1.toString)));
+    if (!result) {
+        throw new utils_1.errors.NotFoundError("Unable to find navigation item");
+    }
+    let { related } = result;
+    if (related) {
+        const fullRelated = await strapi.query(related.__contentType).findOne({
+            where: {
+                id: related.id,
+            },
+            populate: constant_1.I18N_DEFAULT_POPULATE,
+        });
+        if (fullRelated.localizations?.length) {
+            const localeVersion = fullRelated.localizations.find(({ locale }) => locale === target.localeCode);
+            if (localeVersion) {
+                related = {
+                    ...localeVersion,
+                    __contentType: related.__contentType
+                };
+            }
+        }
+    }
+    return pickFields({
+        ...result,
+        related
+    });
+};
+exports.i18nNavigationItemRead = i18nNavigationItemRead;
+const processItems = (context) => async (item) => ({
+    title: item.title,
+    path: item.path,
+    audience: item.audience,
+    type: item.type,
+    uiRouterKey: item.uiRouterKey,
+    order: item.order,
+    collapsed: item.collapsed,
+    menuAttached: item.menuAttached,
+    removed: false,
+    updated: true,
+    externalPath: item.externalPath ?? undefined,
+    items: item.items
+        ? await Promise.all(item.items.map(processItems(context)))
+        : [],
+    master: parseInt(context.master.id.toString(), 10),
+    parent: null,
+    related: item.related ? [await processRelated(item.related, context)] : [],
+});
+const processRelated = async (related, { localeCode, strapi }) => {
+    const { __contentType, id } = related;
+    (0, types_1.assertNotEmpty)(__contentType, new errors_1.FillNavigationError("Related item's content type is missing"));
+    (0, types_1.assertIsNumber)(id, new errors_1.FillNavigationError("Related item's id is not a number"));
+    const relatedItemWithLocalizations = await strapi
+        .query(__contentType)
+        .findOne({ where: { id }, populate: constant_1.I18N_DEFAULT_POPULATE });
+    const localization = relatedItemWithLocalizations.localizations?.find(({ locale }) => locale === localeCode);
+    return {
+        refId: localization?.id ?? id,
+        ref: __contentType,
+        field: related.field,
+    };
+};
+//# sourceMappingURL=serviceEnhancers.js.map

package/server/i18n/types.d.ts

@@ -0,0 +1,60 @@
+import { IStrapi, OnlyStrings, StringMap, WhereClause } from "strapi-typed";
+import { ICommonService, Navigation, NavigationItemInput, NestedStructure, NotVoid } from "../../types";
+export declare type AddI18NConfigFieldsInput<T> = {
+    previousConfig: T;
+    strapi: IStrapi;
+    viaSettingsPage?: boolean;
+};
+export declare type HandleLocaleParamInput = {
+    locale?: string;
+    strapi: IStrapi;
+};
+export declare type I18nAwareEntityReadHandlerInput<T> = {
+    entity: T | undefined | null;
+    entityUid: string;
+    whereClause: WhereClause<OnlyStrings<keyof T>>;
+    localeCode?: string;
+    strapi: IStrapi;
+    populate?: string[];
+};
+export declare type I18NConfigFields = {
+    i18nEnabled: boolean;
+    isI18NPluginEnabled: boolean | undefined;
+    pruneObsoleteI18nNavigations: boolean;
+    defaultLocale?: string | null;
+};
+export declare type AddI18nWhereClause<T> = {
+    previousWhere: T;
+    strapi: IStrapi;
+    query: StringMap<string> & {
+        localeCode?: string;
+    };
+    modelUid: string;
+};
+export declare type I18nNavigationContentsCopyInput = {
+    target: Navigation;
+    source: Navigation;
+    service: ICommonService;
+    strapi: IStrapi;
+};
+export declare type I18nNavigationItemReadInput = {
+    path: string;
+    source: Navigation;
+    strapi: IStrapi;
+    target: Navigation;
+};
+export declare type SourceNavigationItem = NestedStructure<NotVoid<Navigation["items"]>[0]>;
+export declare type ResultNavigationItem = NestedStructure<NavigationItemInput>;
+export declare type FillCopyContext = {
+    master: Navigation;
+    strapi: IStrapi;
+    localeCode: string;
+};
+export declare type MinimalEntityWithI18n = {
+    id: number;
+    localizations?: Array<{
+        id: number;
+        locale?: string;
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map

package/server/i18n/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/server/i18n/utils.d.ts

@@ -0,0 +1,12 @@
+import { IStrapi } from "strapi-typed";
+declare type GetI18nStatusInput = {
+    strapi: IStrapi;
+};
+declare type I18NStatus = {
+    hasI18NPlugin: boolean;
+    enabled: boolean;
+    defaultLocale?: string | null;
+};
+export declare const getI18nStatus: ({ strapi, }: GetI18nStatusInput) => Promise<I18NStatus>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/server/i18n/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getI18nStatus = void 0;
+const getI18nStatus = async ({ strapi, }) => {
+    const i18nPlugin = strapi.plugin("i18n");
+    const hasI18NPlugin = !!i18nPlugin;
+    const pluginStore = strapi.store({
+        type: "plugin",
+        name: "navigation",
+    });
+    const config = await pluginStore.get({
+        key: "config",
+    });
+    const localeService = i18nPlugin ? i18nPlugin.service("locales") : null;
+    const defaultLocale = await localeService?.getDefaultLocale();
+    return hasI18NPlugin
+        ? {
+            hasI18NPlugin,
+            enabled: config.i18nEnabled,
+            defaultLocale,
+        }
+        : {
+            hasI18NPlugin,
+            enabled: false,
+            defaultLocale: undefined,
+        };
+};
+exports.getI18nStatus = getI18nStatus;
+//# sourceMappingURL=utils.js.map

package/server/index.d.ts

@@ -0,0 +1,273 @@
+declare const _default: {
+    bootstrap: ({ strapi }: import("strapi-typed").StrapiContext) => Promise<void>;
+    config: import("../types").StrapiConfig<import("../types").NavigationPluginConfig>;
+    contentTypes: {
+        audience: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    comment: string;
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    key: {
+                        type: string;
+                        targetField: string;
+                    };
+                };
+            };
+        };
+        navigation: {
+            lifecycle: {
+                renderType: {
+                    FLAT: string;
+                    TREE: string;
+                    RFR: string;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        target: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    visible: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    items: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    localizations: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    localeCode: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        "navigation-item": {
+            lifecycle: {
+                type: {
+                    INTERNAL: string;
+                    EXTERNAL: string;
+                    WRAPPER: string;
+                };
+                additionalFields: {
+                    AUDIENCE: string;
+                };
+                lifecycles: {
+                    afterFind(results: any): void;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    timestamps: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    title: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        configurable: boolean;
+                    };
+                    path: {
+                        type: string;
+                        targetField: string;
+                        configurable: boolean;
+                    };
+                    externalPath: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    uiRouterKey: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    menuAttached: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    order: {
+                        type: string;
+                        default: number;
+                        configurable: boolean;
+                    };
+                    collapsed: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    related: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    parent: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                        default: null;
+                    };
+                    master: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    audience: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                };
+            };
+        };
+        "navigations-items-related": {
+            lifecycle: {
+                lifecycles: {
+                    afterFind(results: any): void;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    timestamps: boolean;
+                    populateCreatorFields: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    related_id: {
+                        type: string;
+                        required: boolean;
+                    };
+                    related_type: {
+                        type: string;
+                        required: boolean;
+                    };
+                    field: {
+                        type: string;
+                        required: boolean;
+                    };
+                    order: {
+                        type: string;
+                        required: boolean;
+                    };
+                    master: {
+                        type: string;
+                        required: boolean;
+                    };
+                };
+            };
+        };
+    };
+    controllers: import("../types").NavigationController;
+    destroy: () => void;
+    middlewares: {};
+    policies: {};
+    register: () => Promise<void>;
+    routes: {
+        admin: import("../types").StrapiRoutes;
+        'content-api': import("../types").StrapiRoutes;
+    };
+    services: {
+        common: (context: import("strapi-typed").StrapiContext) => import("../types").ICommonService;
+        admin: (context: import("strapi-typed").StrapiContext) => import("../types").IAdminService;
+        client: (context: import("strapi-typed").StrapiContext) => import("../types").IClientService;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map