adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/lib/installStepper/finalizeStep.js

@@ -1,48 +0,0 @@
-import InstallStepAbstract from "./InstallStepAbstract";
-import * as path from "path";
-import { InstallStepper } from "./installStepper";
-export default class FinalizeStep extends InstallStepAbstract {
-    canBeSkipped = false;
-    description = '';
-    ejsPath = path.resolve(import.meta.dirname, '../../views/ejs/installer/partials/finalize.ejs');
-    id = 'finalize';
-    scriptsUrl = '';
-    sortOrder = 0;
-    stylesUrl = '';
-    title = 'Finalize Step';
-    badge = '';
-    isSkipped = false;
-    settingsKeys = [];
-    renderer = "ejs";
-    isProcessed = false;
-    async check() {
-        if (this.isProcessed) {
-            return true;
-        }
-        else {
-            let installStepper = InstallStepper.getInstance();
-            if (!installStepper.hasUnfinalizedSteps()) {
-                this.canBeSkipped = true;
-            }
-        }
-        return false;
-    }
-    async process(data) {
-        let installStepper = InstallStepper.getInstance();
-        if (!installStepper.hasUnfinalizedSteps()) {
-            this.isProcessed = true;
-        }
-    }
-    async skip() {
-        let installStepper = InstallStepper.getInstance();
-        if (!installStepper.hasUnfinalizedSteps()) {
-            this.isProcessed = true;
-        }
-    }
-    finally() {
-        return Promise.resolve();
-    }
-    toFinally() {
-        return;
-    }
-}

package/lib/installStepper/installStepper.d.ts

@@ -1,40 +0,0 @@
-import InstallStepAbstract from "./InstallStepAbstract";
-interface RenderData {
-    totalStepCount: number;
-    leftStepsCount: number;
-    currentStep: InstallStepAbstract;
-    locale: string;
-}
-export declare class InstallStepper {
-    id: string;
-    private steps;
-    context: any;
-    readonly canBeClosed: boolean;
-    static instances: InstallStepper[];
-    constructor(id: string, canBeClosed?: boolean);
-    static addStepper(stepper?: InstallStepper): void;
-    static getStepper(stepperId: string): InstallStepper;
-    static deleteStepper(stepperId: string): void;
-    static getInstance(): InstallStepper;
-    getSteps(): InstallStepAbstract[];
-    processStep(stepId: string, data: any): Promise<void>;
-    private getStepById;
-    /** Prepares steps array for user interface render */
-    render(req: ReqType): RenderData;
-    skipStep(stepId: string): Promise<void>;
-    /** Add step (replace if it already exists) */
-    addStep(step: InstallStepAbstract): void;
-    hasUnprocessedSteps(): boolean;
-    getNextUnprocessedStep(): InstallStepAbstract;
-    hasUnfinalizedSteps(): boolean;
-    getFinalizeStatus(): {
-        status: string;
-        finalizeList: {
-            id: string;
-            status: "pending" | "fulfilled" | "rejected";
-            description: string;
-            info: string;
-        }[];
-    };
-}
-export {};

package/lib/installStepper/installStepper.js

@@ -1,195 +0,0 @@
-import FinalizeStep from "./finalizeStep";
-import * as fs from "fs";
-import { TranslationHelper } from "../../helpers/translationHelper";
-import { Adminizer } from "../Adminizer";
-export class InstallStepper {
-    id;
-    steps = [];
-    context = {};
-    canBeClosed;
-    // TODO remove static fields for multi adminizer server
-    static instances = [];
-    constructor(id, canBeClosed = false) {
-        this.id = id;
-        this.canBeClosed = canBeClosed;
-    }
-    static addStepper(stepper) {
-        if (this.instances.find(item => item.id === stepper.id)) {
-            Adminizer.log.debug(`Stepper with id ${stepper.id} was deleted due to creating new one`);
-            this.deleteStepper(stepper.id);
-        }
-        this.instances.push(stepper);
-    }
-    static getStepper(stepperId) {
-        return this.instances.find(item => item.id === stepperId);
-    }
-    static deleteStepper(stepperId) {
-        let stepper = this.getStepper(stepperId);
-        if (!stepper.canBeClosed) {
-            Adminizer.log.error(`Can not delete stepper: Stepper with id ${stepperId} can not be closed.`);
-            throw `Can not delete stepper: Stepper with id ${stepperId} can not be closed`;
-        }
-        const index = this.instances.findIndex(item => item.id === stepperId);
-        if (index !== -1) {
-            this.instances.splice(index, 1);
-            Adminizer.log.info(`Stepper with id ${stepperId} has been deleted.`);
-        }
-        else {
-            Adminizer.log.error(`Can not delete stepper: Stepper with id ${stepperId} not found.`);
-            throw `Can not delete stepper: Stepper with id ${stepperId} not found.`;
-        }
-    }
-    static getInstance() {
-        if (!this.instances.length) {
-            let newStepper = new InstallStepper("project", false);
-            this.instances.push(newStepper);
-        }
-        return this.instances.find(item => item.id === "project");
-    }
-    getSteps() {
-        return this.steps;
-    }
-    async processStep(stepId, data) {
-        try {
-            /** As we sort steps by sortOrder, we should check that previous steps were processed */
-            const stepIndex = this.steps.findIndex(item => item.id === stepId);
-            Adminizer.log.debug("STEP INDEX", stepIndex);
-            for (let i = 0; i < stepIndex; i++) {
-                if (this.steps[i].canBeSkipped && this.steps[i].isSkipped) {
-                    continue;
-                }
-                let checkResult = await this.steps[i].check();
-                if (checkResult === false) {
-                    throw `Previous step was not processed`;
-                }
-            }
-            let step = this.getStepById(stepId);
-            // get context copy and write down information in it on process without damaging source object
-            let contextCopy = { ...this.context };
-            await step.process(data, contextCopy);
-            Object.assign(this.context, contextCopy);
-            step.isProcessed = true;
-            Adminizer.log.debug(`STEP ${stepId} was processed`);
-            // call finalize method only if has description
-            if (step.finallyToRun) {
-                contextCopy = { ...this.context };
-                step.toFinally(data, this.context);
-                Object.assign(this.context, contextCopy);
-            }
-        }
-        catch (e) {
-            Adminizer.log.error(`Error processing step: ${e}`);
-            throw new Error(e);
-        }
-    }
-    getStepById(stepId) {
-        return this.steps.find(item => item.id === stepId);
-    }
-    /** Prepares steps array for user interface render */
-    render(req) {
-        let stepToRender = this.getNextUnprocessedStep();
-        let leftSteps = this.steps.filter(step => !step.isProcessed && !step.isSkipped);
-        // set locale
-        if (typeof req.adminizer.config.translation !== "boolean") {
-            if (!req.user.locale || !req.adminizer.config.translation.locales.includes(req.user.locale)) {
-                req.user.locale = req.adminizer.config.translation.defaultLocale || "en";
-            }
-        }
-        else {
-            req.user.locale = "en";
-        }
-        this.context.locale = req.user.locale;
-        // translate step
-        stepToRender = TranslationHelper.translateProperties(req.i18n, stepToRender, ["title", "description", "name"]);
-        return {
-            totalStepCount: this.steps.length,
-            leftStepsCount: leftSteps.length,
-            currentStep: stepToRender,
-            locale: req.user.locale
-        };
-    }
-    async skipStep(stepId) {
-        try {
-            let step = this.getStepById(stepId);
-            await step.skipIt();
-            step.isSkipped = true;
-        }
-        catch (e) {
-            Adminizer.log.error(`Error skipping step: ${e}`);
-        }
-    }
-    /** Add step (replace if it already exists) */
-    addStep(step) {
-        if (step.renderer === "ejs") {
-            if (!step.ejsPath || !fs.existsSync(step.ejsPath)) {
-                throw `Step [${step.title}] error: ejs path does not exists`;
-            }
-        }
-        const stepIndex = this.steps.findIndex(item => item.id === step.id);
-        if (stepIndex !== -1) {
-            Adminizer.log.warn(`Attention! The step has been replaced\`${step.id}\``);
-            this.steps[stepIndex] = step;
-        }
-        else {
-            this.steps.push(step);
-        }
-        // sort by group, then by renderer and then by sortOrder
-        this.steps.sort((a, b) => {
-            if (a.groupSortOrder !== b.groupSortOrder) {
-                return a.groupSortOrder - b.groupSortOrder;
-            }
-            else {
-                if (a.renderer !== b.renderer) {
-                    return a.renderer === 'ejs' ? -1 : 1;
-                }
-                else {
-                    return a.sortOrder - b.sortOrder;
-                }
-            }
-        });
-    }
-    hasUnprocessedSteps() {
-        return this.steps.some(step => !step.isProcessed && !step.isSkipped);
-    }
-    getNextUnprocessedStep() {
-        let nextStep = this.steps.find(step => !step.isProcessed && !step.isSkipped);
-        if (!nextStep && this.hasUnfinalizedSteps()) {
-            if (this.getStepById("finalize")) {
-                nextStep = this.getStepById("finalize");
-            }
-            else {
-                let timer = setInterval(() => {
-                    // clear steps if all of them was processed and finalized
-                    if (!this.hasUnprocessedSteps() && !this.hasUnfinalizedSteps()) {
-                        this.steps = [];
-                        Adminizer.log.debug("CLEARING STEPS", this.steps);
-                        clearInterval(timer);
-                    }
-                }, 5000);
-                nextStep = new FinalizeStep();
-                this.addStep(nextStep);
-            }
-        }
-        return nextStep;
-    }
-    hasUnfinalizedSteps() {
-        return this.steps.some(step => step.finallyPromise?.status === "pending");
-    }
-    getFinalizeStatus() {
-        let stepsWithFinalize = this.steps.filter(step => step.finallyPromise !== null);
-        let generalStatus = "fulfilled";
-        let stepFinalizeStatuses = stepsWithFinalize.map(item => {
-            let info = null;
-            // if one of them is pending, general status is pending
-            if (item.finallyPromise.status === "pending") {
-                generalStatus = "pending";
-            }
-            if (item.finallyPromise.status === "rejected") {
-                generalStatus = "rejected";
-                info = `Error: ${item.finallyPromise.info}`;
-            }
-            return { id: item.id, status: item.finallyPromise.status, description: item.finallyDescription, info: info };
-        });
-        return { status: generalStatus, finalizeList: stepFinalizeStatuses ?? [] };
-    }
-}

package/models/MediaManagerAP.d.ts

@@ -1,62 +0,0 @@
-import { MediaManagerAssociationsAP } from "./MediaManagerAssociationsAP";
-import { MediaManagerMetaAP } from "./MediaManagerMetaAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    parent: {
-        model: string;
-    };
-    variants: {
-        collection: string;
-        via: string;
-    };
-    mimeType: {
-        type: string;
-    };
-    path: {
-        type: string;
-    };
-    size: {
-        type: string;
-    };
-    group: {
-        type: string;
-    };
-    tag: {
-        type: string;
-    };
-    url: {
-        type: string;
-    };
-    filename: {
-        type: string;
-    };
-    meta: {
-        collection: string;
-        via: string;
-    };
-    modelAssociation: {
-        collection: string;
-        via: string;
-    };
-};
-export default _default;
-export interface MediaManagerAP {
-    id: string;
-    parent?: MediaManagerAP;
-    variants?: MediaManagerAP[];
-    mimeType?: string;
-    path?: string;
-    size?: number;
-    group?: string;
-    tag?: string;
-    url?: string;
-    filename?: string;
-    meta?: MediaManagerMetaAP[];
-    modelAssociation?: MediaManagerAssociationsAP[];
-}

package/models/MediaManagerAP.js

@@ -1,45 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    parent: {
-        model: "MediaManagerAP"
-    },
-    variants: {
-        collection: "MediaManagerAP",
-        via: "parent"
-    },
-    mimeType: {
-        type: "string"
-    },
-    path: {
-        type: "string"
-    },
-    size: {
-        type: "number"
-    },
-    group: {
-        type: "string"
-    },
-    tag: {
-        type: "string"
-    },
-    url: {
-        type: "string"
-    },
-    filename: {
-        type: "string"
-    },
-    meta: {
-        collection: "MediaManagerMetaAP",
-        via: "parent"
-    },
-    modelAssociation: {
-        collection: "MediaManagerAssociationsAP",
-        via: "file"
-    }
-};

package/models/MediaManagerAssociationsAP.d.ts

@@ -1,38 +0,0 @@
-import { MediaManagerAP } from "./MediaManagerAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    mediaManagerId: {
-        type: string;
-    };
-    model: {
-        type: string;
-    };
-    modelId: {
-        type: string;
-    };
-    widgetName: {
-        type: string;
-    };
-    sortOrder: {
-        type: string;
-    };
-    file: {
-        model: string;
-    };
-};
-export default _default;
-export interface MediaManagerAssociationsAP {
-    id: string;
-    mediaManagerId?: string;
-    model?: Record<string, unknown>;
-    modelId?: Record<string, unknown>;
-    widgetName?: string;
-    sortOrder?: number;
-    file?: MediaManagerAP;
-}

package/models/MediaManagerAssociationsAP.js

@@ -1,27 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    mediaManagerId: {
-        type: "string"
-    },
-    model: {
-        type: "json"
-    },
-    modelId: {
-        type: "json"
-    },
-    widgetName: {
-        type: "string"
-    },
-    sortOrder: {
-        type: "number"
-    },
-    file: {
-        model: "MediaManagerAP"
-    }
-};

package/models/MediaManagerMetaAP.d.ts

@@ -1,30 +0,0 @@
-import { MediaManagerAP } from "./MediaManagerAP";
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    key: {
-        type: string;
-    };
-    value: {
-        type: string;
-    };
-    isPublic: {
-        type: string;
-    };
-    parent: {
-        model: string;
-    };
-};
-export default _default;
-export interface MediaManagerMetaAP {
-    id: string;
-    key?: string;
-    value?: Record<string, unknown>;
-    isPublic?: boolean;
-    parent?: MediaManagerAP;
-}

package/models/MediaManagerMetaAP.js

@@ -1,21 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    key: {
-        type: "string"
-    },
-    value: {
-        type: "json"
-    },
-    isPublic: {
-        type: "boolean"
-    },
-    parent: {
-        model: "MediaManagerAP"
-    }
-};

package/system/bindInstallStepper.d.ts

@@ -1,2 +0,0 @@
-import { Adminizer } from "../lib/Adminizer";
-export default function bindInstallStepper(adminizer: Adminizer): void;

package/system/bindInstallStepper.js

@@ -1,23 +0,0 @@
-import { InstallStepper } from "../lib/installStepper/installStepper";
-import { Adminizer } from "../lib/Adminizer";
-let installStepper = InstallStepper.getInstance();
-export default function bindInstallStepper(adminizer) {
-    let installStepperPolicy = function (req, res, proceed) {
-        if (!req.user) {
-            return proceed();
-        }
-        let goingToProcessInstallStep = req._parsedUrl.pathname === `/install/${installStepper.id}`;
-        let goingToProcessInstallFinalize = req._parsedUrl.pathname === `/install/${installStepper.id}/finalize`;
-        if (installStepper.hasUnprocessedSteps() && !goingToProcessInstallStep && !goingToProcessInstallFinalize) {
-            return res.redirect(`${adminizer.config.routePrefix}/install/${installStepper.id}`);
-        }
-        return proceed();
-    };
-    if (Array.isArray(adminizer.config.policies) && typeof adminizer.config.policies[0] !== "string") {
-        adminizer.config.policies.push(installStepperPolicy);
-    }
-    else {
-        Adminizer.log.error("Can not bind install stepper. Policies is not array");
-    }
-}
-;