@vendure/dashboard 3.4.1-master-202508020237 → 3.4.1-master-202508040248

package/vite/vite-plugin-admin-api-schema.ts

@@ -1,131 +0,0 @@
-import {
-    GraphQLList,
-    GraphQLNonNull,
-    GraphQLObjectType,
-    GraphQLSchema,
-    GraphQLType,
-    isEnumType,
-    isInputObjectType,
-    isObjectType,
-    isScalarType,
-} from 'graphql';
-import { Plugin } from 'vite';
-
-import { generateSchema } from './utils/schema-generator.js';
-import { ConfigLoaderApi, getConfigLoaderApi } from './vite-plugin-config-loader.js';
-
-export type FieldInfoTuple = readonly [
-    type: string,
-    nullable: boolean,
-    list: boolean,
-    isPaginatedList: boolean,
-];
-
-export interface SchemaInfo {
-    types: {
-        [typename: string]: {
-            [fieldname: string]: FieldInfoTuple;
-        };
-    };
-    inputs: {
-        [typename: string]: {
-            [fieldname: string]: FieldInfoTuple;
-        };
-    };
-    scalars: string[];
-    enums: {
-        [typename: string]: string[];
-    };
-}
-
-const virtualModuleId = 'virtual:admin-api-schema';
-const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-
-export function adminApiSchemaPlugin(): Plugin {
-    let configLoaderApi: ConfigLoaderApi;
-    let schemaInfo: SchemaInfo;
-
-    return {
-        name: 'vendure:admin-api-schema',
-        configResolved({ plugins }) {
-            configLoaderApi = getConfigLoaderApi(plugins);
-        },
-        async buildStart() {
-            const { vendureConfig } = await configLoaderApi.getVendureConfig();
-            if (!schemaInfo) {
-                const safeSchema = await generateSchema({ vendureConfig });
-                schemaInfo = generateSchemaInfo(safeSchema);
-            }
-        },
-        resolveId(id) {
-            if (id === virtualModuleId) {
-                return resolvedVirtualModuleId;
-            }
-        },
-        load(id) {
-            if (id === resolvedVirtualModuleId) {
-                return `
-                    export const schemaInfo = ${JSON.stringify(schemaInfo)};
-                `;
-            }
-        },
-    };
-}
-
-function getTypeInfo(type: GraphQLType) {
-    let nullable = true;
-    let list = false;
-    let isPaginatedList = false;
-
-    // Unwrap NonNull
-    if (type instanceof GraphQLNonNull) {
-        nullable = false;
-        type = type.ofType;
-    }
-
-    // Unwrap List
-    if (type instanceof GraphQLList) {
-        list = true;
-        type = type.ofType;
-    }
-
-    if (type instanceof GraphQLObjectType) {
-        if (type.getInterfaces().some(i => i.name === 'PaginatedList')) {
-            isPaginatedList = true;
-        }
-    }
-
-    return [type.toString().replace(/!$/, ''), nullable, list, isPaginatedList] as const;
-}
-
-function generateSchemaInfo(schema: GraphQLSchema): SchemaInfo {
-    const types = schema.getTypeMap();
-    const result: SchemaInfo = { types: {}, inputs: {}, scalars: [], enums: {} };
-
-    Object.values(types).forEach(type => {
-        if (isObjectType(type)) {
-            const fields = type.getFields();
-            result.types[type.name] = {};
-
-            Object.entries(fields).forEach(([fieldName, field]) => {
-                result.types[type.name][fieldName] = getTypeInfo(field.type);
-            });
-        }
-        if (isInputObjectType(type)) {
-            const fields = type.getFields();
-            result.inputs[type.name] = {};
-
-            Object.entries(fields).forEach(([fieldName, field]) => {
-                result.inputs[type.name][fieldName] = getTypeInfo(field.type);
-            });
-        }
-        if (isScalarType(type)) {
-            result.scalars.push(type.name);
-        }
-        if (isEnumType(type)) {
-            result.enums[type.name] = type.getValues().map(v => v.value);
-        }
-    });
-
-    return result;
-}

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

@@ -1,84 +0,0 @@
-import { Plugin } from 'vite';
-
-import { compile, CompileResult, CompilerOptions } from './utils/compiler.js';
-import { debugLogger } from './utils/logger.js';
-
-export interface ConfigLoaderApi {
-    getVendureConfig(): Promise<CompileResult>;
-}
-
-export const configLoaderName = 'vendure:config-loader';
-
-/**
- * This Vite plugin loads the VendureConfig from the specified file path, and
- * makes it available to other plugins via the `ConfigLoaderApi`.
- */
-export function configLoaderPlugin(options: CompilerOptions): Plugin {
-    let result: CompileResult;
-    const onConfigLoaded: Array<() => void> = [];
-    return {
-        name: configLoaderName,
-        async buildStart() {
-            this.info(
-                `Loading Vendure config. This can take a short while depending on the size of your project...`,
-            );
-            try {
-                const startTime = Date.now();
-                result = await compile({
-                    ...options,
-                    logger: process.env.LOG
-                        ? debugLogger
-                        : {
-                              info: (message: string) => this.info(message),
-                              warn: (message: string) => this.warn(message),
-                              debug: (message: string) => this.debug(message),
-                              error: (message: string) => this.error(message),
-                          },
-                });
-                const endTime = Date.now();
-                const duration = endTime - startTime;
-                const pluginNames = result.pluginInfo
-                    .map(p => `${p.name} ${p.sourcePluginPath ? '(local)' : '(npm)'}`)
-                    .join(', ');
-                this.info(`Found ${result.pluginInfo.length} plugins: ${pluginNames}`);
-                this.info(
-                    `Vendure config loaded (using export "${result.exportedSymbolName}") in ${duration}ms`,
-                );
-            } catch (e: unknown) {
-                if (e instanceof Error) {
-                    const message = [
-                        e.message,
-                        `If you are using a monorepo, you may need to provide a custom pathAdapter to resolve the paths correctly.`,
-                    ].join('\n');
-                    this.error(`Error loading Vendure config: ${message}`);
-                }
-            }
-            onConfigLoaded.forEach(fn => fn());
-        },
-        api: {
-            getVendureConfig(): Promise<CompileResult> {
-                if (result) {
-                    return Promise.resolve(result);
-                } else {
-                    return new Promise<CompileResult>(resolve => {
-                        onConfigLoaded.push(() => {
-                            resolve(result);
-                        });
-                    });
-                }
-            },
-        } satisfies ConfigLoaderApi,
-    };
-}
-
-/**
- * Inter-plugin dependencies implemented following the pattern given here:
- * https://rollupjs.org/plugin-development/#direct-plugin-communication
- */
-export function getConfigLoaderApi(plugins: readonly Plugin[]): ConfigLoaderApi {
-    const parentPlugin = plugins.find(plugin => plugin.name === configLoaderName);
-    if (!parentPlugin) {
-        throw new Error(`This plugin depends on the "${configLoaderName}" plugin.`);
-    }
-    return parentPlugin.api as ConfigLoaderApi;
-}

package/vite/vite-plugin-config.ts

@@ -1,70 +0,0 @@
-import path from 'path';
-import { ConfigEnv, Plugin, UserConfig } from 'vite';
-
-export function viteConfigPlugin({ packageRoot }: { packageRoot: string }): Plugin {
-    return {
-        name: 'vendure:vite-config-plugin',
-        config: (config: UserConfig, env: ConfigEnv) => {
-            // Only set the vite `root` to the dashboard package when running the dev server.
-            // During a production build we still need to reference the dashboard source which
-            // lives in `node_modules`, but we don't want the build output to be emitted in there.
-            // Therefore, we set `root` only for `serve` and, for `build`, we instead make sure that
-            // an `outDir` **outside** of `node_modules` is used (defaulting to the current working
-            // directory if the user did not provide one already).
-            config.root = packageRoot;
-
-            // If we are building and no explicit outDir has been provided (or it is a relative path),
-            // set it to an **absolute** path relative to the cwd so that the output never ends up in
-            // `node_modules`.
-            if (env.command === 'build') {
-                const buildConfig = config.build ?? {};
-
-                const hasOutDir = typeof buildConfig.outDir === 'string' && buildConfig.outDir.length > 0;
-                const outDirIsAbsolute = hasOutDir && path.isAbsolute(buildConfig.outDir as string);
-
-                const normalizedOutDir = hasOutDir
-                    ? outDirIsAbsolute
-                        ? (buildConfig.outDir as string)
-                        : path.resolve(process.cwd(), buildConfig.outDir as string)
-                    : path.resolve(process.cwd(), 'dist');
-
-                config.build = {
-                    ...buildConfig,
-                    outDir: normalizedOutDir,
-                };
-            }
-
-            config.resolve = {
-                alias: {
-                    ...(config.resolve?.alias ?? {}),
-                    // See the readme for an explanation of this alias.
-                    '@/vdb': path.resolve(packageRoot, './src/lib'),
-                    '@/graphql': path.resolve(packageRoot, './src/lib/graphql'),
-                },
-            };
-            // This is required to prevent Vite from pre-bundling the
-            // dashboard source when it resides in node_modules.
-            config.optimizeDeps = {
-                ...config.optimizeDeps,
-                exclude: [
-                    ...(config.optimizeDeps?.exclude || []),
-                    '@vendure/dashboard',
-                    '@/vdb',
-                    'virtual:vendure-ui-config',
-                    'virtual:admin-api-schema',
-                    'virtual:dashboard-extensions',
-                ],
-                // We however do want to pre-bundle recharts, as it depends
-                // on lodash which is a CJS packages and _does_ require
-                // pre-bundling.
-                include: [
-                    ...(config.optimizeDeps?.include || []),
-                    '@/components > recharts',
-                    '@/components > react-dropzone',
-                    '@vendure/common/lib/generated-types',
-                ],
-            };
-            return config;
-        },
-    };
-}

package/vite/vite-plugin-dashboard-metadata.ts

@@ -1,73 +0,0 @@
-import path from 'path';
-import { Plugin } from 'vite';
-
-import { CompileResult } from './utils/compiler.js';
-import { ConfigLoaderApi, getConfigLoaderApi } from './vite-plugin-config-loader.js';
-
-const virtualModuleId = 'virtual:dashboard-extensions';
-const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-
-/**
- * This Vite plugin scans the configured plugins for any dashboard extensions and dynamically
- * generates an import statement for each one, wrapped up in a `runDashboardExtensions()`
- * function which can then be imported and executed in the Dashboard app.
- */
-export function dashboardMetadataPlugin(): Plugin {
-    let configLoaderApi: ConfigLoaderApi;
-    let loadVendureConfigResult: CompileResult;
-    return {
-        name: 'vendure:dashboard-extensions-metadata',
-        configResolved({ plugins }) {
-            configLoaderApi = getConfigLoaderApi(plugins);
-        },
-        resolveId(id) {
-            if (id === virtualModuleId) {
-                return resolvedVirtualModuleId;
-            }
-        },
-        async load(id) {
-            if (id === resolvedVirtualModuleId) {
-                const startTime = Date.now();
-                this.debug('Loading dashboard extensions...');
-
-                if (!loadVendureConfigResult) {
-                    const configStart = Date.now();
-                    loadVendureConfigResult = await configLoaderApi.getVendureConfig();
-                    this.debug(`Loaded Vendure config in ${Date.now() - configStart}ms`);
-                }
-
-                const { pluginInfo } = loadVendureConfigResult;
-                const resolveStart = Date.now();
-                const pluginsWithExtensions =
-                    pluginInfo
-                        ?.map(({ dashboardEntryPath, pluginPath, sourcePluginPath }) => {
-                            if (!dashboardEntryPath) {
-                                return null;
-                            }
-                            // For local plugins, use the sourcePluginPath to resolve the dashboard extension
-                            const basePath = sourcePluginPath
-                                ? path.dirname(sourcePluginPath)
-                                : path.dirname(pluginPath);
-                            const resolved = path.resolve(basePath, dashboardEntryPath);
-                            this.debug(`Resolved extension path: ${resolved}`);
-                            return resolved;
-                        })
-                        .filter(x => x != null) ?? [];
-
-                this.info(
-                    `Found ${pluginsWithExtensions.length} Dashboard extensions in ${Date.now() - resolveStart}ms`,
-                );
-                this.debug(`Total dashboard extension loading completed in ${Date.now() - startTime}ms`);
-
-                return `
-                    export async function runDashboardExtensions() {
-                        ${pluginsWithExtensions
-                            .map(extension => {
-                                return `await import(\`${extension}\`);`;
-                            })
-                            .join('\n')}
-                }`;
-            }
-        },
-    };
-}

package/vite/vite-plugin-gql-tada.ts

@@ -1,62 +0,0 @@
-import { generateOutput } from '@gql.tada/cli-utils';
-import * as fs from 'fs/promises';
-import { printSchema } from 'graphql';
-import * as path from 'path';
-import { Plugin } from 'vite';
-
-import { generateSchema } from './utils/schema-generator.js';
-import { ConfigLoaderApi, getConfigLoaderApi } from './vite-plugin-config-loader.js';
-
-export function gqlTadaPlugin(options: {
-    gqlTadaOutputPath: string;
-    tempDir: string;
-    packageRoot: string;
-}): Plugin {
-    let configLoaderApi: ConfigLoaderApi;
-
-    return {
-        name: 'vendure:gql-tada',
-        configResolved({ plugins }) {
-            configLoaderApi = getConfigLoaderApi(plugins);
-        },
-        async buildStart() {
-            const { vendureConfig } = await configLoaderApi.getVendureConfig();
-            const safeSchema = await generateSchema({ vendureConfig });
-
-            const tsConfigContent = {
-                compilerOptions: {
-                    plugins: [
-                        {
-                            name: 'gql.tada/ts-plugin',
-                            schema: './schema.graphql',
-                        },
-                    ],
-                },
-            };
-
-            const tsConfigPath = path.join(options.tempDir, 'tsconfig.json');
-            await fs.writeFile(tsConfigPath, JSON.stringify(tsConfigContent, null, 2));
-
-            const schemaPath = path.join(options.tempDir, 'schema.graphql');
-            await fs.writeFile(schemaPath, printSchema(safeSchema));
-
-            await generateOutput({
-                output: path.join(options.gqlTadaOutputPath, 'graphql-env.d.ts'),
-                tsconfig: tsConfigPath,
-            });
-
-            // Copy the graphql.ts file to the output path
-            const graphqlTsPath = path.join(options.packageRoot, 'src/lib/graphql/graphql.ts');
-            try {
-                await fs.copyFile(graphqlTsPath, path.join(options.gqlTadaOutputPath, 'graphql.ts'));
-            } catch (error) {
-                if (error instanceof Error) {
-                    this.error(error.message);
-                } else {
-                    this.error('Failed to copy graphql.ts file');
-                }
-            }
-            this.info('graphql introspection files output to ' + options.gqlTadaOutputPath);
-        },
-    };
-}

package/vite/vite-plugin-tailwind-source.ts

@@ -1,81 +0,0 @@
-import path from 'path';
-import { Plugin } from 'vite';
-
-import { CompileResult } from './utils/compiler.js';
-import { ConfigLoaderApi, getConfigLoaderApi } from './vite-plugin-config-loader.js';
-
-/**
- * This Vite plugin transforms the `app/styles.css` file to include a `@source` directive
- * for each dashboard extension's source directory. This allows Tailwind CSS to
- * include styles from these extensions when processing the CSS.
- */
-export function dashboardTailwindSourcePlugin(): Plugin {
-    let configLoaderApi: ConfigLoaderApi;
-    let loadVendureConfigResult: CompileResult;
-    return {
-        name: 'vendure:dashboard-tailwind-source',
-        // Ensure this plugin runs before Tailwind CSS processing
-        enforce: 'pre',
-        configResolved({ plugins }) {
-            configLoaderApi = getConfigLoaderApi(plugins);
-        },
-        async transform(src, id) {
-            if (/app\/styles.css$/.test(id)) {
-                if (!loadVendureConfigResult) {
-                    loadVendureConfigResult = await configLoaderApi.getVendureConfig();
-                }
-                const { pluginInfo } = loadVendureConfigResult;
-                const dashboardExtensionDirs =
-                    pluginInfo
-                        ?.flatMap(({ dashboardEntryPath, sourcePluginPath, pluginPath }) => {
-                            if (!dashboardEntryPath) {
-                                return [];
-                            }
-                            const sourcePaths = [];
-                            if (sourcePluginPath) {
-                                sourcePaths.push(
-                                    path.join(
-                                        path.dirname(sourcePluginPath),
-                                        path.dirname(dashboardEntryPath),
-                                    ),
-                                );
-                            }
-                            if (pluginPath) {
-                                sourcePaths.push(
-                                    path.join(path.dirname(pluginPath), path.dirname(dashboardEntryPath)),
-                                );
-                            }
-                            return sourcePaths;
-                        })
-                        .filter(x => x != null) ?? [];
-                const sources = dashboardExtensionDirs
-                    .map(extension => {
-                        return `@source '${extension}';`;
-                    })
-                    .join('\n');
-
-                // Find the line with the specific comment and insert sources after it
-                const lines = src.split('\n');
-                const sourceCommentIndex = lines.findIndex(line =>
-                    line.includes(
-                        '/* @source rules from extensions will be added here by the dashboardTailwindSourcePlugin */',
-                    ),
-                );
-
-                if (sourceCommentIndex !== -1) {
-                    // Insert the sources after the comment line
-                    lines.splice(sourceCommentIndex + 1, 0, sources);
-                    const modifiedSrc = lines.join('\n');
-                    return {
-                        code: modifiedSrc,
-                    };
-                }
-
-                // If the comment is not found, append sources at the end
-                return {
-                    code: src + '\n' + sources,
-                };
-            }
-        },
-    };
-}