@vendure/dashboard 3.2.2 → 3.2.4

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

@@ -0,0 +1,10 @@
+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.
+ */
+export declare function findConfigExport(sourceFile: ts.SourceFile): string | undefined;

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

@@ -0,0 +1,96 @@
+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.
+ */
+export function findConfigExport(sourceFile) {
+    let exportedSymbolName;
+    function visit(node) {
+        var _a;
+        if (ts.isVariableStatement(node) &&
+            ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.ExportKeyword))) {
+            node.declarationList.declarations.forEach(declaration => {
+                if (ts.isVariableDeclaration(declaration)) {
+                    const typeNode = declaration.type;
+                    if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+                        const typeName = typeNode.typeName;
+                        if (ts.isIdentifier(typeName) && typeName.text === 'VendureConfig') {
+                            if (ts.isIdentifier(declaration.name)) {
+                                exportedSymbolName = declaration.name.text;
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    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.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,120 @@
+import ts from 'typescript';
+import { describe, it, expect } from 'vitest';
+import { getPluginInfo, findConfigExport } 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',
+        });
+    });
+});
+describe('findConfigExport', () => {
+    it('should return undefined when no VendureConfig export is found', () => {
+        const sourceText = `
+            export const notConfig = {
+                some: 'value'
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBeUndefined();
+    });
+    it('should find exported variable with VendureConfig type', () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+    it('should find exported variable with VendureConfig type among other exports', () => {
+        const sourceText = `
+            import { VendureConfig } from '@vendure/core';
+
+            export const otherExport = 'value';
+            export const config: VendureConfig = {
+                authOptions: {
+                    tokenMethod: 'bearer'
+                }
+            };
+            export const anotherExport = 123;
+        `;
+        const sourceFile = ts.createSourceFile('path/to/test.ts', sourceText, ts.ScriptTarget.Latest, true);
+        const result = findConfigExport(sourceFile);
+        expect(result).toBe('config');
+    });
+});

package/dist/plugin/{config-loader.d.ts → utils/config-loader.d.ts}

@@ -1,8 +1,24 @@
 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;
+};
 export interface ConfigLoaderOptions {
     vendureConfigPath: string;
     tempDir: string;
     vendureConfigExport?: string;
+    logger?: Logger;
+}
+export interface LoadVendureConfigResult {
+    vendureConfig: VendureConfig;
+    exportedSymbolName: string;
+    pluginInfo: PluginInfo[];
 }
 /**
  * @description
@@ -16,12 +32,10 @@ export interface ConfigLoaderOptions {
  * 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 SWC, which does support
- * these experimental decorators. The compiled files are then loaded by Vite, which is able to handle the compiled
- * JavaScript output.
+ * 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<{
-    vendureConfig: VendureConfig;
-    exportedSymbolName: string;
-}>;
-export declare function compileFile(inputRootDir: string, inputPath: string, outputDir: string, compiledFiles?: Set<string>): Promise<void>;
+export declare function loadVendureConfig(options: ConfigLoaderOptions): Promise<LoadVendureConfigResult>;
+export declare function compileFile(inputRootDir: string, inputPath: string, outputDir: string, logger?: Logger, compiledFiles?: Set<string>, isRoot?: boolean, pluginInfo?: PluginInfo[]): Promise<PluginInfo[]>;
+export {};

package/dist/plugin/utils/config-loader.js

@@ -0,0 +1,325 @@
+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';
+const defaultLogger = {
+    info: (message) => {
+        /* noop */
+    },
+    warn: (message) => {
+        /* noop */
+    },
+    debug: (message) => {
+        /* noop */
+    },
+};
+/**
+ * @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) {
+    const { vendureConfigPath, vendureConfigExport, tempDir } = options;
+    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, vendureConfigPath, outputPath, logger);
+    const compiledConfigFilePath = pathToFileURL(path.join(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);
+    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, logger) {
+    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 = {};
+                        for (const [alias, patterns] of Object.entries(compilerOptions.paths)) {
+                            // Store paths as defined in tsconfig, they will be relative to baseUrl
+                            paths[alias] = patterns.map(pattern => 
+                            // Normalize slashes for consistency, keep relative
+                            pattern.replace(/\\/g, '/'));
+                        }
+                        logger.debug(`Found tsconfig paths in ${tsConfigPath}: ${JSON.stringify({ baseUrl: tsConfigBaseUrl, paths }, null, 2)}`);
+                        return { baseUrl: tsConfigBaseUrl, paths };
+                    }
+                }
+                catch (e) {
+                    logger.warn(`Could not read or parse tsconfig file ${tsConfigPath}: ${e.message}`);
+                }
+            }
+        }
+        catch (e) {
+            // If we can't read the directory, just continue to the parent
+            logger.warn(`Could not read directory ${currentDir}: ${e.message}`);
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    logger.debug(`No tsconfig paths found traversing up from ${configDir}`);
+    return undefined;
+}
+export async function compileFile(inputRootDir, inputPath, outputDir, logger = defaultLogger, compiledFiles = new Set(), isRoot = true, 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();
+    let tsConfigInfo;
+    if (isRoot) {
+        tsConfigInfo = await findTsConfigPaths(absoluteInputPath, logger);
+        if (tsConfigInfo) {
+            logger === null || logger === void 0 ? void 0 : logger.debug(`Using TypeScript configuration: ${JSON.stringify(tsConfigInfo, null, 2)}`);
+        }
+    }
+    async function collectImports(node) {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const importPath = node.moduleSpecifier.text;
+            // Handle relative imports
+            if (importPath.startsWith('.')) {
+                const resolvedPath = path.resolve(path.dirname(absoluteInputPath), importPath);
+                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 === null || logger === void 0 ? void 0 : 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 + '.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) ||
+                    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, importPath, outputDir, logger, compiledFiles, 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 = {
+            // 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();
+        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, emitResult, 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/dist/plugin/{schema-generator.d.ts → utils/schema-generator.d.ts}

@@ -1,5 +1,10 @@
 import { VendureConfig } from '@vendure/core';
 import { GraphQLSchema } from 'graphql';
+/**
+ * @description
+ * This function generates a GraphQL schema from the Vendure config.
+ * It is used to generate the schema for the dashboard.
+ */
 export declare function generateSchema({ vendureConfig, }: {
     vendureConfig: VendureConfig;
 }): Promise<GraphQLSchema>;

package/dist/plugin/{schema-generator.js → utils/schema-generator.js}

@@ -2,8 +2,14 @@ import { GraphQLTypesLoader } from '@nestjs/graphql';
 import { resetConfig, setConfig, getConfig, runPluginConfigurations, getFinalVendureSchema, VENDURE_ADMIN_API_TYPE_PATHS, } from '@vendure/core';
 import { buildSchema } from 'graphql';
 let schemaPromise;
+/**
+ * @description
+ * This function generates a GraphQL schema from the Vendure config.
+ * It is used to generate the schema for the dashboard.
+ */
 export async function generateSchema({ vendureConfig, }) {
     if (!schemaPromise) {
+        /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
         schemaPromise = new Promise(async (resolve, reject) => {
             resetConfig();
             await setConfig(vendureConfig !== null && vendureConfig !== void 0 ? vendureConfig : {});

package/dist/plugin/{ui-config.js → utils/ui-config.js}

@@ -1,6 +1,6 @@
 import { DEFAULT_AUTH_TOKEN_HEADER_KEY, DEFAULT_CHANNEL_TOKEN_KEY, ADMIN_API_PATH, } from '@vendure/common/lib/shared-constants';
-import { defaultAvailableLocales } from './constants.js';
-import { defaultLocale, defaultLanguage, defaultAvailableLanguages } from './constants.js';
+import { defaultAvailableLocales } from '../constants.js';
+import { defaultLocale, defaultLanguage, defaultAvailableLanguages } from '../constants.js';
 export function getAdminUiConfig(config, adminUiConfig) {
     const { authOptions, apiOptions } = config;
     const propOrDefault = (prop, defaultVal, isArray = false) => {

package/dist/plugin/vite-plugin-admin-api-schema.js

@@ -1,5 +1,5 @@
 import { GraphQLList, GraphQLNonNull, GraphQLObjectType, isEnumType, isInputObjectType, isObjectType, isScalarType, } from 'graphql';
-import { generateSchema } from './schema-generator.js';
+import { generateSchema } from './utils/schema-generator.js';
 import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
 const virtualModuleId = 'virtual:admin-api-schema';
 const resolvedVirtualModuleId = `\0${virtualModuleId}`;
@@ -12,7 +12,7 @@ export function adminApiSchemaPlugin() {
             configLoaderApi = getConfigLoaderApi(plugins);
         },
         async buildStart() {
-            const vendureConfig = await configLoaderApi.getVendureConfig();
+            const { vendureConfig } = await configLoaderApi.getVendureConfig();
             if (!schemaInfo) {
                 const safeSchema = await generateSchema({ vendureConfig });
                 schemaInfo = generateSchemaInfo(safeSchema);

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

@@ -1,8 +1,7 @@
-import { VendureConfig } from '@vendure/core';
 import { Plugin } from 'vite';
-import { ConfigLoaderOptions } from './config-loader.js';
+import { ConfigLoaderOptions, LoadVendureConfigResult } from './utils/config-loader.js';
 export interface ConfigLoaderApi {
-    getVendureConfig(): Promise<VendureConfig>;
+    getVendureConfig(): Promise<LoadVendureConfigResult>;
 }
 export declare const configLoaderName = "vendure:config-loader";
 /**