@vendure/dashboard 3.3.6-master-202507110238 → 3.3.6

package/vite/utils/config-loader.ts

@@ -1,555 +0,0 @@
-import { VendureConfig } from '@vendure/core';
-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, getPluginInfo } from './ast-utils.js';
-
-type Logger = {
-    info: (message: string) => void;
-    warn: (message: string) => void;
-    debug: (message: string) => void;
-};
-
-export type PluginInfo = {
-    name: string;
-    pluginPath: string;
-    dashboardEntryPath: string | undefined;
-};
-
-const defaultLogger: Logger = {
-    info: (message: string) => {
-        /* noop */
-    },
-    warn: (message: string) => {
-        /* noop */
-    },
-    debug: (message: string) => {
-        /* noop */
-    },
-};
-
-/**
- * @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[];
-}
-
-const defaultPathAdapter: Required<PathAdapter> = {
-    getCompiledConfigPath: ({ outputPath, configFileName }) => path.join(outputPath, configFileName),
-    transformTsConfigPathMappings: ({ patterns }) => patterns,
-};
-
-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 async function loadVendureConfig(options: ConfigLoaderOptions): Promise<LoadVendureConfigResult> {
-    const { vendureConfigPath, vendureConfigExport, tempDir, pathAdapter } = options;
-    const getCompiledConfigPath =
-        pathAdapter?.getCompiledConfigPath ?? defaultPathAdapter.getCompiledConfigPath;
-    const transformTsConfigPathMappings =
-        pathAdapter?.transformTsConfigPathMappings ?? defaultPathAdapter.transformTsConfigPathMappings;
-    const logger = options.logger || defaultLogger;
-    const outputPath = tempDir;
-    const configFileName = path.basename(vendureConfigPath);
-    const inputRootDir = path.dirname(vendureConfigPath);
-    await fs.remove(outputPath);
-    const pluginInfo = await compileFile({
-        inputRootDir,
-        inputPath: vendureConfigPath,
-        outputDir: outputPath,
-        logger,
-        transformTsConfigPathMappings,
-    });
-    const compiledConfigFilePath = pathToFileURL(
-        getCompiledConfigPath({
-            inputRootDir,
-            outputPath,
-            configFileName,
-        }),
-    ).href.replace(/.ts$/, '.js');
-    // create package.json with type commonjs and save it to the output dir
-    await fs.writeFile(path.join(outputPath, 'package.json'), JSON.stringify({ type: 'commonjs' }, null, 2));
-
-    // We need to figure out the symbol exported by the config file by
-    // analyzing the AST and finding an export with the type "VendureConfig"
-    const sourceFile = ts.createSourceFile(
-        vendureConfigPath,
-        await fs.readFile(vendureConfigPath, 'utf-8'),
-        ts.ScriptTarget.Latest,
-        true,
-    );
-    const detectedExportedSymbolName = findConfigExport(sourceFile);
-    const configExportedSymbolName = detectedExportedSymbolName || vendureConfigExport;
-    if (!configExportedSymbolName) {
-        throw new Error(
-            `Could not find a variable exported as VendureConfig. Please specify the name of the exported variable using the "vendureConfigExport" option.`,
-        );
-    }
-
-    // Register path aliases from tsconfig before importing
-    const tsConfigInfo = await findTsConfigPaths(
-        vendureConfigPath,
-        logger,
-        'loading',
-        transformTsConfigPathMappings,
-    );
-    if (tsConfigInfo) {
-        tsConfigPaths.register({
-            baseUrl: outputPath,
-            paths: tsConfigInfo.paths,
-        });
-    }
-
-    const config = await import(compiledConfigFilePath).then(m => m[configExportedSymbolName]);
-    if (!config) {
-        throw new Error(
-            `Could not find a variable exported as VendureConfig with the name "${configExportedSymbolName}".`,
-        );
-    }
-    return { vendureConfig: config, exportedSymbolName: configExportedSymbolName, pluginInfo };
-}
-
-/**
- * Finds and parses tsconfig files in the given directory and its parent directories.
- * Returns the paths configuration if found.
- */
-async function findTsConfigPaths(
-    configPath: string,
-    logger: Logger,
-    phase: 'compiling' | 'loading',
-    transformTsConfigPathMappings: Required<PathAdapter>['transformTsConfigPathMappings'],
-): Promise<{ baseUrl: string; paths: Record<string, string[]> } | undefined> {
-    const configDir = path.dirname(configPath);
-    let currentDir = configDir;
-
-    while (currentDir !== path.parse(currentDir).root) {
-        try {
-            const files = await fs.readdir(currentDir);
-            const tsConfigFiles = files.filter(file => /^tsconfig(\..*)?\.json$/.test(file));
-
-            for (const fileName of tsConfigFiles) {
-                const tsConfigPath = path.join(currentDir, fileName);
-                try {
-                    const tsConfigContent = await fs.readFile(tsConfigPath, 'utf-8');
-                    // Use JSON5 or similar parser if comments are expected in tsconfig.json
-                    // For simplicity, assuming standard JSON here. Handle parse errors.
-                    const tsConfig = JSON.parse(tsConfigContent);
-                    const compilerOptions = tsConfig.compilerOptions || {};
-
-                    if (compilerOptions.paths) {
-                        // Determine the effective baseUrl: explicitly set or the directory of tsconfig.json
-                        const tsConfigBaseUrl = path.resolve(currentDir, compilerOptions.baseUrl || '.');
-                        const paths: Record<string, string[]> = {};
-
-                        for (const [alias, patterns] of Object.entries(compilerOptions.paths)) {
-                            // Store paths as defined in tsconfig, they will be relative to baseUrl
-                            const normalizedPatterns = (patterns as string[]).map(pattern =>
-                                // Normalize slashes for consistency, keep relative
-                                pattern.replace(/\\/g, '/'),
-                            );
-                            paths[alias] = transformTsConfigPathMappings({
-                                phase,
-                                alias,
-                                patterns: normalizedPatterns,
-                            });
-                        }
-                        logger.debug(
-                            `Found tsconfig paths in ${tsConfigPath}: ${JSON.stringify(
-                                {
-                                    baseUrl: tsConfigBaseUrl,
-                                    paths,
-                                },
-                                null,
-                                2,
-                            )}`,
-                        );
-                        return { baseUrl: tsConfigBaseUrl, paths };
-                    }
-                } catch (e: any) {
-                    logger.warn(
-                        `Could not read or parse tsconfig file ${tsConfigPath}: ${e.message as string}`,
-                    );
-                }
-            }
-        } catch (e: any) {
-            // If we can't read the directory, just continue to the parent
-            logger.warn(`Could not read directory ${currentDir}: ${e.message as string}`);
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    logger.debug(`No tsconfig paths found traversing up from ${configDir}`);
-    return undefined;
-}
-
-type CompileFileOptions = {
-    inputRootDir: string;
-    inputPath: string;
-    outputDir: string;
-    transformTsConfigPathMappings: Required<PathAdapter>['transformTsConfigPathMappings'];
-    logger?: Logger;
-    compiledFiles?: Set<string>;
-    isRoot?: boolean;
-    pluginInfo?: PluginInfo[];
-    reportCompilationErrors?: boolean;
-};
-
-export async function compileFile({
-    inputRootDir,
-    inputPath,
-    outputDir,
-    transformTsConfigPathMappings,
-    logger = defaultLogger,
-    compiledFiles = new Set<string>(),
-    isRoot = true,
-    pluginInfo = [],
-    reportCompilationErrors = false,
-}: CompileFileOptions): Promise<PluginInfo[]> {
-    const absoluteInputPath = path.resolve(inputPath);
-    if (compiledFiles.has(absoluteInputPath)) {
-        return pluginInfo;
-    }
-    compiledFiles.add(absoluteInputPath);
-
-    // Ensure output directory exists
-    await fs.ensureDir(outputDir);
-
-    // Read the source file
-    const source = await fs.readFile(inputPath, 'utf-8');
-
-    // Parse the source to find relative imports
-    const sourceFile = ts.createSourceFile(absoluteInputPath, source, ts.ScriptTarget.Latest, true);
-
-    const importPaths = new Set<string>();
-    let tsConfigInfo: { baseUrl: string; paths: Record<string, string[]> } | undefined;
-
-    if (isRoot) {
-        tsConfigInfo = await findTsConfigPaths(
-            absoluteInputPath,
-            logger,
-            'compiling',
-            transformTsConfigPathMappings,
-        );
-        if (tsConfigInfo) {
-            logger?.debug(`Using TypeScript configuration: ${JSON.stringify(tsConfigInfo, null, 2)}`);
-        }
-    }
-
-    async function collectImports(node: ts.Node) {
-        if (
-            (ts.isExportDeclaration(node) || ts.isImportDeclaration(node)) &&
-            node.moduleSpecifier &&
-            ts.isStringLiteral(node.moduleSpecifier)
-        ) {
-            const importPath = node.moduleSpecifier.text;
-
-            // Handle relative imports
-            if (importPath.startsWith('.')) {
-                const resolvedPath = path.resolve(path.dirname(absoluteInputPath), importPath);
-                // TODO: does this handle index files correctly?
-                let resolvedTsPath = resolvedPath + '.ts';
-                // Also check for .tsx if .ts doesn't exist
-                if (!(await fs.pathExists(resolvedTsPath))) {
-                    const resolvedTsxPath = resolvedPath + '.tsx';
-                    if (await fs.pathExists(resolvedTsxPath)) {
-                        resolvedTsPath = resolvedTsxPath;
-                    } else {
-                        // If neither exists, maybe it's an index file?
-                        const resolvedIndexPath = path.join(resolvedPath, 'index.ts');
-                        if (await fs.pathExists(resolvedIndexPath)) {
-                            resolvedTsPath = resolvedIndexPath;
-                        } else {
-                            const resolvedIndexTsxPath = path.join(resolvedPath, 'index.tsx');
-                            if (await fs.pathExists(resolvedIndexTsxPath)) {
-                                resolvedTsPath = resolvedIndexTsxPath;
-                            } else {
-                                // If still not found, log a warning or let TS handle it later
-                                logger?.warn(
-                                    `Could not resolve relative import "${importPath}" from "${absoluteInputPath}" to an existing .ts/.tsx file.`,
-                                );
-                                // Do not add to importPaths if we can't verify existence
-                                return;
-                            }
-                        }
-                    }
-                }
-                importPaths.add(resolvedTsPath);
-            }
-            // Handle path aliases if tsConfigInfo exists
-            else if (tsConfigInfo) {
-                // Attempt to resolve using path aliases
-                let resolved = false;
-                for (const [alias, patterns] of Object.entries(tsConfigInfo.paths)) {
-                    const aliasPrefix = alias.replace('*', '');
-                    const aliasSuffix = alias.endsWith('*') ? '*' : '';
-
-                    if (
-                        importPath.startsWith(aliasPrefix) &&
-                        (aliasSuffix === '*' || importPath === aliasPrefix)
-                    ) {
-                        const remainingImportPath = importPath.slice(aliasPrefix.length);
-                        for (const pattern of patterns) {
-                            const patternPrefix = pattern.replace('*', '');
-                            const patternSuffix = pattern.endsWith('*') ? '*' : '';
-                            // Ensure suffix match consistency (* vs exact)
-                            if (aliasSuffix !== patternSuffix) continue;
-
-                            const potentialPathBase = path.resolve(tsConfigInfo.baseUrl, patternPrefix);
-                            const resolvedPath = path.join(potentialPathBase, remainingImportPath);
-
-                            let resolvedTsPath = resolvedPath.endsWith('.ts')
-                                ? resolvedPath
-                                : resolvedPath + '.ts';
-                            // Similar existence checks as relative paths
-                            if (!(await fs.pathExists(resolvedTsPath))) {
-                                const resolvedTsxPath = resolvedPath + '.tsx';
-                                if (await fs.pathExists(resolvedTsxPath)) {
-                                    resolvedTsPath = resolvedTsxPath;
-                                } else {
-                                    const resolvedIndexPath = path.join(resolvedPath, 'index.ts');
-                                    if (await fs.pathExists(resolvedIndexPath)) {
-                                        resolvedTsPath = resolvedIndexPath;
-                                    } else {
-                                        const resolvedIndexTsxPath = path.join(resolvedPath, 'index.tsx');
-                                        if (await fs.pathExists(resolvedIndexTsxPath)) {
-                                            resolvedTsPath = resolvedIndexTsxPath;
-                                        } else {
-                                            // Path doesn't resolve to a file for this pattern
-                                            continue;
-                                        }
-                                    }
-                                }
-                            }
-                            // Add the first successful resolution for this alias
-                            importPaths.add(resolvedTsPath);
-                            resolved = true;
-                            break; // Stop checking patterns for this alias
-                        }
-                    }
-                    if (resolved) break; // Stop checking other aliases if resolved
-                }
-            }
-            // For all other imports (node_modules, etc), we should still add them to be processed
-            // by the TypeScript compiler, even if we can't resolve them to a file
-            else {
-                // Add the import path as is - TypeScript will handle resolution
-                // importPaths.add(importPath);
-            }
-        } else {
-            const children = node.getChildren();
-            for (const child of children) {
-                // Only process nodes that could contain import statements
-                if (
-                    ts.isSourceFile(child) ||
-                    ts.isModuleBlock(child) ||
-                    ts.isModuleDeclaration(child) ||
-                    ts.isImportDeclaration(child) ||
-                    ts.isExportDeclaration(child) ||
-                    child.kind === ts.SyntaxKind.SyntaxList
-                ) {
-                    await collectImports(child);
-                }
-            }
-        }
-    }
-
-    // Start collecting imports from the source file
-    await collectImports(sourceFile);
-
-    const extractedPluginInfo = getPluginInfo(sourceFile);
-    if (extractedPluginInfo) {
-        pluginInfo.push(extractedPluginInfo);
-    }
-
-    // Store the tsConfigInfo on the first call if found
-    const rootTsConfigInfo = isRoot ? tsConfigInfo : undefined;
-
-    // Recursively collect all files that need to be compiled
-    for (const importPath of importPaths) {
-        // Pass rootTsConfigInfo down, but set isRoot to false
-        await compileFile({
-            inputRootDir,
-            inputPath: importPath,
-            outputDir,
-            logger,
-            transformTsConfigPathMappings,
-            compiledFiles,
-            isRoot: false,
-            pluginInfo,
-        });
-    }
-
-    // If this is the root file (the one that started the compilation),
-    // use the TypeScript compiler API to compile all files together
-    if (isRoot) {
-        logger.info(`Starting compilation for ${compiledFiles.size} files...`);
-        const allFiles = Array.from(compiledFiles);
-        const compilerOptions: ts.CompilerOptions = {
-            // Base options
-            target: ts.ScriptTarget.ES2020,
-            module: ts.ModuleKind.CommonJS, // Output CommonJS for Node compatibility
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            esModuleInterop: true,
-            skipLibCheck: true, // Faster compilation
-            forceConsistentCasingInFileNames: true,
-            moduleResolution: ts.ModuleResolutionKind.NodeJs, // Use Node.js module resolution
-            incremental: false, // No need for incremental compilation
-            noEmitOnError: false, // Continue emitting even with errors
-            isolatedModules: true, // Treat files as separate modules
-            strict: false, // Disable strict type checking for speed
-            noUnusedLocals: false, // Skip unused locals check
-            noUnusedParameters: false, // Skip unused parameters check
-
-            // Output options
-            outDir: outputDir, // Output directory for all compiled files
-            sourceMap: false, // Generate source maps
-            declaration: false, // Don't generate .d.ts files
-
-            // Path resolution options - use info found from tsconfig
-            baseUrl: rootTsConfigInfo ? rootTsConfigInfo.baseUrl : undefined, // Let TS handle resolution if no baseUrl
-            paths: rootTsConfigInfo ? rootTsConfigInfo.paths : undefined,
-            // rootDir: inputRootDir, // Often inferred correctly, can cause issues if set explicitly sometimes
-            allowJs: true, // Allow JS files if needed, though we primarily collect TS
-            resolveJsonModule: true, // Allow importing JSON
-        };
-
-        logger.debug(`compilerOptions: ${JSON.stringify(compilerOptions, null, 2)}`);
-
-        // Create a Program to represent the compilation context
-        const program = ts.createProgram(allFiles, compilerOptions);
-        logger.info(`Emitting compiled files to ${outputDir}`);
-        const emitResult = program.emit();
-
-        if (reportCompilationErrors) {
-            const hasEmitErrors = reportDiagnostics(program, emitResult, logger);
-
-            if (hasEmitErrors) {
-                throw new Error('TypeScript compilation failed with errors.');
-            }
-        }
-
-        logger.info(`Successfully compiled ${allFiles.length} files to ${outputDir}`);
-    }
-    return pluginInfo;
-}
-
-function reportDiagnostics(program: ts.Program, emitResult: ts.EmitResult, logger: Logger) {
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-    let hasEmitErrors = emitResult.emitSkipped;
-    allDiagnostics.forEach(diagnostic => {
-        if (diagnostic.file && diagnostic.start) {
-            const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            const logFn = diagnostic.category === ts.DiagnosticCategory.Error ? logger.warn : logger.info;
-            // eslint-disable-next-line no-console
-            console.log(
-                `TS${diagnostic.code} ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`,
-            );
-            if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                hasEmitErrors = true;
-            }
-        } else {
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            const logFn = diagnostic.category === ts.DiagnosticCategory.Error ? logger.warn : logger.info;
-            // eslint-disable-next-line no-console
-            console.log(`TS${diagnostic.code}: ${message}`);
-            if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                hasEmitErrors = true;
-            }
-        }
-    });
-    return hasEmitErrors;
-}

package/vite/utils/logger.ts

@@ -0,0 +1,43 @@
+import { Logger } from '../types.js';
+
+// ANSI color codes
+const colors = {
+    grey: '\x1b[90m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    reset: '\x1b[0m',
+} as const;
+
+export const debugLogger: Logger = {
+    info: (message: string) => {
+        // eslint-disable-next-line no-console
+        console.log(`[INFO] ${message}`);
+    },
+    warn: (message: string) => {
+        // eslint-disable-next-line no-console
+        console.warn(`${colors.yellow}[WARN] ${message}${colors.reset}`);
+    },
+    debug: (message: string) => {
+        // eslint-disable-next-line no-console
+        console.debug(`${colors.grey}[DEBUG] ${message}${colors.reset}`);
+    },
+    error: (message: string) => {
+        // eslint-disable-next-line no-console
+        console.error(`${colors.red}[ERROR] ${message}${colors.reset}`);
+    },
+};
+
+export const noopLogger: Logger = {
+    info: () => {
+        /* noop */
+    },
+    warn: () => {
+        /* noop */
+    },
+    debug: () => {
+        /* noop */
+    },
+    error: () => {
+        /* noop */
+    },
+};