@lwrjs/config 0.8.0-alpha.3

package/build/es/env-config.js

@@ -0,0 +1,352 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { ASSETS_CACHE_DIR, readFile, normalizeDirectory, normalizeResourcePath, DEFAULT_LWR_BOOTSTRAP_CONFIG, DEFAULT_LWR_LOCKER_CONFIG, DEFAULT_LOCKER_TRUSTED_CMP, normalizeInterchangeableModuleConfig, getFeatureFlags, } from '@lwrjs/shared-utils';
+import { rootPath, version } from '@lwrjs/config/package';
+import { validateLwrAppConfig } from './validation/app-config.js';
+import { LwrConfigValidationError } from '@lwrjs/diagnostics';
+const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+const MODE = process.env.MODE || 'dev';
+const DEFAULT_BASE_PATH = '';
+const DEFAULT_API_VERSION = '1';
+const LWR_VERSION = version;
+const DEFAULT_SERVER_TYPE = 'express';
+const DEFAULT_LWR_CONFIG_JSON = '$rootDir/lwr.config.json';
+const DEFAULT_GENERATOR_CONFIG = {
+    outputDir: '__generated_site__',
+    locales: ['en-US'],
+    _additionalRoutePaths: [],
+};
+// Directories
+const DEFAULT_ROOT_DIR = process.cwd();
+const DEFAULT_CACHE_FOLDER = '$rootDir/__lwr_cache__';
+const DEFAULT_ASSETS_DIR = '$rootDir/src/assets';
+const DEFAULT_CONTENT_DIR = '$rootDir/src/content';
+const DEFAULT_LAYOUTS_DIR = '$rootDir/src/layouts';
+const DEFAULT_DATA_DIR = '$rootDir/src/data';
+// Providers
+const DEFAULT_MODULE_PROVIDERS = [
+    '@lwrjs/app-service/moduleProvider',
+    '@lwrjs/lwc-ssr/moduleProvider',
+    '@lwrjs/router/module-provider',
+    '@lwrjs/lwc-module-provider',
+    '@lwrjs/npm-module-provider',
+];
+const DEFAULT_RESOURCE_PROVIDERS = ['@lwrjs/loader'];
+const DEFAULT_VIEW_PROVIDERS = [
+    '@lwrjs/nunjucks-view-provider',
+    '@lwrjs/html-view-provider',
+    '@lwrjs/markdown-view-provider',
+    '@lwrjs/base-view-provider',
+];
+const DEFAULT_VIEW_TRANFORM_PLUGINS = ['@lwrjs/base-view-transformer', '@lwrjs/lwc-ssr/viewTransformer'];
+const DEFAULT_ASSET_PROVIDERS = ['@lwrjs/fs-asset-provider'];
+const DEFAULT_ASSET_TRANFORM_PLUGINS = ['@lwrjs/asset-transformer'];
+// Packages/modules
+const DEFAULT_TEMPLATE_ENGINE = '@lwrjs/base-template-engine';
+const DEFAULT_AMD_LOADER = 'lwr/loader';
+const DEFAULT_AMD_LOADER_LEGACY = 'lwr/loaderLegacy';
+const DEFAULT_ESM_LOADER = 'lwr/esmLoader';
+const DEFAULT_SERVICE_PACKAGE_NAME = /lwr-(\w+)-service/;
+const DEFAULT_LWR_MODULES = [
+    { npm: getLWCEngineSpecifier() },
+    { npm: '@lwrjs/client-modules' },
+    { npm: '@lwrjs/loader' },
+    { npm: '@lwrjs/o11y' },
+    { npm: '@lwrjs/router' },
+    { npm: '@lwc/synthetic-shadow' },
+];
+const DEFAULT_BUNDLE_EXCLUSIONS = [
+    'lwc',
+    '@lwc/synthetic-shadow',
+    'lwr/navigation',
+    'lwr/esmLoader',
+    'lwr/profiler',
+];
+// Default config objects
+const DEFAULT_LWR_CONFIG = {
+    port: PORT,
+    ignoreLwrConfigFile: false,
+    lwrConfigFile: DEFAULT_LWR_CONFIG_JSON,
+    basePath: DEFAULT_BASE_PATH,
+    rootDir: DEFAULT_ROOT_DIR,
+    cacheDir: DEFAULT_CACHE_FOLDER,
+    serverMode: MODE,
+    apiVersion: DEFAULT_API_VERSION,
+    assets: DEFAULT_ASSETS_DIR,
+    assetProviders: DEFAULT_ASSET_PROVIDERS,
+    assetTransformers: DEFAULT_ASSET_TRANFORM_PLUGINS,
+    contentDir: DEFAULT_CONTENT_DIR,
+    layoutsDir: DEFAULT_LAYOUTS_DIR,
+    staticSiteGenerator: DEFAULT_GENERATOR_CONFIG,
+    globalDataDir: DEFAULT_DATA_DIR,
+    globalData: {},
+    hooks: [],
+    moduleProviders: DEFAULT_MODULE_PROVIDERS,
+    resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
+    viewProviders: DEFAULT_VIEW_PROVIDERS,
+    viewTransformers: DEFAULT_VIEW_TRANFORM_PLUGINS,
+    templateEngine: DEFAULT_TEMPLATE_ENGINE,
+    environment: {},
+    lwc: { modules: [] },
+    routes: [],
+    errorRoutes: [],
+    bundleConfig: { exclude: DEFAULT_BUNDLE_EXCLUSIONS },
+    serverType: DEFAULT_SERVER_TYPE,
+    locker: DEFAULT_LWR_LOCKER_CONFIG,
+};
+function createCacheFolder(cache, rootDir) {
+    const cacheDir = normalizeDirectory(cache, rootDir);
+    const absPath = path.resolve(cacheDir);
+    fs.mkdirSync(path.join(absPath, ASSETS_CACHE_DIR), { recursive: true });
+    return absPath;
+}
+function getLwrConfigFromFile(rootDir, customDir = DEFAULT_LWR_CONFIG_JSON) {
+    const lwrConfigPath = path.resolve(normalizeDirectory(customDir, rootDir));
+    if (fs.existsSync(lwrConfigPath)) {
+        const configAsString = readFile(lwrConfigPath);
+        try {
+            return validateLwrAppConfig(configAsString, 'file');
+        }
+        catch (e) {
+            if (e instanceof LwrConfigValidationError) {
+                // TODO: temporary workaround for https://github.com/salesforce/lwr/issues/825
+                if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === 'true') {
+                    console.warn('ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution');
+                    console.dir(e, { depth: null });
+                    return JSON.parse(configAsString);
+                }
+                else {
+                    throw e;
+                }
+            }
+            return undefined;
+        }
+    }
+    else {
+        console.log(`[Warning] LWR Config not found on "${lwrConfigPath}"`);
+        return undefined;
+    }
+}
+export function explodeMode(mode) {
+    const modeConfigFile = path.join(rootPath, `./runtime-configs/${mode}.json`);
+    if (!fs.existsSync(modeConfigFile)) {
+        throw new Error(`No configuration found for server mode - ${mode}`);
+    }
+    const modeConfig = JSON.parse(readFile(modeConfigFile));
+    return modeConfig;
+}
+function normalizeServices(services, rootDir) {
+    return services.map((service) => {
+        const [serviceName, serviceConfig = undefined] = Array.isArray(service) ? service : [service];
+        let rawServiceName = normalizeDirectory(serviceName, rootDir);
+        // We consider it an npm module if it starts with @ or if is of the form lwr-[servicename]-service
+        // Otherwise resolve it as a relative path
+        if (!rawServiceName.startsWith('@') && !DEFAULT_SERVICE_PACKAGE_NAME.test(rawServiceName)) {
+            rawServiceName = path.resolve(rawServiceName);
+        }
+        return [rawServiceName, serviceConfig];
+    });
+}
+function normalizeModules(modules, rootDir) {
+    return modules.map((m) => {
+        const dirRecord = m;
+        if (dirRecord.dir) {
+            dirRecord.dir = path.resolve(normalizeDirectory(dirRecord.dir, rootDir));
+        }
+        const aliasRecord = m;
+        if (aliasRecord.path) {
+            aliasRecord.path = path.resolve(normalizeDirectory(aliasRecord.path, rootDir));
+        }
+        return m;
+    });
+}
+function normalizeRoutes(routes, resourcePaths) {
+    return routes.map((route) => {
+        const { routeHandler, contentTemplate, layoutTemplate } = route;
+        const bootstrap = {
+            ...DEFAULT_LWR_BOOTSTRAP_CONFIG,
+            ...route.bootstrap,
+        };
+        return {
+            ...route,
+            bootstrap,
+            // default routes to be idempotent
+            routeHandler: routeHandler && path.resolve(normalizeDirectory(routeHandler, resourcePaths.rootDir)),
+            contentTemplate: contentTemplate && path.resolve(normalizeResourcePath(contentTemplate, resourcePaths)),
+            layoutTemplate: layoutTemplate && path.resolve(normalizeResourcePath(layoutTemplate, resourcePaths)),
+        };
+    });
+}
+function normalizeAssetsDir(assets, rootDir) {
+    if (typeof assets === 'string') {
+        return [
+            {
+                alias: 'assetsDir',
+                dir: normalizeDirectory(assets, rootDir),
+                urlPath: '/public/assets',
+            },
+        ];
+    }
+    else {
+        return assets.map((asset) => {
+            const assetDir = asset.dir;
+            const assetFile = asset.file;
+            return {
+                ...asset,
+                dir: assetDir && normalizeDirectory(assetDir, rootDir),
+                file: assetFile && normalizeDirectory(assetFile, rootDir),
+            };
+        });
+    }
+}
+// deep merge LWC configs
+function mergeLWCConfigs(config1, config2) {
+    const modules1 = config1?.lwc?.modules || [];
+    const modules2 = config2?.lwc?.modules || [];
+    const interchangeable1 = config1?.lwc?.interchangeable || [];
+    const interchangeable2 = config2?.lwc?.interchangeable || [];
+    const mergedInterchangeable = [...interchangeable1, ...interchangeable2];
+    const interchangeableModules1 = config1?.lwc?.interchangeableModules || [];
+    const interchangeableModules2 = config2?.lwc?.interchangeableModules || [];
+    const mergedInterchangeableModules = [...interchangeableModules1, ...interchangeableModules2];
+    return {
+        modules: [...modules1, ...modules2],
+        interchangeable: mergedInterchangeable.length ? mergedInterchangeable : undefined,
+        interchangeableModules: mergedInterchangeableModules.length
+            ? mergedInterchangeableModules
+            : undefined,
+    };
+}
+// merge default bundle exclusions with any bundle exclusions specified in config
+function mergeBundleConfig(jsonConfig, config) {
+    const defaultExclusions = config?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+        jsonConfig?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+        DEFAULT_BUNDLE_EXCLUSIONS;
+    const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+    return {
+        ...jsonConfig?.bundleConfig,
+        ...config?.bundleConfig,
+        exclude: [...new Set([...defaultExclusions, ...configExclusions])],
+    };
+}
+// merge default locker trusted namespaces/cmps with any trusted namespaces/cmps specified in config
+function mergeLockerConfig(jsonConfig, config) {
+    const defaultNamespaces = DEFAULT_LOCKER_TRUSTED_CMP;
+    const configNamespaces = config?.locker?.trustedComponents || jsonConfig?.locker?.trustedComponents || [];
+    return {
+        ...DEFAULT_LWR_LOCKER_CONFIG,
+        ...jsonConfig?.locker,
+        ...config?.locker,
+        trustedComponents: [...new Set([...defaultNamespaces, ...configNamespaces])],
+    };
+}
+// Ensure correct engine since LWC 2+ changed engine packaging, see https://github.com/salesforce/lwr/issues/791
+function getLWCEngineSpecifier() {
+    const require = createRequire(path.join(process.cwd(), './env-config.js'));
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { version } = require('lwc/package.json');
+    if (version && version.startsWith('1')) {
+        return '@lwc/engine';
+    }
+    // default to engine for LWC version 2+
+    return '@lwc/engine-dom';
+}
+function normalizeLwcConfig(config) {
+    return {
+        ...config,
+        interchangeableModulesMap: config.interchangeableModules
+            ? normalizeInterchangeableModuleConfig(config.interchangeableModules)
+            : undefined,
+    };
+}
+function trimLwrConfig(config) {
+    Object.keys(config).forEach((k) => {
+        if (config[k] === undefined)
+            delete config[k];
+    });
+    return config;
+}
+/**
+ * Merge and normalize all LWR configurations.
+ *
+ * @remarks
+ * Configurations are merged in the following order:
+ *  defaults -> optional config file (lwr.config.json) -> optional config arg
+ *
+ * @param config - optional config supplied separate from the config file
+ * @returns the merged and normalized LWR configuration
+ */
+export function normalizeConfig(config) {
+    if (config !== undefined) {
+        config = trimLwrConfig(config);
+        try {
+            validateLwrAppConfig(JSON.stringify(config), 'pre');
+        }
+        catch (e) {
+            // TODO: temporary workaround for https://github.com/salesforce/lwr/issues/825
+            if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === 'true') {
+                console.warn('ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution');
+                console.dir(e, { depth: null });
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    // Merge all configurations together, and return
+    const rootDir = path.resolve(config?.rootDir || DEFAULT_ROOT_DIR);
+    const lwrJsonConfig = config?.ignoreLwrConfigFile === true
+        ? undefined
+        : getLwrConfigFromFile(rootDir, config?.lwrConfigFile);
+    const mergedLwrGlobalConfig = {
+        ...DEFAULT_LWR_CONFIG,
+        ...lwrJsonConfig,
+        ...config,
+        lwc: normalizeLwcConfig(mergeLWCConfigs(lwrJsonConfig, config)),
+        bundleConfig: mergeBundleConfig(lwrJsonConfig, config),
+        locker: mergeLockerConfig(lwrJsonConfig, config),
+        staticSiteGenerator: {
+            ...DEFAULT_GENERATOR_CONFIG,
+            ...lwrJsonConfig?.staticSiteGenerator,
+            ...config?.staticSiteGenerator,
+        },
+        rootDir,
+    };
+    // Normalize entries (eg: parse full file paths, etc)
+    const assets = normalizeAssetsDir(mergedLwrGlobalConfig.assets, rootDir);
+    const contentDir = normalizeDirectory(mergedLwrGlobalConfig.contentDir, rootDir);
+    const layoutsDir = normalizeDirectory(mergedLwrGlobalConfig.layoutsDir, rootDir);
+    const amdLoader = getFeatureFlags().LEGACY_LOADER ? DEFAULT_AMD_LOADER_LEGACY : DEFAULT_AMD_LOADER;
+    return {
+        ...mergedLwrGlobalConfig,
+        assets,
+        contentDir,
+        layoutsDir,
+        globalDataDir: normalizeDirectory(mergedLwrGlobalConfig.globalDataDir, rootDir),
+        hooks: normalizeServices(mergedLwrGlobalConfig.hooks, rootDir),
+        cacheDir: createCacheFolder(mergedLwrGlobalConfig.cacheDir, rootDir),
+        lwc: {
+            modules: normalizeModules([...DEFAULT_LWR_MODULES, ...mergedLwrGlobalConfig.lwc.modules], rootDir),
+            interchangeable: mergedLwrGlobalConfig.lwc.interchangeable,
+            interchangeableModulesMap: mergedLwrGlobalConfig.lwc.interchangeableModulesMap,
+        },
+        moduleProviders: normalizeServices(mergedLwrGlobalConfig.moduleProviders, rootDir),
+        assetProviders: normalizeServices(mergedLwrGlobalConfig.assetProviders, rootDir),
+        assetTransformers: normalizeServices(mergedLwrGlobalConfig.assetTransformers, rootDir),
+        resourceProviders: normalizeServices(mergedLwrGlobalConfig.resourceProviders, rootDir),
+        viewProviders: normalizeServices(mergedLwrGlobalConfig.viewProviders, rootDir),
+        viewTransformers: normalizeServices(mergedLwrGlobalConfig.viewTransformers, rootDir),
+        routes: normalizeRoutes(mergedLwrGlobalConfig.routes, { rootDir, assets, contentDir, layoutsDir }),
+        errorRoutes: normalizeRoutes(mergedLwrGlobalConfig.errorRoutes, {
+            rootDir,
+            assets,
+            contentDir,
+            layoutsDir,
+        }),
+        amdLoader,
+        esmLoader: DEFAULT_ESM_LOADER,
+        lwrVersion: LWR_VERSION,
+    };
+}
+//# sourceMappingURL=env-config.js.map

package/build/es/index.d.ts

@@ -0,0 +1,4 @@
+import { normalizeConfig, explodeMode } from './env-config.js';
+import { validateLwrAppConfig } from './validation/app-config.js';
+export { normalizeConfig, explodeMode, validateLwrAppConfig };
+//# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -0,0 +1,5 @@
+import { normalizeConfig, explodeMode } from './env-config.js';
+import { validateLwrAppConfig } from './validation/app-config.js';
+// Only export the functions we utilize internally
+export { normalizeConfig, explodeMode, validateLwrAppConfig };
+//# sourceMappingURL=index.js.map

package/build/es/validation/app-config-context.d.ts

@@ -0,0 +1,55 @@
+import { AssetDirConfig, AssetFileConfig, LwrErrorRoute, LwrRoute, NormalizedLwrGlobalConfig, NormalizedLwrAppBootstrapConfig, LwrLockerConfig } from '@lwrjs/types';
+import { Node } from 'jsonc-parser';
+import { Diagnostic } from '@lwrjs/diagnostics';
+declare type RequiredAssetDirConfig = Required<AssetDirConfig>;
+declare type RequiredAssetFileConfig = Required<AssetFileConfig>;
+declare type RequiredLwrRoute = Required<LwrRoute>;
+declare type RequiredLwrErrorRoute = Required<LwrErrorRoute>;
+declare type RequiredLwrLockerConfig = Required<LwrLockerConfig>;
+interface ConfigMap {
+    root: NormalizedLwrGlobalConfig;
+    assetDir: RequiredAssetDirConfig;
+    assetFile: RequiredAssetFileConfig;
+    routes: RequiredLwrRoute;
+    errorRoutes: RequiredLwrErrorRoute;
+    bootstrap: NormalizedLwrAppBootstrapConfig;
+    locker: RequiredLwrLockerConfig;
+}
+export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routes", "serverMode", "serverType", "templateEngine", "viewProviders", "viewTransformers"];
+export declare const ASSET_DIR_ATTRIBUTE_KEYS: ["alias", "dir", "urlPath"];
+export declare const ASSET_FILE_ATTRIBUTE_KEYS: ["alias", "file", "urlPath"];
+export declare const LOCKER_ATTRIBUTE_KEYS: ["enabled", "trustedComponents", "clientOnly"];
+export declare const ROUTE_ATTRIBUTE_KEYS: ["bootstrap", "contentTemplate", "id", "cache", "layoutTemplate", "method", "path", "rootComponent", "routeHandler", "properties"];
+export declare const ERROR_ROUTE_ATTRIBUTE_KEYS: ["bootstrap", "contentTemplate", "id", "layoutTemplate", "rootComponent", "routeHandler", "status", "properties", "cache"];
+export declare const BOOTSTRAP_ATTRIBUTE_KEYS: ["autoBoot", "syntheticShadow", "workers", "services", "configAsSrc", "experimentalSSR"];
+export declare const BASE_PATH_REGEX: RegExp;
+export declare class ValidationContext {
+    diagnostics: Diagnostic[];
+    sourceText: string;
+    constructor(sourceText: string);
+    private getLocationFromNode;
+    assertIsObject<T extends keyof ConfigMap>(node: Node, property: T): void;
+    assertIsBoolean(node: Node | undefined, property: string): void;
+    assertIsArray(node: Node | undefined, property: string): void;
+    assertIsSpecifier(node: Node | undefined, property: string): void;
+    assertIsPath(node: Node | undefined, property: string): void;
+    assertIsPort(node: Node | undefined, property: string): void;
+    assertIsServerType(node: Node | undefined, property: string): void;
+    assertIsStaticSiteGenerator(node: Node | undefined, property: string): void;
+    assertIsMethod(node: Node | undefined, property: string): void;
+    assertIsStatus(node: Node | undefined, property: string): void;
+    assertIsEnvironment(node: Node | undefined, property: string): void;
+    assertIsBasePath(node: Node | undefined, property: string): void;
+    assertNotEmptyString(node: Node | undefined, property: string): void;
+    assertNotEmptyArray(node: Node | undefined, property: string): void;
+    assertHasOneOrMore(node: Node, property: string, childProps: string[]): void;
+    assertHasOnlyOne(node: Node, property: string, childProps: string[]): void;
+    assertArrayOfStrings(node: Node | undefined, property: string): void;
+    assertArrayOfSpecifiers(node: Node | undefined, property: string): void;
+    assertArrayOfServices(node: Node | undefined, property: string): void;
+    assertUniqueIds(nodes: Node[], property: string): void;
+    assertRequiredKeys(node: Node, property: string, requiredPropertyKeys: string[]): void;
+    assertValidKeys<T extends keyof ConfigMap>(node: Node, property: T, validPropertyKeys: (keyof ConfigMap[T])[]): void;
+}
+export {};
+//# sourceMappingURL=app-config-context.d.ts.map