@verdaccio/plugin-verifier 1.0.0-next-9.1

package/tests/verify-plugin.spec.ts

@@ -0,0 +1,218 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+import { PLUGIN_CATEGORY } from '@verdaccio/core';
+
+import { verifyPlugin } from '../src/verify-plugin';
+
+const fixturesPath = join(__dirname, 'fixtures');
+
+describe('verifyPlugin', () => {
+  describe('authentication plugins', () => {
+    it('should verify a valid auth plugin (CommonJS)', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-auth-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+      expect(result.error).toBeUndefined();
+      expect(result.diagnostics).toBeUndefined();
+    });
+
+    it('should verify a valid auth plugin (ES6 default export)', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-auth-es6-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+    });
+
+    it('should fail sanity check when a middleware plugin is tested as auth', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'wrong-category-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.pluginsLoaded).toBe(0);
+      expect(result.diagnostics).toBeDefined();
+
+      const sanityStep = result.diagnostics!.find((d) => d.phase === 'sanity-check');
+      expect(sanityStep?.pass).toBe(false);
+      expect(sanityStep?.message).toContain('authentication');
+      expect(sanityStep?.message).toContain('register_middlewares');
+    });
+  });
+
+  describe('storage plugins', () => {
+    it('should verify a valid storage plugin', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-storage-plugin',
+        category: PLUGIN_CATEGORY.STORAGE,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+    });
+  });
+
+  describe('middleware plugins', () => {
+    it('should verify a valid middleware plugin', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-middleware-plugin',
+        category: PLUGIN_CATEGORY.MIDDLEWARE,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+    });
+  });
+
+  describe('filter plugins', () => {
+    it('should verify a valid filter plugin', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-filter-plugin',
+        category: PLUGIN_CATEGORY.FILTER,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+    });
+  });
+
+  describe('diagnostics', () => {
+    it('should diagnose plugin directory not found', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'non-existent-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.diagnostics).toBeDefined();
+      expect(result.diagnostics).toHaveLength(1);
+
+      const step = result.diagnostics![0];
+      expect(step.phase).toBe('resolve');
+      expect(step.pass).toBe(false);
+      expect(step.message).toContain('verdaccio-non-existent-plugin');
+    });
+
+    it('should diagnose non-existent plugins folder', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'some-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: '/does/not/exist',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.diagnostics).toBeDefined();
+
+      const step = result.diagnostics![0];
+      expect(step.phase).toBe('resolve');
+      expect(step.pass).toBe(false);
+      expect(step.message).toContain('does not exist');
+    });
+
+    it('should diagnose invalid export shape', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'invalid-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.diagnostics).toBeDefined();
+
+      const resolveStep = result.diagnostics!.find((d) => d.phase === 'resolve');
+      expect(resolveStep?.pass).toBe(true);
+
+      const exportStep = result.diagnostics!.find((d) => d.phase === 'export');
+      expect(exportStep?.pass).toBe(false);
+      expect(exportStep?.message).toContain('does not export a function');
+    });
+
+    it('should diagnose instantiation failure', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'throwing-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.diagnostics).toBeDefined();
+
+      const instantiateStep = result.diagnostics!.find((d) => d.phase === 'instantiate');
+      expect(instantiateStep?.pass).toBe(false);
+      expect(instantiateStep?.message).toContain('Plugin initialization failed');
+    });
+
+    it('should diagnose failed sanity check and list available methods', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'wrong-category-plugin',
+        category: PLUGIN_CATEGORY.STORAGE,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.diagnostics).toBeDefined();
+
+      const steps = result.diagnostics!;
+      expect(steps.find((d) => d.phase === 'resolve')?.pass).toBe(true);
+      expect(steps.find((d) => d.phase === 'export')?.pass).toBe(true);
+      expect(steps.find((d) => d.phase === 'instantiate')?.pass).toBe(true);
+
+      const sanityStep = steps.find((d) => d.phase === 'sanity-check');
+      expect(sanityStep?.pass).toBe(false);
+      expect(sanityStep?.message).toContain('storage');
+      expect(sanityStep?.message).toContain('register_middlewares');
+    });
+
+    it('should show all steps passing on success', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-auth-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.diagnostics).toBeUndefined();
+    });
+  });
+
+  describe('custom sanity check', () => {
+    it('should use a custom sanity check when provided', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-auth-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+        sanityCheck: (plugin) => typeof plugin.authenticate === 'function',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.pluginsLoaded).toBe(1);
+    });
+
+    it('should fail with a custom sanity check that does not pass', async () => {
+      const result = await verifyPlugin({
+        pluginPath: 'valid-auth-plugin',
+        category: PLUGIN_CATEGORY.AUTHENTICATION,
+        pluginsFolder: fixturesPath,
+        sanityCheck: () => false,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.pluginsLoaded).toBe(0);
+    });
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["tests/**"]
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../../tsconfig.reference.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build",
+    "composite": true,
+    "declaration": true
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    {
+      "path": "../../core/core"
+    },
+    {
+      "path": "../../core/types"
+    },
+    {
+      "path": "../../loaders"
+    },
+    {
+      "path": "../../logger"
+    }
+  ]
+}

package/vite.config.mjs

@@ -0,0 +1,69 @@
+import { builtinModules, createRequire } from 'node:module';
+import path from 'node:path';
+
+import dts from 'vite-plugin-dts';
+import { defineConfig } from 'vite';
+
+const dirname = import.meta.dirname;
+const require = createRequire(path.resolve(dirname, 'package.json'));
+const pkg = require('./package.json');
+
+const nodeBuiltins = new Set([
+  ...builtinModules,
+  ...builtinModules.map((m) => `node:${m}`),
+]);
+
+const externalDeps = new Set([
+  ...Object.keys(pkg.dependencies ?? {}),
+  ...Object.keys(pkg.devDependencies ?? {}),
+  ...Object.keys(pkg.peerDependencies ?? {}),
+]);
+
+const isExternal = (id) => {
+  if (nodeBuiltins.has(id)) return true;
+  if (externalDeps.has(id)) return true;
+  if ([...externalDeps].some((dep) => id.startsWith(`${dep}/`))) return true;
+  return false;
+};
+
+const sharedOutput = {
+  preserveModules: true,
+  preserveModulesRoot: 'src',
+};
+
+export default defineConfig({
+  plugins: [
+    dts({
+      tsconfigPath: path.resolve(dirname, 'tsconfig.build.json'),
+    }),
+  ],
+  build: {
+    outDir: 'build',
+    emptyOutDir: true,
+    sourcemap: true,
+    minify: false,
+    lib: {
+      entry: [
+        path.resolve(dirname, 'src/index.ts'),
+        path.resolve(dirname, 'src/cli.ts'),
+      ],
+    },
+    rollupOptions: {
+      external: isExternal,
+      output: [
+        {
+          format: 'es',
+          entryFileNames: '[name].js',
+          chunkFileNames: '[name].js',
+          ...sharedOutput,
+        },
+        {
+          format: 'cjs',
+          entryFileNames: '[name].cjs',
+          chunkFileNames: '[name].cjs',
+          ...sharedOutput,
+        },
+      ],
+    },
+  },
+});

package/vitest.config.mjs

@@ -0,0 +1,11 @@
+// @ts-check
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      exclude: ['tests/fixtures/**'],
+    },
+    globals: true,
+  },
+});