@vendure/dashboard 3.2.0

package/dist/plugin/config-loader.js

@@ -0,0 +1,141 @@
+import { parse, transform } from '@swc/core';
+import fs from 'fs-extra';
+import path from 'path';
+import { pathToFileURL } from 'url';
+/**
+ * @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 SWC, which does support
+ * 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 outputPath = tempDir;
+    const configFileName = path.basename(vendureConfigPath);
+    const inputRootDir = path.dirname(vendureConfigPath);
+    await fs.remove(outputPath);
+    await compileFile(inputRootDir, vendureConfigPath, outputPath);
+    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 ast = await parse(await fs.readFile(vendureConfigPath, 'utf-8'), {
+        syntax: 'typescript',
+        decorators: true,
+    });
+    const detectedExportedSymbolName = findConfigExport(ast.body);
+    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.`);
+    }
+    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 };
+}
+/**
+ * Given the AST of a TypeScript file, finds the name of the variable exported as VendureConfig.
+ */
+function findConfigExport(statements) {
+    var _a;
+    for (const statement of statements) {
+        if (statement.type === 'ExportDeclaration') {
+            if (statement.declaration.type === 'VariableDeclaration') {
+                for (const declaration of statement.declaration.declarations) {
+                    if (isBindingIdentifier(declaration.id)) {
+                        const typeRef = (_a = declaration.id.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation;
+                        if ((typeRef === null || typeRef === void 0 ? void 0 : typeRef.type) === 'TsTypeReference') {
+                            if (typeRef.typeName.type === 'Identifier' &&
+                                typeRef.typeName.value === 'VendureConfig') {
+                                return declaration.id.value;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function isBindingIdentifier(id) {
+    return id.type === 'Identifier' && !!id.typeAnnotation;
+}
+export async function compileFile(inputRootDir, inputPath, outputDir, compiledFiles = new Set()) {
+    if (compiledFiles.has(inputPath)) {
+        return;
+    }
+    compiledFiles.add(inputPath);
+    // Ensure output directory exists
+    await fs.ensureDir(outputDir);
+    // Read the source file
+    const source = await fs.readFile(inputPath, 'utf-8');
+    // Transform config
+    const config = {
+        filename: inputPath,
+        sourceMaps: true,
+        jsc: {
+            parser: {
+                syntax: 'typescript',
+                tsx: false,
+                decorators: true,
+            },
+            target: 'es2020',
+            loose: false,
+            transform: {
+                legacyDecorator: true,
+                decoratorMetadata: true,
+            },
+        },
+        module: {
+            type: 'commonjs',
+            strict: true,
+            strictMode: true,
+            lazy: false,
+            noInterop: false,
+        },
+    };
+    // Transform the code using SWC
+    const result = await transform(source, config);
+    // Generate output file path
+    const relativePath = path.relative(inputRootDir, inputPath);
+    const outputPath = path.join(outputDir, relativePath).replace(/\.ts$/, '.js');
+    // Ensure the subdirectory for the output file exists
+    await fs.ensureDir(path.dirname(outputPath));
+    // Write the transformed code
+    await fs.writeFile(outputPath, result.code);
+    // Write source map if available
+    if (result.map) {
+        await fs.writeFile(`${outputPath}.map`, JSON.stringify(result.map));
+    }
+    // Parse the source to find relative imports
+    const ast = await parse(source, { syntax: 'typescript', decorators: true });
+    const importPaths = new Set();
+    function collectImports(node) {
+        if (node.type === 'ImportDeclaration' && node.source.value.startsWith('.')) {
+            const importPath = path.resolve(path.dirname(inputPath), node.source.value);
+            importPaths.add(importPath + '.ts');
+        }
+        for (const key in node) {
+            if (node[key] && typeof node[key] === 'object') {
+                collectImports(node[key]);
+            }
+        }
+    }
+    collectImports(ast);
+    // Recursively compile all relative imports
+    for (const importPath of importPaths) {
+        await compileFile(inputRootDir, importPath, outputDir, compiledFiles);
+    }
+}

package/dist/plugin/constants.d.ts

@@ -0,0 +1,5 @@
+import { LanguageCode } from '@vendure/core';
+export declare const defaultLanguage = LanguageCode.en;
+export declare const defaultLocale: undefined;
+export declare const defaultAvailableLanguages: LanguageCode[];
+export declare const defaultAvailableLocales: string[];

package/dist/plugin/constants.js

@@ -0,0 +1,277 @@
+import { LanguageCode } from '@vendure/core';
+export const defaultLanguage = LanguageCode.en;
+export const defaultLocale = undefined;
+export const defaultAvailableLanguages = [
+    LanguageCode.he,
+    LanguageCode.ar,
+    LanguageCode.de,
+    LanguageCode.en,
+    LanguageCode.es,
+    LanguageCode.pl,
+    LanguageCode.zh_Hans,
+    LanguageCode.zh_Hant,
+    LanguageCode.pt_BR,
+    LanguageCode.pt_PT,
+    LanguageCode.cs,
+    LanguageCode.fr,
+    LanguageCode.ru,
+    LanguageCode.uk,
+    LanguageCode.it,
+    LanguageCode.fa,
+    LanguageCode.ne,
+    LanguageCode.hr,
+    LanguageCode.sv,
+    LanguageCode.nb,
+    LanguageCode.tr,
+];
+export const defaultAvailableLocales = [
+    'AF',
+    'AL',
+    'DZ',
+    'AS',
+    'AD',
+    'AO',
+    'AI',
+    'AQ',
+    'AG',
+    'AR',
+    'AM',
+    'AW',
+    'AU',
+    'AT',
+    'AZ',
+    'BS',
+    'BH',
+    'BD',
+    'BB',
+    'BY',
+    'BE',
+    'BZ',
+    'BJ',
+    'BM',
+    'BT',
+    'BO',
+    'BQ',
+    'BA',
+    'BW',
+    'BV',
+    'BR',
+    'IO',
+    'BN',
+    'BG',
+    'BF',
+    'BI',
+    'CV',
+    'KH',
+    'CM',
+    'CA',
+    'KY',
+    'CF',
+    'TD',
+    'CL',
+    'CN',
+    'CX',
+    'CC',
+    'CO',
+    'KM',
+    'CD',
+    'CG',
+    'CK',
+    'CR',
+    'HR',
+    'CU',
+    'CW',
+    'CY',
+    'CZ',
+    'CI',
+    'DK',
+    'DJ',
+    'DM',
+    'DO',
+    'EC',
+    'EG',
+    'SV',
+    'GQ',
+    'ER',
+    'EE',
+    'SZ',
+    'ET',
+    'FK',
+    'FO',
+    'FJ',
+    'FI',
+    'FR',
+    'GF',
+    'PF',
+    'TF',
+    'GA',
+    'GM',
+    'GE',
+    'DE',
+    'GH',
+    'GI',
+    'GR',
+    'GL',
+    'GD',
+    'GP',
+    'GU',
+    'GT',
+    'GG',
+    'GN',
+    'GW',
+    'GY',
+    'HT',
+    'HM',
+    'VA',
+    'HN',
+    'HK',
+    'HU',
+    'IS',
+    'IN',
+    'ID',
+    'IR',
+    'IQ',
+    'IE',
+    'IM',
+    'IL',
+    'IT',
+    'JM',
+    'JP',
+    'JE',
+    'JO',
+    'KZ',
+    'KE',
+    'KI',
+    'KP',
+    'KR',
+    'KW',
+    'KG',
+    'LA',
+    'LV',
+    'LB',
+    'LS',
+    'LR',
+    'LY',
+    'LI',
+    'LT',
+    'LU',
+    'MO',
+    'MG',
+    'MW',
+    'MY',
+    'MV',
+    'ML',
+    'MT',
+    'MH',
+    'MQ',
+    'MR',
+    'MU',
+    'YT',
+    'MX',
+    'FM',
+    'MD',
+    'MC',
+    'MN',
+    'ME',
+    'MS',
+    'MA',
+    'MZ',
+    'MM',
+    'NA',
+    'NR',
+    'NP',
+    'NL',
+    'NC',
+    'NZ',
+    'NI',
+    'NE',
+    'NG',
+    'NU',
+    'NF',
+    'MK',
+    'MP',
+    'NO',
+    'OM',
+    'PK',
+    'PW',
+    'PS',
+    'PA',
+    'PG',
+    'PY',
+    'PE',
+    'PH',
+    'PN',
+    'PL',
+    'PT',
+    'PR',
+    'QA',
+    'RO',
+    'RU',
+    'RW',
+    'RE',
+    'BL',
+    'SH',
+    'KN',
+    'LC',
+    'MF',
+    'PM',
+    'VC',
+    'WS',
+    'SM',
+    'ST',
+    'SA',
+    'SN',
+    'RS',
+    'SC',
+    'SL',
+    'SG',
+    'SX',
+    'SK',
+    'SI',
+    'SB',
+    'SO',
+    'ZA',
+    'GS',
+    'SS',
+    'ES',
+    'LK',
+    'SD',
+    'SR',
+    'SJ',
+    'SE',
+    'CH',
+    'SY',
+    'TW',
+    'TJ',
+    'TZ',
+    'TH',
+    'TL',
+    'TG',
+    'TK',
+    'TO',
+    'TT',
+    'TN',
+    'TR',
+    'TM',
+    'TC',
+    'TV',
+    'UG',
+    'UA',
+    'AE',
+    'GB',
+    'UM',
+    'US',
+    'UY',
+    'UZ',
+    'VU',
+    'VE',
+    'VN',
+    'VG',
+    'VI',
+    'WF',
+    'EH',
+    'YE',
+    'ZM',
+    'ZW',
+    'AX',
+];

package/dist/plugin/index.d.ts

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/plugin/index.js

@@ -0,0 +1 @@
+export { vendureDashboardPlugin } from './vite-plugin-vendure-dashboard.js';

package/dist/plugin/schema-generator.d.ts

@@ -0,0 +1,5 @@
+import { VendureConfig } from '@vendure/core';
+import { GraphQLSchema } from 'graphql';
+export declare function generateSchema({ vendureConfig, }: {
+    vendureConfig: VendureConfig;
+}): Promise<GraphQLSchema>;

package/dist/plugin/schema-generator.js

@@ -0,0 +1,24 @@
+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;
+export async function generateSchema({ vendureConfig, }) {
+    if (!schemaPromise) {
+        schemaPromise = new Promise(async (resolve, reject) => {
+            resetConfig();
+            await setConfig(vendureConfig !== null && vendureConfig !== void 0 ? vendureConfig : {});
+            const runtimeConfig = await runPluginConfigurations(getConfig());
+            const typesLoader = new GraphQLTypesLoader();
+            const finalSchema = await getFinalVendureSchema({
+                config: runtimeConfig,
+                typePaths: VENDURE_ADMIN_API_TYPE_PATHS,
+                typesLoader,
+                apiType: 'admin',
+                output: 'sdl',
+            });
+            const safeSchema = buildSchema(finalSchema);
+            resolve(safeSchema);
+        });
+    }
+    return schemaPromise;
+}

package/dist/plugin/ui-config.d.ts

@@ -0,0 +1,3 @@
+import { AdminUiConfig } from '@vendure/common/lib/shared-types';
+import { VendureConfig } from '@vendure/core';
+export declare function getAdminUiConfig(config: VendureConfig, adminUiConfig?: Partial<AdminUiConfig>): AdminUiConfig;

package/dist/plugin/ui-config.js

@@ -0,0 +1,35 @@
+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';
+export function getAdminUiConfig(config, adminUiConfig) {
+    const { authOptions, apiOptions } = config;
+    const propOrDefault = (prop, defaultVal, isArray = false) => {
+        var _a;
+        if (isArray) {
+            const isValidArray = !!adminUiConfig
+                ? !!((_a = adminUiConfig[prop]) === null || _a === void 0 ? void 0 : _a.length)
+                : false;
+            return !!adminUiConfig && isValidArray ? adminUiConfig[prop] : defaultVal;
+        }
+        else {
+            return adminUiConfig ? adminUiConfig[prop] || defaultVal : defaultVal;
+        }
+    };
+    return {
+        adminApiPath: propOrDefault('adminApiPath', apiOptions.adminApiPath || ADMIN_API_PATH),
+        apiHost: propOrDefault('apiHost', 'auto'),
+        apiPort: propOrDefault('apiPort', 'auto'),
+        tokenMethod: propOrDefault('tokenMethod', authOptions.tokenMethod === 'bearer' ? 'bearer' : 'cookie'),
+        authTokenHeaderKey: propOrDefault('authTokenHeaderKey', authOptions.authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY),
+        channelTokenKey: propOrDefault('channelTokenKey', apiOptions.channelTokenKey || DEFAULT_CHANNEL_TOKEN_KEY),
+        defaultLanguage: propOrDefault('defaultLanguage', defaultLanguage),
+        defaultLocale: propOrDefault('defaultLocale', defaultLocale),
+        availableLanguages: propOrDefault('availableLanguages', defaultAvailableLanguages, true),
+        availableLocales: propOrDefault('availableLocales', defaultAvailableLocales, true),
+        brand: adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.brand,
+        hideVendureBranding: propOrDefault('hideVendureBranding', (adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.hideVendureBranding) || false),
+        hideVersion: propOrDefault('hideVersion', (adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.hideVersion) || false),
+        loginImageUrl: adminUiConfig === null || adminUiConfig === void 0 ? void 0 : adminUiConfig.loginImageUrl,
+        cancellationReasons: propOrDefault('cancellationReasons', undefined),
+    };
+}

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

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+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[];
+    };
+}
+export declare function adminApiSchemaPlugin(): Plugin;

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

@@ -0,0 +1,82 @@
+import { GraphQLList, GraphQLNonNull, GraphQLObjectType, isEnumType, isInputObjectType, isObjectType, isScalarType, } from 'graphql';
+import { generateSchema } from './schema-generator.js';
+import { getConfigLoaderApi } from './vite-plugin-config-loader.js';
+const virtualModuleId = 'virtual:admin-api-schema';
+const resolvedVirtualModuleId = `\0${virtualModuleId}`;
+export function adminApiSchemaPlugin() {
+    let configLoaderApi;
+    let 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) {
+    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];
+}
+function generateSchemaInfo(schema) {
+    const types = schema.getTypeMap();
+    const result = { 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/dist/plugin/vite-plugin-config-loader.d.ts

@@ -0,0 +1,17 @@
+import { VendureConfig } from '@vendure/core';
+import { Plugin } from 'vite';
+import { ConfigLoaderOptions } from './config-loader.js';
+export interface ConfigLoaderApi {
+    getVendureConfig(): Promise<VendureConfig>;
+}
+export declare 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 declare function configLoaderPlugin(options: ConfigLoaderOptions): Plugin;
+/**
+ * Inter-plugin dependencies implemented following the pattern given here:
+ * https://rollupjs.org/plugin-development/#direct-plugin-communication
+ */
+export declare function getConfigLoaderApi(plugins: readonly Plugin[]): ConfigLoaderApi;

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

@@ -0,0 +1,56 @@
+import { loadVendureConfig } from './config-loader.js';
+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) {
+    let vendureConfig;
+    const onConfigLoaded = [];
+    return {
+        name: configLoaderName,
+        async buildStart() {
+            this.info(`Loading Vendure config...`);
+            try {
+                const result = await loadVendureConfig({
+                    tempDir: options.tempDir,
+                    vendureConfigPath: options.vendureConfigPath,
+                    vendureConfigExport: options.vendureConfigExport,
+                });
+                vendureConfig = result.vendureConfig;
+                this.info(`Vendure config loaded (using export "${result.exportedSymbolName}")`);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    this.error(`Error loading Vendure config: ${e.message}`);
+                }
+            }
+            onConfigLoaded.forEach(fn => fn());
+        },
+        api: {
+            getVendureConfig() {
+                if (vendureConfig) {
+                    return Promise.resolve(vendureConfig);
+                }
+                else {
+                    return new Promise(resolve => {
+                        onConfigLoaded.push(() => {
+                            resolve(vendureConfig);
+                        });
+                    });
+                }
+            },
+        },
+    };
+}
+/**
+ * Inter-plugin dependencies implemented following the pattern given here:
+ * https://rollupjs.org/plugin-development/#direct-plugin-communication
+ */
+export function getConfigLoaderApi(plugins) {
+    const parentPlugin = plugins.find(plugin => plugin.name === configLoaderName);
+    if (!parentPlugin) {
+        throw new Error(`This plugin depends on the "${configLoaderName}" plugin.`);
+    }
+    return parentPlugin.api;
+}

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

@@ -0,0 +1,4 @@
+import { Plugin } from 'vite';
+export declare function viteConfigPlugin({ packageRoot }: {
+    packageRoot: string;
+}): Plugin;