@dxos/config 0.7.5-main.b19bfc8 → 0.7.5-main.d9d2d4e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/config",
-  "version": "0.7.5-main.b19bfc8",
+  "version": "0.7.5-main.d9d2d4e",
   "description": "Config utilities",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,6 +8,31 @@
   "author": "DXOS.org",
   "sideEffects": true,
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": {
+        "require": "./dist/lib/node/index.cjs",
+        "default": "./dist/lib/node-esm/index.mjs"
+      }
+    },
+    "./esbuild-plugin": {
+      "types": "./dist/types/src/esbuild-plugin/index.d.ts",
+      "import": "./dist/plugin/node-esm/esbuild-plugin.mjs",
+      "require": "./dist/plugin/node/esbuild-plugin.cjs"
+    },
+    "./rollup-plugin": {
+      "types": "./dist/types/src/rollup-plugin/index.d.ts",
+      "import": "./dist/plugin/node-esm/rollup-plugin.mjs",
+      "require": "./dist/plugin/node/rollup-plugin.cjs"
+    },
+    "./vite-plugin": {
+      "types": "./dist/types/src/vite-plugin/index.d.ts",
+      "import": "./dist/plugin/node-esm/vite-plugin.mjs",
+      "require": "./dist/plugin/node/vite-plugin.cjs"
+    }
+  },
   "main": "dist/lib/node/index.cjs",
   "browser": {
     "./src/loaders/index.ts": "./src/loaders/browser.js",
@@ -16,16 +41,22 @@
     "./dist/lib/node/index.cjs": "./dist/lib/browser/index.mjs"
   },
   "types": "dist/types/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "esbuild-plugin": [
+        "dist/types/src/esbuild-plugin/index.d.ts"
+      ],
+      "rollup-plugin": [
+        "dist/types/src/rollup-plugin/index.d.ts"
+      ],
+      "vite-plugin": [
+        "dist/types/src/vite-plugin/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist",
-    "esbuild-plugin.js",
-    "esbuild-plugin.d.ts",
-    "rollup-plugin.js",
-    "rollup-plugin.d.ts",
-    "vite-plugin.js",
-    "vite-plugin.d.ts",
-    "webpack-plugin.js",
-    "webpack-plugin.d.ts"
+    "src"
   ],
   "dependencies": {
     "boolean": "^3.0.1",
@@ -34,11 +65,11 @@
     "lodash.defaultsdeep": "^4.6.1",
     "lodash.ismatch": "^4.4.0",
     "pkg-up": "^3.1.0",
-    "@dxos/log": "0.7.5-main.b19bfc8",
-    "@dxos/tracing": "0.7.5-main.b19bfc8",
-    "@dxos/protocols": "0.7.5-main.b19bfc8",
-    "@dxos/util": "0.7.5-main.b19bfc8",
-    "@dxos/node-std": "0.7.5-main.b19bfc8"
+    "@dxos/log": "0.7.5-main.d9d2d4e",
+    "@dxos/node-std": "0.7.5-main.d9d2d4e",
+    "@dxos/protocols": "0.7.5-main.d9d2d4e",
+    "@dxos/tracing": "0.7.5-main.d9d2d4e",
+    "@dxos/util": "0.7.5-main.d9d2d4e"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",

package/src/config.test.ts

@@ -0,0 +1,158 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { expect, test } from 'vitest';
+
+import { Config, mapFromKeyValues, mapToKeyValues } from './config';
+// @ts-ignore
+import defaults from './testing/defaults.js';
+// @ts-ignore
+import envmap from './testing/envs-map.js';
+
+test('Empty config', () => {
+  const config = new Config();
+
+  expect(config.values).toBeTruthy();
+  expect(config.get('runtime.props.title')).toBeUndefined();
+});
+
+test('Basic config', () => {
+  const config = new Config(
+    {
+      runtime: {
+        props: {
+          title: 'testing',
+        },
+      },
+    },
+    {
+      runtime: {
+        app: {
+          theme: 'light',
+        },
+      },
+    },
+  );
+
+  expect(config.values).toEqual({
+    version: 1,
+    runtime: {
+      app: {
+        theme: 'light',
+      },
+      props: {
+        title: 'testing',
+      },
+    },
+  });
+});
+
+test('Runtime and module config', () => {
+  const config = new Config(
+    {
+      package: {
+        modules: [
+          {
+            name: 'example:app/tasks',
+            record: {
+              web: {
+                entryPoint: 'main.js',
+              },
+            },
+          },
+        ],
+      },
+    },
+    {
+      runtime: {
+        services: {
+          signaling: [
+            {
+              server: 'ws://localhost:<random-port>',
+            },
+          ],
+        },
+      },
+    },
+  );
+
+  expect(config.values).toEqual({
+    version: 1,
+    package: {
+      modules: [
+        {
+          name: 'example:app/tasks',
+          record: {
+            web: {
+              entryPoint: 'main.js',
+            },
+          },
+        },
+      ],
+    },
+    runtime: {
+      services: {
+        signaling: [
+          {
+            server: 'ws://localhost:<random-port>',
+          },
+        ],
+      },
+    },
+  });
+});
+
+test.skip('Mapping', () => {
+  process.env.TEST_CLIENT_ID = '900';
+  process.env.TEST_SERVER_ENDPOINT = 'http://localhost';
+
+  const config = new Config(
+    {
+      runtime: {
+        client: {
+          tag: 'testing',
+        },
+      },
+    } as any,
+    mapFromKeyValues(envmap, process.env),
+  );
+
+  expect(config.values).toEqual({
+    runtime: {
+      client: {
+        id: 900,
+        tag: 'testing',
+      },
+      server: {
+        endpoint: 'http://localhost',
+      },
+    },
+  });
+
+  const values = mapToKeyValues(envmap, config.values);
+
+  expect(values).toEqual({
+    TEST_CLIENT_ID: 900,
+    TEST_CLIENT_TAG: 'testing',
+    TEST_SERVER_ENDPOINT: 'http://localhost',
+  });
+});
+
+test.skip('mapToKeyValuesping', () => {
+  const config = new Config(
+    {
+      client: {
+        tag: 'testing',
+      },
+    } as any,
+    defaults as any,
+  );
+
+  const values = mapToKeyValues(envmap, config.values);
+
+  expect(values).toEqual({
+    TEST_CLIENT_ID: 123,
+    TEST_CLIENT_TAG: 'testing',
+  });
+});

package/src/config.ts

@@ -0,0 +1,182 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { boolean } from 'boolean';
+import defaultsDeep from 'lodash.defaultsdeep';
+import isMatch from 'lodash.ismatch';
+
+import { InvalidConfigError } from '@dxos/protocols';
+import { schema } from '@dxos/protocols/proto';
+import { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+import { trace } from '@dxos/tracing';
+import { getDeep, setDeep } from '@dxos/util';
+
+import { type ConfigKey, type DeepIndex, type ParseKey } from './types';
+
+type MappingSpec = Record<string, { path: string; type?: string }>;
+const configRootType = schema.getCodecForType('dxos.config.Config');
+
+/**
+ * Maps the given objects onto a flattened set of (key x values).
+ *
+ * Expects parsed yaml content of the form:
+ *
+ * ```
+ * ENV_VAR:
+ *   path: config.selector.path
+ * ```
+ *
+ * @param {object} spec
+ * @param {object} values
+ * @return {object}
+ */
+export const mapFromKeyValues = (spec: MappingSpec, values: Record<string, any>) => {
+  const config = {};
+
+  for (const [key, { path, type }] of Object.entries(spec)) {
+    let value = values[key];
+
+    if (value !== undefined) {
+      if (type) {
+        switch (type) {
+          case 'boolean': {
+            value = boolean(value);
+            break;
+          }
+
+          case 'number': {
+            value = Number(value);
+            break;
+          }
+
+          case 'string': {
+            break;
+          }
+
+          case 'json': {
+            value = value ? JSON.parse(value) : null;
+            break;
+          }
+
+          default: {
+            throw new Error(`Invalid type: ${type}`);
+          }
+        }
+      }
+
+      setDeep(config, path.split('.'), value);
+    }
+  }
+
+  return config;
+};
+
+/**
+ * Maps the given flattend set of (key x values) onto a JSON object.
+ * @param {object} spec
+ * @param {object} values
+ */
+export const mapToKeyValues = (spec: MappingSpec, values: any) => {
+  const config: Record<string, any> = {};
+
+  for (const [key, { path, type }] of Object.entries(spec)) {
+    const value = getDeep(values, path.split('.'));
+    if (value !== undefined) {
+      switch (type) {
+        case 'json':
+          config[key] = JSON.stringify(value);
+          break;
+        default:
+          config[key] = value;
+      }
+    }
+  }
+
+  return config;
+};
+
+/**
+ * Validate config object.
+ */
+export const validateConfig = (config: ConfigProto): ConfigProto => {
+  if (!('version' in config)) {
+    throw new InvalidConfigError('Version not specified');
+  }
+
+  if (config?.version !== 1) {
+    throw new InvalidConfigError(`Invalid config version: ${config.version}`);
+  }
+
+  const error = configRootType.protoType.verify(config);
+  if (error) {
+    throw new InvalidConfigError(error);
+  }
+
+  return config;
+};
+
+export const ConfigResource = Symbol.for('dxos.resource.Config');
+
+/**
+ * Global configuration object.
+ * NOTE: Config objects are immutable.
+ */
+@trace.resource({ annotation: ConfigResource })
+export class Config {
+  private readonly _config: any;
+
+  /**
+   * Creates an immutable instance.
+   * @constructor
+   */
+  constructor(config: ConfigProto = {}, ...objects: ConfigProto[]) {
+    this._config = validateConfig(defaultsDeep(config, ...objects, { version: 1 }));
+  }
+
+  /**
+   * Returns an immutable config JSON object.
+   */
+  get values(): ConfigProto {
+    return this._config;
+  }
+
+  /**
+   * Returns the given config property.
+   *
+   * @param key A key in the config object. Can be a nested property with keys separated by dots: 'services.signal.server'.
+   * @param defaultValue Default value to return if option is not present in the config.
+   * @returns The config value or undefined if the option is not present.
+   */
+  get<K extends ConfigKey>(
+    key: K,
+    defaultValue?: DeepIndex<ConfigProto, ParseKey<K>>,
+  ): DeepIndex<ConfigProto, ParseKey<K>> | undefined {
+    return getDeep(this._config, key.split('.')) ?? defaultValue;
+  }
+
+  /**
+   * Get unique key.
+   */
+  find<T = any>(path: string, test: object): T | undefined {
+    const values = getDeep(this._config, path.split('.'));
+    if (!Array.isArray(values)) {
+      return;
+    }
+
+    return values.find((value) => isMatch(value, test));
+  }
+
+  /**
+   * Returns the given config property or throw if it doesn't exist.
+   *
+   * @param key A key in the config object. Can be a nested property with keys separated by dots: 'services.signal.server'.
+   */
+  getOrThrow<K extends ConfigKey>(key: K): Exclude<DeepIndex<ConfigProto, ParseKey<K>>, undefined> {
+    const value: DeepIndex<ConfigProto, ParseKey<K>> | undefined = getDeep(this._config, key.split('.'));
+    if (!value) {
+      throw new Error(`Config option not present: ${key}`);
+    }
+    return value;
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+// TODO(burdon): Why is this exported? (Rename).
+export * as defs from '@dxos/protocols/proto/dxos/config';
+
+export { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+
+export * from './config';
+export * from './loaders';
+export * from './savers';
+export * from './plugin';
+export * from './types';

package/src/loaders/browser.js

@@ -0,0 +1,80 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+/* THIS FILE WILL BE LOADED BY CONTEXT REPLACEMENT PLUGIN IN BROWSER ENVS. */
+
+/* global __DXOS_CONFIG__ __CONFIG_ENVS__ __CONFIG_DEFAULTS__ __CONFIG_LOCAL__ */
+
+import localforage from 'localforage';
+
+import { log } from '@dxos/log';
+
+const CONFIG_ENDPOINT = '/.well-known/dx/config';
+
+export const Local = () => {
+  return typeof __CONFIG_LOCAL__ !== 'undefined' ? __CONFIG_LOCAL__ : {};
+};
+
+export const Dynamics = async () => {
+  const { publicUrl = '', dynamic } = __DXOS_CONFIG__;
+  if (!dynamic) {
+    log('dynamics disabled');
+    return {};
+  }
+
+  log('fetching config...', { publicUrl });
+  return await fetch(`${publicUrl}${CONFIG_ENDPOINT}`)
+    .then((res) => res.json())
+    .catch((error) => {
+      log.warn('Failed to fetch dynamic config.', error);
+      return {};
+    });
+};
+
+export const Envs = () => {
+  return typeof __CONFIG_ENVS__ !== 'undefined' ? __CONFIG_ENVS__ : {};
+};
+
+export const Defaults = () => {
+  return typeof __CONFIG_DEFAULTS__ !== 'undefined' ? __CONFIG_DEFAULTS__ : {};
+};
+
+/**
+ * Settings config from browser storage.
+ */
+export const Storage = async () => {
+  try {
+    const config = await localforage.getItem('dxos.org/settings/config');
+    if (config) {
+      return config;
+    }
+  } catch (err) {
+    log.warn('Failed to load config', { err });
+  }
+  return {};
+};
+
+export const Remote = (target, authenticationToken) => {
+  if (!target) {
+    return {};
+  }
+
+  try {
+    const url = new URL(target);
+    const protocol = url.protocol.slice(0, -1);
+
+    return {
+      runtime: {
+        client: {
+          // TODO(burdon): Remove vault.html.
+          remoteSource: url.origin + (protocol.startsWith('http') ? '/vault.html' : ''),
+          remoteSourceAuthenticationToken: authenticationToken,
+        },
+      },
+    };
+  } catch (err) {
+    log.catch(err);
+    return {};
+  }
+};

package/src/loaders/index.ts

@@ -0,0 +1,90 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { log } from '@dxos/log';
+import { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+
+import { mapFromKeyValues } from '../config';
+import { FILE_DEFAULTS, FILE_ENVS } from '../types';
+
+// TODO(burdon): Move code out of index file.
+
+const DEFAULT_BASE_PATH = path.resolve(process.cwd(), 'config');
+
+const maybeLoadFile = (file: string): any => {
+  try {
+    return yaml.load(fs.readFileSync(file, { encoding: 'utf8' }));
+  } catch (err: any) {
+    // Ignored.
+  }
+};
+
+//
+// NOTE: Export LocalStorage and Dynamics for typescript to typecheck browser code (see ConfigPlugin).
+//
+
+/**
+ * Profile
+ */
+export const Profile = (profile = 'default') => {
+  const configFile = path.join(process.env.HOME ?? '~', `.config/dx/profile/${profile}.yml`);
+  return maybeLoadFile(configFile) as ConfigProto;
+};
+
+/**
+ * Development config.
+ */
+// TODO(burdon): Rename or reconcile with Profile above?
+export const Local = (): Partial<ConfigProto> => ({});
+
+/**
+ * Provided dynamically by server.
+ */
+export const Dynamics = (): Partial<ConfigProto> => ({});
+
+/**
+ * ENV variable (key/value) map.
+ */
+export const Envs = (basePath = DEFAULT_BASE_PATH): Partial<ConfigProto> => {
+  const content = maybeLoadFile(path.resolve(basePath, FILE_ENVS));
+  return content ? mapFromKeyValues(content, process.env) : {};
+};
+
+/**
+ * JSON config.
+ */
+export const Defaults = (basePath = DEFAULT_BASE_PATH): Partial<ConfigProto> =>
+  maybeLoadFile(path.resolve(basePath, FILE_DEFAULTS)) ?? {};
+
+/**
+ * Load config from storage.
+ */
+export const Storage = async (): Promise<Partial<ConfigProto>> => ({});
+
+export const Remote = (target: string | undefined, authenticationToken?: string): Partial<ConfigProto> => {
+  if (!target) {
+    return {};
+  }
+
+  try {
+    const url = new URL(target);
+    const protocol = url.protocol.slice(0, -1);
+    return {
+      runtime: {
+        client: {
+          // TODO(burdon): Remove vault.html.
+          remoteSource: url.origin + (protocol.startsWith('http') ? '/vault.html' : ''),
+          remoteSourceAuthenticationToken: authenticationToken,
+        },
+      },
+    };
+  } catch (err) {
+    log.catch(err);
+    return {};
+  }
+};

package/src/plugin/definitions.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import yaml from 'js-yaml';
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import pkgUp from 'pkg-up';
+
+import { log } from '@dxos/log';
+import { setDeep } from '@dxos/util';
+
+import { type ConfigPluginOpts } from './types';
+import { mapFromKeyValues } from '../config';
+
+const CWD = process.cwd();
+
+export const definitions = ({
+  configPath,
+  envPath,
+  devPath,
+  mode = process.env.NODE_ENV,
+  publicUrl = '',
+  env,
+}: ConfigPluginOpts) => {
+  const KEYS_TO_FILE = {
+    __CONFIG_DEFAULTS__: configPath?.length ? configPath : resolve(CWD, 'dx.yml'),
+    __CONFIG_ENVS__: envPath?.length ? envPath : resolve(CWD, 'dx-env.yml'),
+  } as { [key: string]: string };
+
+  if (mode !== 'production') {
+    KEYS_TO_FILE.__CONFIG_LOCAL__ = devPath ?? resolve(CWD, 'dx-local.yml');
+  }
+
+  return Object.entries(KEYS_TO_FILE).reduce(
+    (prev, [key, value]) => {
+      let content = {};
+
+      try {
+        content = yaml.load(readFileSync(value, 'utf-8')) as any;
+
+        // Map environment variables to config values.
+        if (key === '__CONFIG_ENVS__') {
+          content = mapFromKeyValues(content, process.env);
+        }
+
+        if (key === '__CONFIG_DEFAULTS__') {
+          // Load app environment variables into default config.
+          Object.entries(process.env).forEach(([key, value]) => {
+            if (key.startsWith('DX_') || env?.includes(key)) {
+              setDeep(content, ['runtime', 'app', 'env', key], value);
+            }
+          });
+
+          // Set build info automatically if available.
+          try {
+            const timestamp = new Date().toISOString();
+            const commitHash =
+              process.env.DX_COMMIT_HASH ??
+              execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).replace('\n', '');
+            const packagePath = pkgUp.sync();
+            const packageJson = packagePath && JSON.parse(readFileSync(packagePath, 'utf-8'));
+            setDeep(content, ['runtime', 'app', 'build', 'timestamp'], timestamp);
+            setDeep(content, ['runtime', 'app', 'build', 'commitHash'], commitHash);
+            setDeep(content, ['runtime', 'app', 'build', 'version'], packageJson?.version);
+          } catch {}
+        }
+      } catch (err: any) {
+        if (err.message.includes('YAMLException')) {
+          log.error(`Failed to parse file ${value}:`, err);
+        } else {
+          log(`Failed to load file ${value}:`, err);
+        }
+
+        if (key === '__CONFIG_DEFAULTS__') {
+          // Default config is required.
+          throw new Error(`Failed to load default config file from ${value}`);
+        }
+      }
+
+      return {
+        ...prev,
+        [key]: content,
+      };
+    },
+    {
+      __DXOS_CONFIG__: { dynamic: mode === 'production', publicUrl },
+      __CONFIG_DEFAULTS__: {},
+      __CONFIG_ENVS__: {},
+      __CONFIG_LOCAL__: {},
+    },
+  );
+};

package/src/plugin/esbuild-plugin.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import type { Plugin } from 'esbuild';
+
+import { definitions } from './definitions';
+import { type ConfigPluginOpts } from './types';
+
+export const ConfigPlugin = (options: ConfigPluginOpts = {}): Plugin => {
+  return {
+    name: 'dxos-config',
+    setup: ({ initialOptions }) => {
+      const esbuildOptions = initialOptions;
+      esbuildOptions.define ||= {};
+
+      Object.entries(definitions({ ...options, mode: process.env.NODE_ENV })).reduce((define, [key, value]) => {
+        define[key] = JSON.stringify(value);
+        return define;
+      }, esbuildOptions.define);
+    },
+  };
+};

package/src/plugin/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './definitions';
+export * from './types';

package/src/plugin/rollup-plugin.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { type Plugin } from 'rollup';
+
+import { definitions } from './definitions';
+import { type ConfigPluginOpts } from './types';
+
+export const ConfigPlugin = (options: ConfigPluginOpts = {}): Plugin => {
+  const contents = Object.entries(definitions({ ...options, mode: process.env.NODE_ENV }))
+    .map(([key, value]) => `globalThis.${key} = ${JSON.stringify(value)};`)
+    .join('\n');
+
+  return {
+    name: 'dxos-config',
+    banner: contents,
+  };
+};

package/src/plugin/types.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export interface ConfigPluginOpts {
+  /**
+   * Path to the DX config files, defaults to current working directory.
+   */
+  configPath?: string;
+
+  /**
+   * Path to the environment variable overrides for DX config.
+   */
+  envPath?: string;
+
+  /**
+   * Path to the development overrides for DX config.
+   */
+  devPath?: string;
+
+  /**
+   * If set to `production` then config loaders behave differently:
+   * - `Local` returns an empty object
+   * - `Dynamics` is enabled and makes an HTTP request to the well known config endpoint for config.
+   */
+  mode?: string;
+
+  /**
+   * Public URL of the published app. Also used to load the dynamic config.
+   *
+   * @default ''
+   */
+  publicUrl?: string;
+
+  /**
+   * Environment variables to be passed to the app.
+   */
+  env?: string[];
+}

package/src/plugin/vite-plugin.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { resolve } from 'node:path';
+import type { Plugin } from 'vite';
+
+import { definitions } from './definitions';
+import { type ConfigPluginOpts } from './types';
+
+export const ConfigPlugin = (options: ConfigPluginOpts = {}): Plugin => ({
+  name: 'dxos-config',
+  config: ({ root }) => {
+    const configPath = root && resolve(root, options.configPath ?? 'dx.yml');
+    const envPath = root && resolve(root, options.envPath ?? 'dx-env.yml');
+    const devPath = root && resolve(root, options.devPath ?? 'dx-local.yml');
+    const define = Object.entries(definitions({ ...options, configPath, envPath, devPath })).reduce(
+      (define, [key, value]) => {
+        define[key] = JSON.stringify(value);
+        return define;
+      },
+      {} as { [key: string]: string },
+    );
+
+    return { define };
+  },
+});

package/src/savers/browser.js

@@ -0,0 +1,28 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+/* THIS FILE WILL BE LOADED BY CONTEXT REPLACEMENT PLUGIN IN BROWSER ENVS. */
+
+import localforage from 'localforage';
+
+import { log } from '@dxos/log';
+
+let PERFORMING_CONFIG_SAVE = false;
+
+export const SaveConfig = async (config) => {
+  if (PERFORMING_CONFIG_SAVE) {
+    log.warn('Already performing config save');
+    return;
+  }
+  PERFORMING_CONFIG_SAVE = true;
+
+  try {
+    await localforage.setItem('dxos.org/settings/config', config);
+  } catch (err) {
+    log.warn('Failed to save config', { err });
+    return {};
+  } finally {
+    PERFORMING_CONFIG_SAVE = false;
+  }
+};

package/src/savers/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+
+export const SaveConfig = async (_: ConfigProto) => {};

package/src/testing/build.js

@@ -0,0 +1,21 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// This script is used to test whether the esbuild config plugin is properly injecting config constants.
+// TODO(wittjosiah): Automate this test.
+
+const { build } = require('esbuild');
+const { join } = require('node:path');
+
+// eslint-disable-next-line
+// @ts-ignore
+const { ConfigPlugin } = require('../../dist/plugin/node/esbuild-plugin.cjs');
+
+void build({
+  entryPoints: [join(__dirname, './entry.js')],
+  outdir: join(__dirname, '../../out'),
+  write: true,
+  bundle: true,
+  plugins: [ConfigPlugin()],
+});

package/src/testing/defaults.js

@@ -0,0 +1,11 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(wittjosiah): This should be JSON but isn't due to Nx TS build issue.
+export default {
+  client: {
+    id: 123,
+    tag: 'xyz',
+  },
+};

package/src/testing/entry.js

@@ -0,0 +1,10 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// eslint-disable-next-line
+// @ts-ignore
+const { Defaults } = require('../../dist/lib/node/index.cjs');
+
+// eslint-disable-next-line no-console
+console.log(Defaults());

package/src/testing/envs-map.js

@@ -0,0 +1,17 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(wittjosiah): This should be JSON but isn't due to Nx TS build issue.
+export default {
+  TEST_CLIENT_ID: {
+    path: 'runtime.client.id',
+    type: 'number',
+  },
+  TEST_CLIENT_TAG: {
+    path: 'runtime.client.tag',
+  },
+  TEST_SERVER_ENDPOINT: {
+    path: 'runtime.server.endpoint',
+  },
+};

package/src/types.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { type Config as ConfigProto } from '@dxos/protocols/proto/dxos/config';
+
+export const FILE_DEFAULTS = 'defaults.yml';
+export const FILE_ENVS = 'envs-map.yml';
+export const FILE_DYNAMICS = 'config.yml';
+
+type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`;
+
+/**
+ * Returns all dot-separated nested keys for an object.
+ *
+ * Read more: https://stackoverflow.com/a/68404823.
+ */
+type DotNestedKeys<T> = (
+  T extends object
+    ? {
+        [K in Exclude<keyof T, symbol>]: `${K}${DotPrefix<DotNestedKeys<T[K]>>}`;
+      }[Exclude<keyof T, symbol>]
+    : ''
+) extends infer D
+  ? Extract<D, string>
+  : never;
+
+/**
+ * Parse a dot separated nested key into an array of keys.
+ *
+ * Example: 'services.signal.server' -> ['services', 'signal', 'server'].
+ */
+export type ParseKey<K extends string> = K extends `${infer L}.${infer Rest}` ? [L, ...ParseKey<Rest>] : [K];
+
+/**
+ * Array of types that can act as an object key.
+ */
+type Keys = (keyof any)[];
+
+/**
+ * Retrieves a property type in a series of nested objects.
+ *
+ * Read more: https://stackoverflow.com/a/61648690.
+ */
+export type DeepIndex<T, KS extends Keys, Fail = undefined> = KS extends [infer F, ...infer R]
+  ? F extends keyof Exclude<T, undefined>
+    ? R extends Keys
+      ? DeepIndex<Exclude<T, undefined>[F], R, Fail>
+      : Fail
+    : Fail
+  : T;
+
+/**
+ * Any nested dot separated key that can be in config.
+ */
+// TODO(egorgripasov): Clean once old config deprecated.
+export type ConfigKey = DotNestedKeys<ConfigProto>;

package/dist/types/src/plugin/webpack-plugin.d.ts

@@ -1,8 +0,0 @@
-import { type Compiler } from 'webpack';
-import { type ConfigPluginOpts } from './types';
-export declare class ConfigPlugin {
-    private readonly _options;
-    constructor(_options?: ConfigPluginOpts);
-    apply(compiler: Compiler): void;
-}
-//# sourceMappingURL=webpack-plugin.d.ts.map

package/dist/types/src/plugin/webpack-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webpack-plugin.d.ts","sourceRoot":"","sources":["../../../../src/plugin/webpack-plugin.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,GAAE,gBAAqB;IAE5D,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAWzB"}

package/esbuild-plugin.d.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-export * from './dist/types/src/plugin/esbuild-plugin';

package/esbuild-plugin.js

@@ -1,8 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-// Not included in the main `index.ts` so that the apps are not bundled with it.
-// It contains native Node functionality so must not be included in the final app bundle, only during compilation/bundling.
-
-module.exports = require('./dist/plugin/node/esbuild-plugin.cjs');

package/rollup-plugin.d.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-export * from './dist/types/src/plugin/rollup-plugin';

package/rollup-plugin.js

@@ -1,8 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-// Not included in the main `index.ts` so that the apps are not bundled with it.
-// It contains native Node functionality so must not be included in the final app bundle, only during compilation/bundling.
-
-module.exports = require('./dist/plugin/node/rollup-plugin.cjs');

package/vite-plugin.d.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-export * from './dist/types/src/plugin/vite-plugin';

package/webpack-plugin.d.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-export * from './dist/types/src/plugin/webpack-plugin';

package/webpack-plugin.js

@@ -1,8 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-// Not included in the main `index.ts` so that the apps are not bundled with it.
-// It contains native Node functionality so must not be included in the final app bundle, only during compilation/bundling.
-
-module.exports = require('./dist/plugin/node/webpack-plugin.cjs');