strapi-plugin-navigation 2.0.11 → 2.1.0-beta.1

package/server/i18n/serviceEnhancers.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nNavigationContentsCopy = exports.addI18nWhereClause = exports.i18nAwareEntityReadHandler = exports.handleLocaleQueryParam = exports.addI18NConfigFields = void 0;
+const types_1 = require("../../types");
+const constant_1 = require("./constant");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+const addI18NConfigFields = async ({ previousConfig, strapi, viaSettingsPage = false, }) => {
+    const { enabled, hasI18NPlugin, defaultLocale } = await (0, utils_1.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_1.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_1.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_1.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 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,54 @@
+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 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

package/server/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bootstrap_1 = __importDefault(require("./bootstrap"));
+const config_1 = __importDefault(require("./config"));
+const content_types_1 = __importDefault(require("./content-types"));
+const controllers_1 = __importDefault(require("./controllers"));
+const destroy_1 = __importDefault(require("./destroy"));
+const register_1 = __importDefault(require("./register"));
+const routes_1 = __importDefault(require("./routes"));
+const services_1 = __importDefault(require("./services"));
+exports.default = {
+    bootstrap: bootstrap_1.default,
+    config: config_1.default,
+    contentTypes: content_types_1.default,
+    controllers: controllers_1.default,
+    destroy: destroy_1.default,
+    middlewares: {},
+    policies: {},
+    register: register_1.default,
+    routes: routes_1.default,
+    services: services_1.default,
+};
+//# sourceMappingURL=index.js.map

package/server/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setupStrategy";
+//# sourceMappingURL=index.d.ts.map

package/server/navigation/index.js

@@ -0,0 +1,18 @@
+"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("./setupStrategy"), exports);
+//# sourceMappingURL=index.js.map

package/server/navigation/setupStrategy.d.ts

@@ -0,0 +1,3 @@
+import { INavigationSetupStrategy } from "../../types";
+export declare const navigationSetupStrategy: INavigationSetupStrategy;
+//# sourceMappingURL=setupStrategy.d.ts.map

package/server/navigation/setupStrategy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigationSetupStrategy = void 0;
+const i18n_1 = require("../i18n");
+const utils_1 = require("../utils");
+const navigationSetupStrategy = async (context) => {
+    if (context.strapi.plugin("i18n")) {
+        return await (0, i18n_1.i18nNavigationSetupStrategy)(context);
+    }
+    else {
+        return await regularNavigationSetupStrategy(context);
+    }
+};
+exports.navigationSetupStrategy = navigationSetupStrategy;
+const regularNavigationSetupStrategy = async ({ strapi, }) => {
+    const navigations = await getCurrentNavigations();
+    if (!navigations.length) {
+        return [
+            await createNavigation({
+                strapi,
+                payload: {
+                    ...utils_1.DEFAULT_NAVIGATION_ITEM,
+                },
+                populate: utils_1.DEFAULT_POPULATE
+            }),
+        ];
+    }
+    return navigations;
+};
+const createNavigation = ({ strapi, payload, populate }) => strapi.query("plugin::navigation.navigation").create({
+    data: {
+        ...payload,
+    },
+    populate,
+});
+const getCurrentNavigations = () => (0, utils_1.getPluginService)('admin').get();
+//# sourceMappingURL=setupStrategy.js.map

package/server/register/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/server/register/index.js

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

package/server/routes/admin.d.ts

@@ -0,0 +1,4 @@
+import { StrapiRoutes } from "../../types";
+declare const routes: StrapiRoutes;
+export default routes;
+//# sourceMappingURL=admin.d.ts.map