@vendure/dashboard 3.2.0 → 3.2.1

package/dist/plugin/config-loader.js

@@ -1,141 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,277 +0,0 @@
-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

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

package/dist/plugin/index.js

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

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

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

package/dist/plugin/schema-generator.js

@@ -1,24 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

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