@adobe-commerce/elsie 1.2.2-alpha1 → 1.3.0-alpha01

package/config/vite.mjs

@@ -25,18 +25,11 @@ import banner from 'vite-plugin-banner';
 const env = loadEnv('', process.cwd());
 
 // Load Elsie Config
-const elsieConfig = await import(
-  path.resolve(process.cwd(), './.elsie.js')
-).then((m) => m.default);
-
-const packageJSON = await import(
-  path.resolve(process.cwd(), './package.json'),
-  {
-    assert: {
-      type: 'json',
-    },
-  }
-).then((m) => m.default);
+const elsieConfig = await import(path.resolve(process.cwd(), './.elsie.js')).then((m) => m.default);
+
+// Read package.json using createRequire (compatible with Node 20 and 22)
+const require = createRequire(import.meta.url);
+const packageJSON = require(path.resolve(process.cwd(), './package.json'));
 
 // Paths
 const paths = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe-commerce/elsie",
-  "version": "1.2.2-alpha1",
+  "version": "1.3.0-alpha01",
   "license": "SEE LICENSE IN LICENSE.md",
   "description": "Domain Package SDK",
   "engines": {

package/src/lib/aem/configs.ts

@@ -0,0 +1,237 @@
+import { deepmerge } from '../deepmerge';
+
+interface ConfigHeaders {
+  all?: Record<string, string>;
+  [key: string]: Record<string, string> | undefined;
+}
+
+interface ConfigPublic {
+  default: ConfigRoot;
+  [key: string]: ConfigRoot;
+}
+
+interface ConfigRoot {
+  headers?: ConfigHeaders;
+  [key: string]: any;
+}
+
+interface Config {
+  public: ConfigPublic;
+  [key: string]: any;
+}
+
+// Private state
+let config: Config | null = null;
+let rootPath: string | null = null;
+let rootConfig: ConfigRoot | null = null;
+
+/**
+ * Reset the config state
+ */
+function resetConfig() {
+  config = null;
+  rootPath = null;
+  rootConfig = null;
+}
+
+/**
+ * Builds the URL for the config file.
+ *
+ * @returns {URL} - The URL for the config file.
+ */
+function buildConfigURL() {
+  return new URL(`${window.location.origin}/config.json`);
+}
+
+/**
+ * Retrieves a value from a config object using dot notation.
+ *
+ * @param {Object} obj - The config object.
+ * @param {string} key - The key to retrieve (supports dot notation).
+ * @returns {any} - The value of the key.
+ */
+function getValue(obj: Record<string, any>, key: string): any {
+  return key.split('.').reduce((current: Record<string, any>, part: string) => {
+    if (!Object.prototype.hasOwnProperty.call(current, part)) {
+      console.warn(`Property ${key} does not exist in the object`);
+      return undefined;
+    }
+    return current[part];
+  }, obj);
+}
+
+/**
+ * Get cookie
+ * @param {string} cookieName - The name of the cookie to get
+ * @returns {string} - The value of the cookie
+ */
+function getCookie(cookieName: string): string | undefined {
+  const cookies = document.cookie.split(';');
+  let foundValue;
+
+  cookies.forEach((cookie) => {
+    const [name, value] = cookie.trim().split('=');
+    if (name === cookieName) {
+      foundValue = decodeURIComponent(value);
+    }
+  });
+
+  return foundValue;
+}
+
+/**
+ * Get root path
+ * @param {Object} [configObj=config] - The config object.
+ * @returns {string} - The root path.
+ */
+function getRootPath(configObj: Config | null = config): string {
+  if (!configObj) {
+    console.warn('No config found. Please call initializeConfig() first.');
+    return '/';
+  }
+
+  const value = Object.keys(configObj?.public)
+    // Sort by number of non-empty segments to find the deepest path
+    .sort((a, b) => {
+      const aSegments = a.split('/').filter(Boolean).length;
+      const bSegments = b.split('/').filter(Boolean).length;
+      return bSegments - aSegments;
+    })
+    .find(
+      (key) =>
+        window.location.pathname === key ||
+        window.location.pathname.startsWith(key)
+    );
+
+  return value ?? '/';
+}
+
+/**
+ * Get list of root paths from public config
+ * @returns {Array} - The list of root paths.
+ */
+function getListOfRootPaths(): string[] {
+  if (!config) {
+    console.warn('No config found. Please call initializeConfig() first.');
+    return [];
+  }
+
+  return Object.keys(config.public).filter((root) => root !== 'default');
+}
+
+/**
+ * Checks if the public config contains more than "default"
+ * @returns {boolean} - true if public config contains more than "default"
+ */
+function isMultistore(): boolean {
+  return getListOfRootPaths().length >= 1;
+}
+
+/**
+ * Retrieves headers from config entries like commerce.headers.pdp.my-header, etc and
+ * returns as object of all headers like { my-header: value, ... }
+ * @param {string} scope - The scope of the headers to retrieve.
+ * @returns {Object} - The headers.
+ */
+function getHeaders(scope: string): Record<string, string> {
+  if (!rootConfig) {
+    throw new Error(
+      'Configuration not initialized. Call initializeConfig() first.'
+    );
+  }
+  const headers = rootConfig.headers ?? {};
+  return {
+    ...(headers.all ?? {}),
+    ...(headers[scope] ?? {}),
+  };
+}
+
+/**
+ * Applies config overrides from metadata.
+ *
+ * @param {Object} [configObj=config] - The base config.
+ * @param {string} [root=rootPath] - The root path.
+ * @returns {Object} - The config with overrides applied.
+ */
+function applyConfigOverrides(
+  configObj: Config | null,
+  root: string | null
+): ConfigRoot {
+  const defaultConfig = configObj!.public?.default;
+
+  if (root === '/' || !configObj!.public[root as keyof ConfigPublic])
+    return defaultConfig;
+
+  return deepmerge(
+    defaultConfig,
+    configObj!.public[root as keyof ConfigPublic]
+  );
+}
+
+/**
+ * Fetches config from remote and saves in session, then returns it, otherwise
+ * returns if it already exists.
+ *
+ * @returns {Promise<Object>} - The config JSON from session storage
+ */
+async function getConfigFromSession(): Promise<Config> {
+  try {
+    const configJSON = window.sessionStorage.getItem('config');
+    if (!configJSON) {
+      throw new Error('No config in session storage');
+    }
+
+    const parsedConfig = JSON.parse(configJSON);
+    if (
+      !parsedConfig[':expiry'] ||
+      parsedConfig[':expiry'] < Math.round(Date.now() / 1000)
+    ) {
+      throw new Error('Config expired');
+    }
+    return parsedConfig;
+  } catch (e) {
+    const config = await fetch(buildConfigURL());
+    if (!config.ok) throw new Error('Failed to fetch config');
+    const configJSON = await config.json();
+    configJSON[':expiry'] = Math.round(Date.now() / 1000) + 7200;
+    window.sessionStorage.setItem('config', JSON.stringify(configJSON));
+    return configJSON;
+  }
+}
+
+/**
+ * Initializes the configuration system.
+ * @returns {Promise<void>}
+ */
+async function initializeConfig(): Promise<ConfigRoot> {
+  config = await getConfigFromSession();
+  rootPath = getRootPath(config);
+  rootConfig = applyConfigOverrides(config, rootPath);
+  return rootConfig;
+}
+
+/**
+ * Retrieves a configuration value.
+ *
+ * @param {string} configParam - The configuration parameter to retrieve.
+ * @returns {string|undefined} - The value of the configuration parameter, or undefined.
+ */
+function getConfigValue(configParam: string): any {
+  if (!rootConfig) {
+    throw new Error(
+      'Configuration not initialized. Call initializeConfig() first.'
+    );
+  }
+  return getValue(rootConfig, configParam);
+}
+
+export {
+  initializeConfig,
+  getCookie,
+  getRootPath,
+  getListOfRootPaths,
+  isMultistore,
+  getConfigValue,
+  getHeaders,
+  resetConfig,
+};