verdaccio-stats 0.1.0

package/lib/index.mjs

@@ -0,0 +1,679 @@
+import z from 'zod';
+import dayjs, { extend } from 'dayjs';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import weekYear from 'dayjs/plugin/weekYear';
+import path from 'node:path';
+import { Model, DataTypes, Sequelize } from 'sequelize';
+import { tarballUtils } from '@verdaccio/core';
+import { PACKAGE_API_ENDPOINTS } from '@verdaccio/middleware';
+import buildDebug from 'debug';
+import { Umzug, SequelizeStorage } from 'umzug';
+
+var name = "verdaccio-stats";
+var version = "0.1.0";
+
+const plugin = {
+    name,
+    version,
+};
+const pluginKey = name.replace("verdaccio-", "");
+const UNIVERSE_PACKAGE_NAME = "**";
+const UNIVERSE_PACKAGE_VERSION = "*";
+const PERIOD_TYPES = ["overall", "daily", "monthly", "weekly", "yearly"];
+const PERIOD_VALUE_TOTAL = "total";
+const DEFAULT_SQLITE_FILE = "stats.db";
+const API_BASE_PATH = "/-/verdaccio/stats";
+
+function noop() {
+    /* noop */
+}
+const dummyLogger = {
+    child: () => dummyLogger,
+    debug: noop,
+    error: noop,
+    http: noop,
+    info: noop,
+    trace: noop,
+    warn: noop,
+};
+let logger = dummyLogger;
+function setLogger(l) {
+    if (!l)
+        return;
+    logger = l.child({ plugin: { name: plugin.name } });
+    logger.info(plugin, "plugin loading: @{name}@@{version}");
+}
+
+extend(advancedFormat);
+extend(weekYear);
+extend(weekOfYear);
+extend(isoWeek);
+/**
+ * Get the period value for the given period type.
+ *
+ * @param periodType {PeriodType} - The period type.
+ * @param date {Dayjs} - The date to get the period value for.
+ * @param isoWeek {boolean} - Whether to use ISO week format.
+ * @returns {PeriodValue} The period value.
+ */
+function getPeriodValue(periodType, date, isoWeek) {
+    switch (periodType) {
+        case "daily": {
+            return dayjs(date).format("YYYY-MM-DD");
+        }
+        case "monthly": {
+            return dayjs(date).format("YYYY-MM");
+        }
+        case "overall": {
+            return PERIOD_VALUE_TOTAL;
+        }
+        case "weekly": {
+            return dayjs(date).format(isoWeek ? "GGGG-[W]WW" : "gggg-[W]ww");
+        }
+        case "yearly": {
+            return dayjs(date).format("YYYY");
+        }
+        default: {
+            throw new Error(`Unknown period type: ${String(periodType)}`);
+        }
+    }
+}
+/**
+ * Check if the status code is a success status code.
+ *
+ * @param statusCode {number} - The status code.
+ * @returns {boolean} Whether the status code is a success status code.
+ */
+function isSuccessStatus(statusCode) {
+    return (statusCode >= 200 && statusCode < 300) || statusCode === 304;
+}
+/**
+ * Get the absolute path of a file path.
+ *
+ * @param configPath {string} - The path to the config file.
+ * @param targetPath {string} - The path to the files.
+ * @returns {string} The absolute path of the file.
+ */
+function normalizeFilePath(configPath, targetPath) {
+    return path.isAbsolute(targetPath) ? targetPath : path.normalize(path.join(path.dirname(configPath), targetPath));
+}
+/**
+ * Wraps the given URL path for Verdaccio stats.
+ *
+ * @param urlPath {string} - The path to be wrapped.
+ * @returns {string} The wrapped path.
+ */
+function wrapPath(urlPath) {
+    return `${API_BASE_PATH}${urlPath}`;
+}
+
+const statsConfig = z.object({
+    file: z.string().optional(),
+    "iso-week": z.boolean().optional(),
+    "count-downloads": z.boolean().optional(),
+    "count-manifest-views": z.boolean().optional(),
+});
+class ParsedPluginConfig {
+    config;
+    verdaccioConfig;
+    get configPath() {
+        return this.verdaccioConfig.configPath ?? this.verdaccioConfig.self_path;
+    }
+    get countDownloads() {
+        return this.config["count-downloads"] ?? true;
+    }
+    get countManifestViews() {
+        return this.config["count-manifest-views"] ?? true;
+    }
+    get file() {
+        return normalizeFilePath(this.configPath, this.config.file ?? DEFAULT_SQLITE_FILE);
+    }
+    get isoWeek() {
+        return this.config["iso-week"] ?? false;
+    }
+    get logo() {
+        return this.verdaccioConfig.web?.logo;
+    }
+    get title() {
+        return this.verdaccioConfig.web?.title ?? "Verdaccio Stats";
+    }
+    constructor(config, verdaccioConfig) {
+        this.config = config;
+        this.verdaccioConfig = verdaccioConfig;
+        try {
+            statsConfig.parse(config);
+        }
+        catch (err) {
+            const zodError = err;
+            logger.error({ errors: zodError.flatten().fieldErrors }, "Invalid config, @{errors}");
+            process.exit(1);
+        }
+    }
+}
+
+class DownloadStats extends Model {
+}
+class ManifestViewStats extends Model {
+}
+class Package extends Model {
+}
+
+const rootPath = wrapPath("/admin");
+const defaultActions = {
+    new: { isAccessible: false },
+    edit: { isAccessible: false },
+    delete: { isAccessible: false },
+    bulkDelete: { isAccessible: false },
+};
+process.env.ADMIN_JS_SKIP_BUNDLE = "true";
+/**
+ * Add Admin UI to the application.
+ */
+class AdminUI {
+    adminRouter = null;
+    config;
+    constructor(config) {
+        this.config = config;
+        void this.create().then((router) => {
+            this.adminRouter = router;
+        });
+    }
+    static populatePackageIdListProperties(response) {
+        for (const record of response.records) {
+            if (record.populated.packageId?.params) {
+                const params = record.populated.packageId.params;
+                record.populated.packageId.title = `${params.name}@${params.version}`;
+            }
+        }
+        return response;
+    }
+    static populatePackageIdSearchProperties(response) {
+        for (const record of response.records) {
+            if (record.populated.packageId?.params) {
+                const params = record.populated.packageId.params;
+                record.populated.packageId.title = `${params.name}@${params.version}`;
+            }
+        }
+        return response;
+    }
+    static populatePackageIdShowProperties(response) {
+        if (response.record.populated.packageId?.params) {
+            const params = response.record.populated.packageId.params;
+            response.record.populated.packageId.title = `${params.name}@${params.version}`;
+        }
+        return response;
+    }
+    register_middlewares(app) {
+        app.use(rootPath, (req, res, next) => {
+            if (this.adminRouter) {
+                return this.adminRouter(req, res, next);
+            }
+            else {
+                res.status(503).send("Admin UI is not ready yet.");
+            }
+        });
+    }
+    async create() {
+        const [AdminJS, AdminJSExpress, AdminJSSequelize] = await Promise.all([
+            import('adminjs').then((mod) => mod.default),
+            import('@adminjs/express').then((mod) => mod.default),
+            import('@adminjs/sequelize').then((mod) => mod.default),
+        ]);
+        AdminJS.registerAdapter({
+            Resource: AdminJSSequelize.Resource,
+            Database: AdminJSSequelize.Database,
+        });
+        const admin = new AdminJS({
+            resources: [
+                {
+                    resource: Package,
+                    options: {
+                        actions: { ...defaultActions },
+                        listProperties: ["id", "name", "version", "createdAt"],
+                        showProperties: ["id", "name", "version", "createdAt"],
+                        filterProperties: ["name", "version"],
+                        sort: { sortBy: "createdAt", direction: "desc" },
+                    },
+                },
+                {
+                    resource: DownloadStats,
+                    options: {
+                        actions: {
+                            ...defaultActions,
+                            show: { after: AdminUI.populatePackageIdShowProperties },
+                            list: { after: AdminUI.populatePackageIdListProperties },
+                            search: { after: AdminUI.populatePackageIdSearchProperties },
+                        },
+                        properties: {
+                            periodType: {
+                                availableValues: PERIOD_TYPES.map((type) => ({ value: type, label: type })),
+                            },
+                        },
+                        listProperties: ["id", "packageId", "periodType", "periodValue", "count", "createdAt", "updatedAt"],
+                        showProperties: ["id", "packageId", "periodType", "periodValue", "count", "createdAt", "updatedAt"],
+                        filterProperties: ["packageId", "periodType", "periodValue", "createdAt", "updatedAt"],
+                        sort: { sortBy: "updatedAt", direction: "desc" },
+                    },
+                },
+                {
+                    resource: ManifestViewStats,
+                    options: {
+                        actions: {
+                            ...defaultActions,
+                            show: { after: AdminUI.populatePackageIdShowProperties },
+                            list: { after: AdminUI.populatePackageIdListProperties },
+                            search: { after: AdminUI.populatePackageIdSearchProperties },
+                        },
+                        properties: {
+                            periodType: {
+                                availableValues: PERIOD_TYPES.map((type) => ({ value: type, label: type })),
+                            },
+                        },
+                        listProperties: ["id", "packageId", "periodType", "periodValue", "count", "createdAt", "updatedAt"],
+                        showProperties: ["id", "packageId", "periodType", "periodValue", "count", "createdAt", "updatedAt"],
+                        filterProperties: ["packageId", "periodType", "periodValue", "createdAt", "updatedAt"],
+                        sort: { sortBy: "updatedAt", direction: "desc" },
+                    },
+                },
+            ],
+            rootPath: rootPath,
+            branding: {
+                companyName: this.config.title,
+                logo: this.config.logo,
+            },
+            env: {
+                ADMIN_JS_SKIP_BUNDLE: "true",
+            },
+        });
+        return AdminJSExpress.buildRouter(admin);
+    }
+}
+
+class Hooks {
+    config;
+    db = null;
+    constructor(config) {
+        this.config = config;
+    }
+    packageManifestHandler = (req, res, next) => {
+        const db = this.db;
+        if (!db) {
+            logger.warn("DB instance is not ready; skipping manifest stats");
+            return next();
+        }
+        const packageName = req.params.package;
+        const version = req.params.version;
+        if (packageName === "favicon.ico") {
+            logger.debug("Skipping manifest stats for favicon request");
+            return next();
+        }
+        res.once("finish", () => {
+            if (!isSuccessStatus(res.statusCode)) {
+                logger.debug("Skipping manifest stats for non-2xx response");
+                return;
+            }
+            if (!packageName) {
+                logger.warn("Unexpected missing package name in request");
+                return;
+            }
+            logger.debug({ packageName, version }, "Adding manifest view stats for package @{packageName} version @{version}");
+            db.addManifestViewCount(packageName, version).catch((err) => {
+                logger.error({ err }, "Failed to add manifest count; @{err}");
+            });
+        });
+        return next();
+    };
+    register_middlewares(app) {
+        if (this.config.countDownloads) {
+            app.get(PACKAGE_API_ENDPOINTS.get_package_tarball, this.tarballDownloadHandler);
+        }
+        if (this.config.countManifestViews) {
+            app.get(PACKAGE_API_ENDPOINTS.get_package_by_version, this.packageManifestHandler);
+        }
+    }
+    setDatabase(db) {
+        this.db = db;
+    }
+    tarballDownloadHandler = (req, res, next) => {
+        const db = this.db;
+        if (!db) {
+            logger.warn("DB instance is not ready; skipping download stats");
+            return next();
+        }
+        // react
+        const packageName = req.params.package;
+        // react-18.0.0.tgz
+        const filename = req.params.filename;
+        res.once("finish", () => {
+            if (!isSuccessStatus(res.statusCode)) {
+                logger.debug("Skipping download stats for non-2xx response");
+                return;
+            }
+            // react-18.0.0.tgz -> 18.0.0
+            const version = tarballUtils.getVersionFromTarball(filename);
+            if (!packageName || !version) {
+                logger.warn("Unexpected missing package name or filename in request");
+                return;
+            }
+            logger.debug({ packageName, version }, "Adding download stats for package @{packageName} version @{version}");
+            db.addDownloadCount(packageName, version).catch((err) => {
+                logger.error({ err }, "Failed to add download count; @{err}");
+            });
+        });
+        return next();
+    };
+}
+
+/**
+ * NOTE: This middleware is not implemented yet.
+ */
+class Stats {
+    config;
+    db = null;
+    constructor(config) {
+        this.config = config;
+    }
+    register_middlewares(app) {
+        app.get(wrapPath("/downloads/latest"), this.notImplementedHandler);
+        app.get(wrapPath("/downloads/total"), this.notImplementedHandler);
+        app.get(wrapPath("/downloads/popular/:count?"), this.notImplementedHandler);
+        app.get(wrapPath("/downloads/package/:package/:version?"), this.notImplementedHandler);
+        app.get(wrapPath("/manifest/latest"), this.notImplementedHandler);
+        app.get(wrapPath("/manifest/total"), this.notImplementedHandler);
+        app.get(wrapPath("/manifest/popular/:count?"), this.notImplementedHandler);
+        app.get(wrapPath("/manifest/views/package/:package/:version?"), this.notImplementedHandler);
+    }
+    setDatabase(db) {
+        this.db = db;
+    }
+    checkDatabase(db, res) {
+        if (!db) {
+            res.sendStatus(500).send("Database not set");
+            return false;
+        }
+        return true;
+    }
+    notImplementedHandler = (req, res) => {
+        if (!this.checkDatabase(this.db, res))
+            return;
+        res.sendStatus(501).send("Not implemented");
+    };
+}
+
+const debug = buildDebug(`verdaccio:plugin:${pluginKey}`);
+function getUmzugLogger() {
+    return {
+        debug: (msg) => debug("umzug:debug: %j", msg),
+        error: (msg) => debug("umzug:error: %j", msg),
+        info: (msg) => debug("umzug:info: %j", msg),
+        warn: (msg) => debug("umzug:warn: %j", msg),
+    };
+}
+
+const migrations = [
+    {
+        name: "000-initial",
+        up: async ({ context: sequelize }) => {
+            const queryInterface = sequelize.getQueryInterface();
+            await Promise.all([
+                queryInterface.createTable("packages", {
+                    id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                    name: { allowNull: false, type: DataTypes.STRING(100) },
+                    version: { allowNull: false, type: DataTypes.STRING(50) },
+                    created_at: { allowNull: false, type: DataTypes.DATE },
+                    updated_at: { allowNull: false, type: DataTypes.DATE },
+                }),
+                queryInterface.createTable("download_stats", {
+                    id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                    package_id: { allowNull: false, type: DataTypes.INTEGER },
+                    period_type: { allowNull: false, type: DataTypes.STRING(20) },
+                    period_value: { allowNull: false, type: DataTypes.STRING(20) },
+                    count: { allowNull: false, type: DataTypes.BIGINT, defaultValue: 0 },
+                    created_at: { allowNull: false, type: DataTypes.DATE },
+                    updated_at: { allowNull: false, type: DataTypes.DATE },
+                }),
+                queryInterface.createTable("manifest_view_stats", {
+                    id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                    package_id: { allowNull: false, type: DataTypes.INTEGER },
+                    period_type: { allowNull: false, type: DataTypes.STRING(20) },
+                    period_value: { allowNull: false, type: DataTypes.STRING(20) },
+                    count: { allowNull: false, type: DataTypes.BIGINT, defaultValue: 0 },
+                    created_at: { allowNull: false, type: DataTypes.DATE },
+                    updated_at: { allowNull: false, type: DataTypes.DATE },
+                }),
+            ]);
+            await Promise.all([
+                queryInterface.addIndex("packages", ["name", "version"], {
+                    unique: true,
+                    name: "packages_index",
+                }),
+                queryInterface.addIndex("download_stats", ["package_id", "period_type", "period_value"], {
+                    name: "download_stats_index",
+                }),
+                queryInterface.addIndex("manifest_view_stats", ["package_id", "period_type", "period_value"], {
+                    name: "manifest_view_stats_index",
+                }),
+            ]);
+            return queryInterface.bulkInsert("packages", [
+                {
+                    name: UNIVERSE_PACKAGE_NAME,
+                    version: UNIVERSE_PACKAGE_VERSION,
+                    created_at: new Date(),
+                    updated_at: new Date(),
+                },
+            ]);
+        },
+        down: async ({ context: Sequelize }) => {
+            const queryInterface = Sequelize.getQueryInterface();
+            await Promise.all([
+                queryInterface.removeIndex("packages", "packages_index"),
+                queryInterface.removeIndex("download_stats", "download_stats_index"),
+                queryInterface.removeIndex("manifest_view_stats", "manifest_view_stats_index"),
+            ]);
+            return Promise.all(["packages", "download_stats", "manifest_view_stats"].map((table) => queryInterface.dropTable(table)));
+        },
+    },
+];
+
+class Database {
+    config;
+    sequelize;
+    umzug;
+    constructor(config) {
+        const sequelize = new Sequelize({
+            dialect: "sqlite",
+            storage: config.file,
+            logging: (sql) => buildDebug(sql),
+        });
+        const umzug = new Umzug({
+            context: () => sequelize,
+            migrations: migrations,
+            storage: new SequelizeStorage({ sequelize, modelName: "migration_meta" }),
+            logger: getUmzugLogger(),
+        });
+        this.config = config;
+        this.sequelize = sequelize;
+        this.umzug = umzug;
+    }
+    static async create(config) {
+        const db = new Database(config);
+        await db.migrate();
+        await db.init();
+        return db;
+    }
+    async addDownloadCount(packageName, version) {
+        const t = await this.sequelize.transaction();
+        try {
+            await Promise.all([
+                this.addTotalDownloadCount(t),
+                this.addPackageDownloadCount(packageName, UNIVERSE_PACKAGE_VERSION, t),
+                this.addPackageDownloadCount(packageName, version, t),
+            ]);
+            await t.commit();
+        }
+        catch (err) {
+            await t.rollback();
+            throw err;
+        }
+    }
+    async addManifestViewCount(packageName, version) {
+        const t = await this.sequelize.transaction();
+        try {
+            await Promise.all([
+                this.addTotalManifestViewCount(t),
+                this.addPackageManifestViewCount(packageName, UNIVERSE_PACKAGE_VERSION, t),
+                version && this.addPackageManifestViewCount(packageName, version, t),
+            ].filter(Boolean));
+            await t.commit();
+        }
+        catch (err) {
+            await t.rollback();
+            throw err;
+        }
+    }
+    migrate() {
+        return this.umzug.up();
+    }
+    rollback() {
+        return this.umzug.down();
+    }
+    async addDownloadForAllPeriod(pkg, transaction) {
+        return Promise.all(PERIOD_TYPES.map(async (periodType) => {
+            const [downloadStats] = await DownloadStats.findOrCreate({
+                where: {
+                    packageId: pkg.id,
+                    periodType: periodType,
+                    periodValue: getPeriodValue(periodType, undefined, this.config.isoWeek),
+                },
+                transaction,
+            });
+            return downloadStats.increment("count", { by: 1, transaction });
+        }));
+    }
+    async addManifestViewForAllPeriod(pkg, transaction) {
+        return Promise.all(PERIOD_TYPES.map(async (periodType) => {
+            const [manifestViewStats] = await ManifestViewStats.findOrCreate({
+                where: {
+                    packageId: pkg.id,
+                    periodType: periodType,
+                    periodValue: getPeriodValue(periodType, undefined, this.config.isoWeek),
+                },
+                transaction,
+            });
+            return manifestViewStats.increment("count", { by: 1, transaction });
+        }));
+    }
+    async addPackageDownloadCount(packageName, version, transaction) {
+        const [pkg] = await Package.findOrCreate({ where: { name: packageName, version }, transaction });
+        if (!pkg) {
+            throw new Error("Package not found");
+        }
+        return this.addDownloadForAllPeriod(pkg, transaction);
+    }
+    async addPackageManifestViewCount(packageName, version, transaction) {
+        const [pkg] = await Package.findOrCreate({ where: { name: packageName, version }, transaction });
+        if (!pkg) {
+            throw new Error("Package not found");
+        }
+        return this.addManifestViewForAllPeriod(pkg, transaction);
+    }
+    async addTotalDownloadCount(transaction) {
+        const universePkg = await Package.findOne({
+            where: { name: UNIVERSE_PACKAGE_NAME, version: UNIVERSE_PACKAGE_VERSION },
+            transaction,
+        });
+        if (!universePkg) {
+            throw new Error("Universe package not found");
+        }
+        return this.addDownloadForAllPeriod(universePkg, transaction);
+    }
+    async addTotalManifestViewCount(transaction) {
+        const universePkg = await Package.findOne({
+            where: { name: UNIVERSE_PACKAGE_NAME, version: UNIVERSE_PACKAGE_VERSION },
+            transaction,
+        });
+        if (!universePkg) {
+            throw new Error("Universe package not found");
+        }
+        return this.addManifestViewForAllPeriod(universePkg, transaction);
+    }
+    async init() {
+        await Promise.all([
+            Package.init({
+                id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                name: { allowNull: false, type: DataTypes.STRING(100) },
+                version: { allowNull: false, type: DataTypes.STRING(50) },
+            }, { sequelize: this.sequelize, tableName: "packages", underscored: true }),
+            DownloadStats.init({
+                count: { allowNull: false, type: DataTypes.BIGINT, defaultValue: 0 },
+                id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                packageId: { allowNull: false, type: DataTypes.INTEGER, references: { model: Package, key: "id" } },
+                periodType: { allowNull: false, type: DataTypes.STRING(20) },
+                periodValue: { allowNull: false, type: DataTypes.STRING(20) },
+            }, { sequelize: this.sequelize, tableName: "download_stats", underscored: true }),
+            ManifestViewStats.init({
+                count: { allowNull: false, type: DataTypes.BIGINT, defaultValue: 0 },
+                id: { allowNull: false, autoIncrement: true, primaryKey: true, type: DataTypes.INTEGER },
+                packageId: { allowNull: false, type: DataTypes.INTEGER, references: { model: Package, key: "id" } },
+                periodType: { allowNull: false, type: DataTypes.STRING(20) },
+                periodValue: { allowNull: false, type: DataTypes.STRING(20) },
+            }, { sequelize: this.sequelize, tableName: "manifest_view_stats", underscored: true }),
+        ]);
+        Package.hasMany(DownloadStats, {
+            sourceKey: "id",
+            foreignKey: "packageId",
+        });
+        Package.hasMany(ManifestViewStats, {
+            sourceKey: "id",
+            foreignKey: "packageId",
+        });
+        DownloadStats.belongsTo(Package, {
+            targetKey: "id",
+            foreignKey: "packageId",
+            as: "package",
+        });
+        ManifestViewStats.belongsTo(Package, {
+            targetKey: "id",
+            foreignKey: "packageId",
+            as: "package",
+        });
+    }
+}
+
+class Plugin {
+    config;
+    options;
+    get version() {
+        return +plugin.version;
+    }
+    parsedConfig;
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+        setLogger(options.logger);
+        this.parsedConfig = new ParsedPluginConfig(config, options.config);
+    }
+    getVersion() {
+        return this.version;
+    }
+    register_middlewares(app) {
+        const db = Database.create(this.parsedConfig);
+        const hooks = new Hooks(this.parsedConfig);
+        const stats = new Stats(this.parsedConfig);
+        const adminUI = new AdminUI(this.parsedConfig);
+        db.then((db) => {
+            hooks.setDatabase(db);
+            stats.setDatabase(db);
+        }).catch((err) => {
+            logger.error({ err }, "Failed to initialize database; @{err}");
+            process.exit(1);
+        });
+        for (const middleware of [hooks, stats, adminUI]) {
+            middleware.register_middlewares(app);
+        }
+    }
+}
+
+export { Plugin as default };

package/lib/logger.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from "@verdaccio/types";
+declare let logger: Logger;
+export declare function setLogger(l?: Logger): void;
+export default logger;

package/lib/middlewares/admin-ui.d.ts

@@ -0,0 +1,17 @@
+import type { ListActionResponse, RecordActionResponse, SearchActionResponse } from "adminjs";
+import type { Application } from "express";
+import type { ConfigHolder } from "../config";
+import type { PluginMiddleware } from "../types";
+/**
+ * Add Admin UI to the application.
+ */
+export declare class AdminUI implements PluginMiddleware {
+    private adminRouter;
+    private config;
+    constructor(config: ConfigHolder);
+    static populatePackageIdListProperties(this: void, response: ListActionResponse): ListActionResponse;
+    static populatePackageIdSearchProperties(this: void, response: SearchActionResponse): SearchActionResponse;
+    static populatePackageIdShowProperties(this: void, response: RecordActionResponse): RecordActionResponse;
+    register_middlewares(app: Application): void;
+    private create;
+}