@vendure/dashboard 3.3.6-master-202507110238 → 3.3.6

package/dist/plugin/types.d.ts

@@ -0,0 +1,40 @@
+export type Logger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+};
+export type PluginInfo = {
+    name: string;
+    pluginPath: string;
+    dashboardEntryPath: string | undefined;
+    /** The original source path of the plugin, only set for local plugins that are compiled */
+    sourcePluginPath?: string;
+};
+export type GetCompiledConfigPathFn = (params: {
+    inputRootDir: string;
+    outputPath: string;
+    configFileName: string;
+}) => string;
+export type TransformTsConfigPathMappingsFn = (params: {
+    phase: 'compiling' | 'loading';
+    alias: string;
+    patterns: string[];
+}) => string[];
+/**
+ * @description
+ * The PathAdapter interface allows customization of how paths are handled
+ * when compiling the Vendure config and its imports.
+ */
+export interface PathAdapter {
+    /**
+     * @description
+     * A function to determine the path to the compiled Vendure config file.
+     */
+    getCompiledConfigPath?: GetCompiledConfigPathFn;
+    /**
+     * If your project makes use of the TypeScript `paths` configuration, the compiler will
+     * attempt to use these paths when compiling the Vendure config and its imports.
+     */
+    transformTsConfigPathMappings?: TransformTsConfigPathMappingsFn;
+}

package/dist/plugin/utils/ast-utils.d.ts

@@ -1,9 +1,4 @@
 import ts from 'typescript';
-import { PluginInfo } from './config-loader.js';
-/**
- * Get the plugin info from the source file.
- */
-export declare function getPluginInfo(sourceFile: ts.SourceFile): PluginInfo | undefined;
 /**
  * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
  */

package/dist/plugin/utils/ast-utils.js

@@ -1,53 +1,4 @@
-import path from 'path';
 import ts from 'typescript';
-/**
- * Get the plugin info from the source file.
- */
-export function getPluginInfo(sourceFile) {
-    var _a;
-    const classDeclaration = sourceFile.statements.find(statement => {
-        return (statement.kind === ts.SyntaxKind.ClassDeclaration &&
-            statement.getText().includes('@VendurePlugin('));
-    });
-    if (classDeclaration) {
-        const identifier = classDeclaration.getChildren().find(child => {
-            return child.kind === ts.SyntaxKind.Identifier;
-        });
-        const dashboardEntryPath = (_a = classDeclaration
-            .getChildren()
-            .map(child => {
-            if (child.kind === ts.SyntaxKind.SyntaxList) {
-                const pluginDecorator = child.getChildren().find(_child => {
-                    return _child.kind === ts.SyntaxKind.Decorator;
-                });
-                if (pluginDecorator) {
-                    const callExpression = findFirstDescendantOfKind(pluginDecorator, ts.SyntaxKind.CallExpression);
-                    if (callExpression) {
-                        const objectLiteral = findFirstDescendantOfKind(callExpression, ts.SyntaxKind.ObjectLiteralExpression);
-                        if (objectLiteral && ts.isObjectLiteralExpression(objectLiteral)) {
-                            // Now find the specific 'dashboard' property
-                            const dashboardProperty = objectLiteral.properties.find(prop => { var _a; return ts.isPropertyAssignment(prop) && ((_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText()) === 'dashboard'; });
-                            if (dashboardProperty &&
-                                ts.isPropertyAssignment(dashboardProperty) &&
-                                ts.isStringLiteral(dashboardProperty.initializer)) {
-                                const dashboardPath = dashboardProperty.initializer.text;
-                                return dashboardPath;
-                            }
-                        }
-                    }
-                }
-            }
-        })
-            .filter(Boolean)) === null || _a === void 0 ? void 0 : _a[0];
-        if (identifier) {
-            return {
-                name: identifier.getText(),
-                pluginPath: path.dirname(sourceFile.fileName),
-                dashboardEntryPath,
-            };
-        }
-    }
-}
 /**
  * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
  */
@@ -76,21 +27,3 @@ export function findConfigExport(sourceFile) {
     visit(sourceFile);
     return exportedSymbolName;
 }
-function findFirstDescendantOfKind(node, kind) {
-    let foundNode;
-    function visit(_node) {
-        if (foundNode) {
-            // Stop searching if we already found it
-            return;
-        }
-        if (_node.kind === kind) {
-            foundNode = _node;
-            return;
-        }
-        // Recursively visit children
-        ts.forEachChild(_node, visit);
-    }
-    // Start the traversal from the initial node's children
-    ts.forEachChild(node, visit);
-    return foundNode;
-}

package/dist/plugin/utils/ast-utils.spec.js

@@ -1,81 +1,6 @@
 import ts from 'typescript';
 import { describe, expect, it } from 'vitest';
-import { findConfigExport, getPluginInfo } from './ast-utils.js';
-describe('getPluginInfo', () => {
-    it('should return undefined when no plugin class is found', () => {
-        const sourceText = `
-            class NotAPlugin {
-                constructor() {}
-            }
-        `;
-        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
-        const result = getPluginInfo(sourceFile);
-        expect(result).toBeUndefined();
-    });
-    it('should return plugin info when a valid plugin class is found', () => {
-        const sourceText = `
-            @VendurePlugin({
-                imports: [],
-                providers: []
-            })
-            class TestPlugin {
-                constructor() {}
-            }
-        `;
-        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
-        const result = getPluginInfo(sourceFile);
-        expect(result).toEqual({
-            name: 'TestPlugin',
-            pluginPath: 'path/to',
-            dashboardEntryPath: undefined,
-        });
-    });
-    it('should handle multiple classes but only return the plugin one', () => {
-        const sourceText = `
-            class NotAPlugin {
-                constructor() {}
-            }
-
-            @VendurePlugin({
-                imports: [],
-                providers: []
-            })
-            class TestPlugin {
-                constructor() {}
-            }
-
-            class AnotherClass {
-                constructor() {}
-            }
-        `;
-        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
-        const result = getPluginInfo(sourceFile);
-        expect(result).toEqual({
-            name: 'TestPlugin',
-            pluginPath: 'path/to',
-            dashboardEntryPath: undefined,
-        });
-    });
-    it('should determine the dashboard entry path when it is provided', () => {
-        const sourceText = `
-            @VendurePlugin({
-                imports: [],
-                providers: [],
-                dashboard: './dashboard/index.tsx',
-            })
-            class TestPlugin {
-                constructor() {}
-            }
-        `;
-        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
-        const result = getPluginInfo(sourceFile);
-        expect(result).toEqual({
-            name: 'TestPlugin',
-            pluginPath: 'path/to',
-            dashboardEntryPath: './dashboard/index.tsx',
-        });
-    });
-});
+import { findConfigExport } from './ast-utils.js';
 describe('findConfigExport', () => {
     it('should return undefined when no VendureConfig export is found', () => {
         const sourceText = `

package/dist/plugin/utils/compiler.d.ts

@@ -0,0 +1,22 @@
+import { VendureConfig } from '@vendure/core';
+import { Logger, PathAdapter, PluginInfo } from '../types.js';
+export interface PackageScannerConfig {
+    nodeModulesRoot?: string;
+}
+export interface CompilerOptions {
+    vendureConfigPath: string;
+    outputPath: string;
+    pathAdapter?: PathAdapter;
+    logger?: Logger;
+    pluginPackageScanner?: PackageScannerConfig;
+}
+export interface CompileResult {
+    vendureConfig: VendureConfig;
+    exportedSymbolName: string;
+    pluginInfo: PluginInfo[];
+}
+/**
+ * Compiles TypeScript files and discovers Vendure plugins in both the compiled output
+ * and in node_modules.
+ */
+export declare function compile(options: CompilerOptions): Promise<CompileResult>;

package/dist/plugin/utils/compiler.js

@@ -0,0 +1,162 @@
+import fs from 'fs-extra';
+import path from 'path';
+import tsConfigPaths from 'tsconfig-paths';
+import * as ts from 'typescript';
+import { pathToFileURL } from 'url';
+import { findConfigExport } from './ast-utils.js';
+import { noopLogger } from './logger.js';
+import { discoverPlugins } from './plugin-discovery.js';
+import { findTsConfigPaths } from './tsconfig-utils.js';
+const defaultPathAdapter = {
+    getCompiledConfigPath: ({ outputPath, configFileName }) => path.join(outputPath, configFileName),
+    transformTsConfigPathMappings: ({ patterns }) => patterns,
+};
+/**
+ * Compiles TypeScript files and discovers Vendure plugins in both the compiled output
+ * and in node_modules.
+ */
+export async function compile(options) {
+    var _a, _b;
+    const { vendureConfigPath, outputPath, pathAdapter, logger = noopLogger, pluginPackageScanner } = options;
+    const getCompiledConfigPath = (_a = pathAdapter === null || pathAdapter === void 0 ? void 0 : pathAdapter.getCompiledConfigPath) !== null && _a !== void 0 ? _a : defaultPathAdapter.getCompiledConfigPath;
+    const transformTsConfigPathMappings = (_b = pathAdapter === null || pathAdapter === void 0 ? void 0 : pathAdapter.transformTsConfigPathMappings) !== null && _b !== void 0 ? _b : defaultPathAdapter.transformTsConfigPathMappings;
+    // 1. Compile TypeScript files
+    const compileStart = Date.now();
+    await compileTypeScript({
+        inputPath: vendureConfigPath,
+        outputPath,
+        logger,
+        transformTsConfigPathMappings,
+    });
+    logger.info(`TypeScript compilation completed in ${Date.now() - compileStart}ms`);
+    // 2. Discover plugins
+    const analyzePluginsStart = Date.now();
+    const plugins = await discoverPlugins({
+        vendureConfigPath,
+        transformTsConfigPathMappings,
+        logger,
+        outputPath,
+        pluginPackageScanner,
+    });
+    logger.info(`Analyzed plugins and found ${plugins.length} dashboard extensions in ${Date.now() - analyzePluginsStart}ms`);
+    // 3. Load the compiled config
+    const configFileName = path.basename(vendureConfigPath);
+    const compiledConfigFilePath = pathToFileURL(getCompiledConfigPath({
+        inputRootDir: path.dirname(vendureConfigPath),
+        outputPath,
+        configFileName,
+    })).href.replace(/.ts$/, '.js');
+    // Create package.json with type commonjs
+    await fs.writeFile(path.join(outputPath, 'package.json'), JSON.stringify({ type: 'commonjs', private: true }, null, 2));
+    // Find the exported config symbol
+    const sourceFile = ts.createSourceFile(vendureConfigPath, await fs.readFile(vendureConfigPath, 'utf-8'), ts.ScriptTarget.Latest, true);
+    const exportedSymbolName = findConfigExport(sourceFile);
+    if (!exportedSymbolName) {
+        throw new Error(`Could not find a variable exported as VendureConfig. Please specify the name of the exported variable.`);
+    }
+    const loadConfigStart = Date.now();
+    await registerTsConfigPaths({
+        outputPath,
+        configPath: vendureConfigPath,
+        logger,
+        phase: 'loading',
+        transformTsConfigPathMappings,
+    });
+    let config;
+    try {
+        config = await import(compiledConfigFilePath).then(m => m[exportedSymbolName]);
+    }
+    catch (e) {
+        logger.error(`Error loading config: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!config) {
+        throw new Error(`Could not find a variable exported as VendureConfig with the name "${exportedSymbolName}".`);
+    }
+    logger.debug(`Loaded config in ${Date.now() - loadConfigStart}ms`);
+    return { vendureConfig: config, exportedSymbolName, pluginInfo: plugins };
+}
+/**
+ * Compiles TypeScript files to JavaScript
+ */
+async function compileTypeScript({ inputPath, outputPath, logger, transformTsConfigPathMappings, }) {
+    var _a;
+    await fs.ensureDir(outputPath);
+    // Find tsconfig paths first
+    const tsConfigInfo = await findTsConfigPaths(inputPath, logger, 'compiling', transformTsConfigPathMappings);
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10, // More explicit CJS resolution
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        noEmit: false,
+        // Speed optimizations
+        noEmitOnError: false, // Emit output even if there are errors
+        noImplicitAny: false, // Don't require implicit any
+        noUnusedLocals: false, // Don't check for unused locals
+        noUnusedParameters: false, // Don't check for unused parameters
+        allowJs: true,
+        checkJs: false, // Don't type check JS files
+        skipDefaultLibCheck: true, // Skip checking .d.ts files
+        isolatedModules: false, // Need to check cross-file references to compile dependencies
+        incremental: false, // Don't use incremental compilation (faster for one-off builds)
+        resolveJsonModule: true,
+        preserveSymlinks: false,
+        outDir: outputPath,
+    };
+    logger.debug(`Compiling ${inputPath} to ${outputPath} using TypeScript...`);
+    // Add path mappings if found
+    if (tsConfigInfo) {
+        // We need to set baseUrl and paths for TypeScript to resolve the imports
+        compilerOptions.baseUrl = tsConfigInfo.baseUrl;
+        compilerOptions.paths = tsConfigInfo.paths;
+        // This is critical - it tells TypeScript to preserve the paths in the output
+        // compilerOptions.rootDir = tsConfigInfo.baseUrl;
+    }
+    logger.debug(`tsConfig paths: ${JSON.stringify(tsConfigInfo === null || tsConfigInfo === void 0 ? void 0 : tsConfigInfo.paths, null, 2)}`);
+    logger.debug(`tsConfig baseUrl: ${(_a = tsConfigInfo === null || tsConfigInfo === void 0 ? void 0 : tsConfigInfo.baseUrl) !== null && _a !== void 0 ? _a : 'UNKNOWN'}`);
+    // Create a custom transformer to rewrite the output paths
+    const customTransformers = {
+        after: [
+            context => {
+                return sourceFile => {
+                    // Only transform files that are not the entry point
+                    if (sourceFile.fileName === inputPath) {
+                        return sourceFile;
+                    }
+                    sourceFile.fileName = path.join(outputPath, path.basename(sourceFile.fileName));
+                    return sourceFile;
+                };
+            },
+        ],
+    };
+    const program = ts.createProgram([inputPath], compilerOptions);
+    const emitResult = program.emit(undefined, undefined, undefined, undefined, customTransformers);
+    // Only log actual emit errors, not type errors
+    if (emitResult.emitSkipped) {
+        for (const diagnostic of emitResult.diagnostics) {
+            if (diagnostic.file && diagnostic.start !== undefined) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+                logger.warn(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+            }
+            else {
+                logger.warn(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+            }
+        }
+    }
+}
+async function registerTsConfigPaths(options) {
+    const { outputPath, configPath, logger, phase, transformTsConfigPathMappings } = options;
+    const tsConfigInfo = await findTsConfigPaths(configPath, logger, phase, transformTsConfigPathMappings);
+    if (tsConfigInfo) {
+        const params = {
+            baseUrl: outputPath,
+            paths: tsConfigInfo.paths,
+        };
+        logger.debug(`Registering tsconfig paths: ${JSON.stringify(params, null, 2)}`);
+        tsConfigPaths.register(params);
+    }
+}

package/dist/plugin/utils/config-loader.d.ts

@@ -1,121 +1 @@
-import { VendureConfig } from '@vendure/core';
-type Logger = {
-    info: (message: string) => void;
-    warn: (message: string) => void;
-    debug: (message: string) => void;
-};
-export type PluginInfo = {
-    name: string;
-    pluginPath: string;
-    dashboardEntryPath: string | undefined;
-};
-/**
- * @description
- * The PathAdapter interface allows customization of how paths are handled
- * when compiling the Vendure config and its imports.
- *
- * This is particularly useful in complex project structures, such as monorepos,
- * where the Vendure config file may not be in the root directory,
- * or when you need to transform TypeScript path mappings.
- */
-export interface PathAdapter {
-    /**
-     * @description
-     * A function to determine the path to the compiled Vendure config file. The default implementation
-     * simple joins the output directory with the config file name:
-     *
-     * ```ts
-     * return path.join(outputPath, configFileName)
-     * ```
-     *
-     * However, in some cases with more complex project structures, you may need to
-     * provide a custom implementation to ensure the compiled config file is
-     * correctly located.
-     *
-     * @example
-     * ```ts
-     * getCompiledConfigPath: ({ inputRootDir, outputPath, configFileName }) => {
-     *     const projectName = inputRootDir.split('/libs/')[1].split('/')[0];
-     *     const pathAfterProject = inputRootDir.split(`/libs/${projectName}`)[1];
-     *     const compiledConfigFilePath = `${outputPath}/${projectName}${pathAfterProject}`;
-     *     return path.join(compiledConfigFilePath, configFileName);
-     * },
-     * ```
-     */
-    getCompiledConfigPath?: (params: {
-        inputRootDir: string;
-        outputPath: string;
-        configFileName: string;
-    }) => string;
-    /**
-     * If your project makes use of the TypeScript `paths` configuration, the compiler will
-     * attempt to use these paths when compiling the Vendure config and its imports.
-     *
-     * In certain cases, you may need to transform these paths before they are used. For instance,
-     * if your project is a monorepo and the paths are defined relative to the root of the monorepo,
-     * you may need to adjust them to be relative to the output directory where the compiled files are located.
-     *
-     * @example
-     * ```ts
-     * transformTsConfigPathMappings: ({ phase, patterns }) => {
-     *     // "loading" phase is when the compiled Vendure code is being loaded by
-     *     // the plugin, in order to introspect the configuration of your app.
-     *     if (phase === 'loading') {
-     *         return patterns.map((p) =>
-     *             p.replace('libs/', '').replace(/.ts$/, '.js'),
-     *         );
-     *     }
-     *     return patterns;
-     * },
-     * ```
-     * @param params
-     */
-    transformTsConfigPathMappings?: (params: {
-        phase: 'compiling' | 'loading';
-        alias: string;
-        patterns: string[];
-    }) => string[];
-}
-export interface ConfigLoaderOptions {
-    vendureConfigPath: string;
-    tempDir: string;
-    pathAdapter?: PathAdapter;
-    vendureConfigExport?: string;
-    logger?: Logger;
-    reportCompilationErrors?: boolean;
-}
-export interface LoadVendureConfigResult {
-    vendureConfig: VendureConfig;
-    exportedSymbolName: string;
-    pluginInfo: PluginInfo[];
-}
-/**
- * @description
- * This function compiles the given Vendure config file and any imported relative files (i.e.
- * project files, not npm packages) into a temporary directory, and returns the compiled config.
- *
- * The reason we need to do this is that Vendure code makes use of TypeScript experimental decorators
- * (e.g. for NestJS decorators and TypeORM column decorators) which are not supported by esbuild.
- *
- * In Vite, when we load some TypeScript into the top-level Vite config file (in the end-user project), Vite
- * internally uses esbuild to temporarily compile that TypeScript code. Unfortunately, esbuild does not support
- * these experimental decorators, errors will be thrown as soon as e.g. a TypeORM column decorator is encountered.
- *
- * To work around this, we compile the Vendure config file and all its imports using the TypeScript compiler,
- * which fully supports these experimental decorators. The compiled files are then loaded by Vite, which is able
- * to handle the compiled JavaScript output.
- */
-export declare function loadVendureConfig(options: ConfigLoaderOptions): Promise<LoadVendureConfigResult>;
-type CompileFileOptions = {
-    inputRootDir: string;
-    inputPath: string;
-    outputDir: string;
-    transformTsConfigPathMappings: Required<PathAdapter>['transformTsConfigPathMappings'];
-    logger?: Logger;
-    compiledFiles?: Set<string>;
-    isRoot?: boolean;
-    pluginInfo?: PluginInfo[];
-    reportCompilationErrors?: boolean;
-};
-export declare function compileFile({ inputRootDir, inputPath, outputDir, transformTsConfigPathMappings, logger, compiledFiles, isRoot, pluginInfo, reportCompilationErrors, }: CompileFileOptions): Promise<PluginInfo[]>;
 export {};