@lorion-org/runtime-config-node 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,526 @@
+// src/index.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import path from "path";
+import Ajv from "ajv";
+import {
+  getRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  projectRuntimeConfigEnvVars,
+  toRuntimeConfigFragment,
+  runtimeEnvVarsToShellAssignments
+} from "@lorion-org/runtime-config";
+var defaultRuntimeConfigFileName = "runtime.config.json";
+var defaultRuntimeConfigDirName = "runtime-config";
+var defaultRuntimeConfigSchemaFileName = "runtime-config.schema.json";
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+function escapeRegex(value) {
+  return value.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+function countWildcards(pattern) {
+  return (pattern.match(/\*/g) ?? []).length;
+}
+function assertSingleWildcardPattern(pattern) {
+  const wildcardCount = countWildcards(pattern);
+  if (wildcardCount !== 1) {
+    throw new Error(
+      `RuntimeConfig path pattern must contain exactly one "*" wildcard: "${pattern}"`
+    );
+  }
+}
+function createGlobSegmentRegex(segment) {
+  return new RegExp(`^${segment.split("*").map(escapeRegex).join("[^/\\\\]*")}$`);
+}
+function splitAbsolutePattern(pattern) {
+  const absolutePattern = path.resolve(pattern);
+  const parsed = path.parse(absolutePattern);
+  const relativePattern = path.relative(parsed.root, absolutePattern);
+  return {
+    root: parsed.root,
+    segments: relativePattern.split(/[\\/]+/).filter(Boolean)
+  };
+}
+function expandRuntimeConfigPattern(pattern) {
+  assertSingleWildcardPattern(pattern);
+  const { root, segments } = splitAbsolutePattern(pattern);
+  const visit = (currentDir, index) => {
+    const segment = segments[index];
+    if (!segment) return [];
+    const isLast = index === segments.length - 1;
+    if (!segment.includes("*")) {
+      const nextPath = path.join(currentDir, segment);
+      if (isLast) return existsSync(nextPath) ? [nextPath] : [];
+      if (!existsSync(nextPath)) return [];
+      return visit(nextPath, index + 1);
+    }
+    if (!existsSync(currentDir)) return [];
+    const matcher = createGlobSegmentRegex(segment);
+    return readdirSync(currentDir, { withFileTypes: true }).filter((entry) => entry.name !== "node_modules" && matcher.test(entry.name)).flatMap((entry) => {
+      const nextPath = path.join(currentDir, entry.name);
+      if (isLast) return entry.isFile() ? [nextPath] : [];
+      return entry.isDirectory() ? visit(nextPath, index + 1) : [];
+    });
+  };
+  return visit(root, 0);
+}
+function getRuntimeConfigScopeIdFromPattern(input) {
+  assertSingleWildcardPattern(input.pattern);
+  const resolvedPattern = path.resolve(input.pattern);
+  const wildcardIndex = resolvedPattern.indexOf("*");
+  const beforeWildcard = resolvedPattern.slice(0, wildcardIndex);
+  const afterWildcard = resolvedPattern.slice(wildcardIndex + 1);
+  const configPath = path.resolve(input.configPath);
+  if (!configPath.startsWith(beforeWildcard) || !configPath.endsWith(afterWildcard)) {
+    throw new Error(
+      `RuntimeConfig file "${input.configPath}" does not match pattern "${input.pattern}"`
+    );
+  }
+  return toPosixPath(
+    configPath.slice(beforeWildcard.length, configPath.length - afterWildcard.length)
+  ).replace(/^\/+|\/+$/g, "");
+}
+function getRuntimeConfigPatternPublicRoot(pattern) {
+  assertSingleWildcardPattern(pattern);
+  const resolvedPattern = path.resolve(pattern);
+  const beforeWildcard = resolvedPattern.slice(0, resolvedPattern.indexOf("*"));
+  const wildcardParent = beforeWildcard.replace(/[\\/]+$/, "");
+  return path.resolve(wildcardParent, "public");
+}
+function getFileName(options) {
+  return options.fileName ?? defaultRuntimeConfigFileName;
+}
+function getRuntimeConfigDirName(options) {
+  return options.runtimeConfigDirName ?? defaultRuntimeConfigDirName;
+}
+function getRuntimeConfigPathOptions(source) {
+  return {
+    ...source.fileName ? { fileName: source.fileName } : {},
+    ...source.runtimeConfigDirName ? { runtimeConfigDirName: source.runtimeConfigDirName } : {}
+  };
+}
+function getSchemaFileName(options) {
+  return options.schemaFileName ?? defaultRuntimeConfigSchemaFileName;
+}
+function stripJsonBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function ensureParentDir(filePath) {
+  const dirPath = path.dirname(filePath);
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+}
+function readTextFile(filePath) {
+  return existsSync(filePath) ? readFileSync(filePath, "utf8") : void 0;
+}
+function writeTextFile(filePath, data, options = {}) {
+  if (options.createDir !== false) ensureParentDir(filePath);
+  writeFileSync(filePath, data, "utf8");
+}
+function readJsonFile(filePath, options = {}) {
+  const text = readTextFile(filePath);
+  if (text === void 0) return void 0;
+  try {
+    return JSON.parse(stripJsonBom(text));
+  } catch (error) {
+    options.onParseError?.(error, filePath);
+    return options.defaultValue;
+  }
+}
+function readRequiredJsonFile(filePath) {
+  const text = readTextFile(filePath);
+  if (text === void 0) {
+    throw new Error(`RuntimeConfig JSON file not found: "${filePath}"`);
+  }
+  try {
+    return JSON.parse(stripJsonBom(text));
+  } catch (error) {
+    throw new Error(`RuntimeConfig JSON parse error in "${filePath}": ${String(error)}`);
+  }
+}
+function writeJsonFile(filePath, data, options = {}) {
+  const spacing = options.pretty === false ? void 0 : 2;
+  writeTextFile(filePath, `${JSON.stringify(data, void 0, spacing)}
+`, options);
+}
+function resolveRuntimeConfigPaths(varDir, scopeId, options = {}) {
+  const runtimeConfigDir = path.join(varDir, getRuntimeConfigDirName(options));
+  const scopeDir = path.join(runtimeConfigDir, scopeId);
+  const filePath = path.join(scopeDir, getFileName(options));
+  return {
+    varDir,
+    runtimeConfigDir,
+    scopeDir,
+    filePath
+  };
+}
+function resolveRuntimeConfigSource(options = {}) {
+  const envKey = options.envKey ?? "RUNTIME_CONFIG_VAR_DIR";
+  const varDir = String(
+    options.varDir ?? options.env?.[envKey] ?? options.defaultVarDir ?? ""
+  ).trim();
+  if (!varDir) {
+    throw new Error(`RuntimeConfig varDir not found. Pass varDir or set ${envKey}.`);
+  }
+  return {
+    varDir,
+    ...options.fileName ? { fileName: options.fileName } : {},
+    ...options.runtimeConfigDirName ? { runtimeConfigDirName: options.runtimeConfigDirName } : {}
+  };
+}
+function resolveRuntimeConfigFilePath(varDir, scopeId, filename, options = {}) {
+  const { scopeDir } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  return path.join(scopeDir, filename);
+}
+function resolveRuntimeConfigScopeFilePath(source, scopeId, fileName) {
+  return resolveRuntimeConfigFilePath(
+    source.varDir,
+    scopeId,
+    fileName,
+    getRuntimeConfigPathOptions(source)
+  );
+}
+function readRuntimeConfigScopeJson(source, scopeId, fileName, options = {}) {
+  return readJsonFile(resolveRuntimeConfigScopeFilePath(source, scopeId, fileName), options);
+}
+function writeRuntimeConfigScopeJson(source, scopeId, fileName, data, options = {}) {
+  writeJsonFile(resolveRuntimeConfigScopeFilePath(source, scopeId, fileName), data, options);
+}
+function resolveRuntimeConfigPublicRootPath(source) {
+  return path.resolve(
+    source.varDir,
+    getRuntimeConfigDirName(getRuntimeConfigPathOptions(source)),
+    "public"
+  );
+}
+function resolveRuntimeConfigPublicFilePath(source, relativePath) {
+  return path.resolve(resolveRuntimeConfigPublicRootPath(source), relativePath);
+}
+function resolveRuntimeConfigSourceFiles(source) {
+  return source.paths.flatMap(
+    (pattern) => expandRuntimeConfigPattern(pattern).map((configPath) => ({
+      configPath,
+      pattern,
+      scopeId: getRuntimeConfigScopeIdFromPattern({ configPath, pattern })
+    }))
+  ).filter((entry, index, entries) => {
+    return entries.findIndex((candidate) => candidate.configPath === entry.configPath) === index;
+  }).sort((left, right) => left.configPath.localeCompare(right.configPath));
+}
+function loadRuntimeConfigSourceTree(source) {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const entry of resolveRuntimeConfigSourceFiles(source)) {
+    const config = readJsonFile(entry.configPath);
+    if (config) fragments.set(entry.scopeId, config);
+  }
+  return fragments;
+}
+function resolveRuntimeConfigSourcePublicRootPath(source) {
+  const pattern = source.paths[0];
+  return pattern ? getRuntimeConfigPatternPublicRoot(pattern) : void 0;
+}
+function listRuntimeConfigScopeFiles(varDir, scopeId, subdir, options = {}) {
+  const dirPath = resolveRuntimeConfigFilePath(varDir, scopeId, subdir, options);
+  if (!existsSync(dirPath)) return [];
+  return readdirSync(dirPath, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => options.extension ? name.endsWith(options.extension) : true);
+}
+function collectRuntimeConfigFragmentFiles(runtimeConfigDir, options = {}) {
+  const fileName = getFileName(options);
+  const files = [];
+  if (!existsSync(runtimeConfigDir)) return files;
+  const walk = (currentPath) => {
+    for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+      const absolutePath = path.resolve(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile() && entry.name === fileName) {
+        files.push(absolutePath);
+      }
+    }
+  };
+  walk(runtimeConfigDir);
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function parseRuntimeConfigFragmentFiles(filePaths, runtimeConfigDir, options = {}) {
+  const fileName = getFileName(options);
+  const fragments = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    const relativePath = toPosixPath(path.relative(runtimeConfigDir, filePath));
+    const scopeId = relativePath.replace(
+      new RegExp(`/${fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`),
+      ""
+    );
+    const config = readJsonFile(filePath);
+    if (config) fragments.set(scopeId, config);
+  }
+  return fragments;
+}
+function loadRuntimeConfigFragment(varDir, scopeId, options = {}) {
+  const { filePath } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  return readJsonFile(filePath);
+}
+function writeRuntimeConfigFragment(varDir, scopeId, config, options = {}) {
+  const { filePath } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  writeJsonFile(filePath, config, options);
+}
+function formatRuntimeConfigSchemaValidationError(target, validationError) {
+  const jsonPath = validationError.instancePath || "/";
+  const ajvError = `${validationError.keyword}${validationError.message ? `: ${validationError.message}` : ""}`;
+  return new Error(
+    [
+      "RuntimeConfig schema validation failed.",
+      `Scope: ${target.scopeId}`,
+      `File: ${target.configPath}`,
+      `JSON path: ${jsonPath}`,
+      `Schema error: ${ajvError}`
+    ].join("\n")
+  );
+}
+function validateRuntimeConfigSchemaTargets(targets, options = {}) {
+  const ajv = new Ajv({
+    strict: false,
+    allErrors: false,
+    ...options.ajvOptions
+  });
+  const formatError = options.formatError ?? formatRuntimeConfigSchemaValidationError;
+  for (const target of targets) {
+    if (!existsSync(target.schemaPath) || !existsSync(target.configPath)) {
+      continue;
+    }
+    const schema = readRequiredJsonFile(target.schemaPath);
+    const runtimeConfig = readRequiredJsonFile(target.configPath);
+    const validate = ajv.compile(schema);
+    const isValid = validate(runtimeConfig);
+    if (!isValid) {
+      const validationError = validate.errors?.[0];
+      if (validationError) {
+        throw formatError(target, validationError);
+      }
+      throw new Error(
+        `RuntimeConfig schema validation failed for "${target.scopeId}" (${target.configPath})`
+      );
+    }
+  }
+}
+function loadRuntimeConfigTree(varDir, options = {}) {
+  const runtimeConfigDir = path.join(varDir, getRuntimeConfigDirName(options));
+  const filePaths = collectRuntimeConfigFragmentFiles(runtimeConfigDir, options);
+  return parseRuntimeConfigFragmentFiles(filePaths, runtimeConfigDir, options);
+}
+function loadRuntimeConfigEnvVars(varDir, options = {}) {
+  const { fileName, runtimeConfigDirName, ...envOptions } = options;
+  return projectRuntimeConfigEnvVars(
+    loadRuntimeConfigTree(varDir, {
+      ...fileName ? { fileName } : {},
+      ...runtimeConfigDirName ? { runtimeConfigDirName } : {}
+    }),
+    envOptions
+  );
+}
+function loadRuntimeConfigShellAssignments(varDir, options = {}) {
+  return runtimeEnvVarsToShellAssignments(loadRuntimeConfigEnvVars(varDir, options));
+}
+function listRuntimeConfigFragments(varDir, options = {}) {
+  const { contextInputKey, ...pathOptions } = options;
+  const fragments = loadRuntimeConfigTree(varDir, pathOptions);
+  const scopes = Array.from(fragments.entries()).map(([scopeId, config]) => {
+    const fragment = contextInputKey ? toRuntimeConfigFragment(config, { contextInputKey }) : config;
+    return {
+      contextIds: Object.keys(fragment.contexts ?? {}).sort(),
+      path: resolveRuntimeConfigPaths(varDir, scopeId, pathOptions).filePath,
+      privateKeys: Object.keys(config.private ?? {}).sort(),
+      publicKeys: Object.keys(config.public ?? {}).sort(),
+      scopeId
+    };
+  }).sort((left, right) => left.scopeId.localeCompare(right.scopeId));
+  return {
+    fileName: getFileName(pathOptions),
+    scopes,
+    varDir
+  };
+}
+function showRuntimeConfigFragment(varDir, scopeId, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const config = normalizedScopeId ? loadRuntimeConfigFragment(varDir, normalizedScopeId, options) : void 0;
+  return {
+    fileName: getFileName(options),
+    path: resolveRuntimeConfigPaths(varDir, normalizedScopeId, options).filePath,
+    scopeId: normalizedScopeId,
+    varDir,
+    exists: Boolean(config),
+    ...config ? { config } : {}
+  };
+}
+function projectRuntimeConfigTree(varDir, options = {}) {
+  const fragments = loadRuntimeConfigTree(varDir, options);
+  const scopeIds = options.scopeIds?.length ? options.scopeIds : Array.from(fragments.keys()).sort();
+  return {
+    fileName: getFileName(options),
+    runtimeConfig: projectSectionedRuntimeConfig(fragments, {
+      ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+      ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+      scopeIds
+    }),
+    scopeIds,
+    varDir
+  };
+}
+function getRuntimeConfigValue(varDir, scopeId, key, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const normalizedKey = key.trim();
+  const visibility = options.visibility ?? "public";
+  const runtimeConfig = projectRuntimeConfigTree(varDir, {
+    ...options,
+    scopeIds: normalizedScopeId ? [normalizedScopeId] : []
+  }).runtimeConfig;
+  const value = resolveRuntimeConfigValueFromRuntimeConfig(
+    runtimeConfig,
+    normalizedScopeId,
+    normalizedKey,
+    {
+      ...options.contextId ? { contextId: options.contextId } : {},
+      ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+      visibility
+    }
+  );
+  return {
+    fileName: getFileName(options),
+    key: normalizedKey,
+    scopeId: normalizedScopeId,
+    varDir,
+    visibility,
+    ...options.contextId ? { contextId: options.contextId } : {},
+    exists: value !== void 0,
+    ...value !== void 0 ? { value } : {}
+  };
+}
+function getRuntimeConfigScopeView(varDir, scopeId, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const visibility = options.visibility ?? "public";
+  const runtimeConfig = projectRuntimeConfigTree(varDir, {
+    ...options,
+    scopeIds: normalizedScopeId ? [normalizedScopeId] : []
+  }).runtimeConfig;
+  const scopeOptions = {
+    ...options.contextId ? { contextId: options.contextId } : {},
+    ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+    visibility
+  };
+  return {
+    config: getRuntimeConfigScope(runtimeConfig, normalizedScopeId, scopeOptions),
+    fileName: getFileName(options),
+    scopeId: normalizedScopeId,
+    varDir,
+    visibility,
+    ...options.contextId ? { contextId: options.contextId } : {}
+  };
+}
+function validateRuntimeConfigScopes(varDir, targets, options = {}) {
+  const schemaFileName = getSchemaFileName(options);
+  const result = {
+    fileName: getFileName(options),
+    skipped: [],
+    validated: [],
+    varDir
+  };
+  for (const target of targets) {
+    const scopeId = target.scopeId.trim();
+    if (!scopeId) continue;
+    const configPath = resolveRuntimeConfigPaths(varDir, scopeId, options).filePath;
+    const schemaPath = target.cwd ? path.resolve(target.cwd, schemaFileName) : void 0;
+    if (!target.cwd || !schemaPath) {
+      result.skipped.push({ configPath, reason: "missing-scope-dir", scopeId });
+      continue;
+    }
+    if (!existsSync(configPath)) {
+      result.skipped.push({ configPath, reason: "missing-config", schemaPath, scopeId });
+      continue;
+    }
+    if (!existsSync(schemaPath)) {
+      result.skipped.push({ configPath, reason: "missing-schema", schemaPath, scopeId });
+      continue;
+    }
+    result.validated.push({ configPath, schemaPath, scopeId });
+  }
+  validateRuntimeConfigSchemaTargets(result.validated, {
+    ...options.formatError ? { formatError: options.formatError } : {}
+  });
+  return result;
+}
+function validateRuntimeConfigSourceScopes(source, targets, options = {}) {
+  const schemaFileName = getSchemaFileName(options);
+  const filesByScope = /* @__PURE__ */ new Map();
+  const result = {
+    fileName: source.paths[0] ?? "",
+    skipped: [],
+    validated: [],
+    varDir: ""
+  };
+  for (const file of resolveRuntimeConfigSourceFiles(source)) {
+    filesByScope.set(file.scopeId, file.configPath);
+  }
+  for (const target of targets) {
+    const scopeId = target.scopeId.trim();
+    if (!scopeId) continue;
+    const configPath = filesByScope.get(scopeId);
+    const schemaPath = target.cwd ? path.resolve(target.cwd, schemaFileName) : void 0;
+    if (!target.cwd || !schemaPath) {
+      result.skipped.push({
+        ...configPath ? { configPath } : {},
+        reason: "missing-scope-dir",
+        scopeId
+      });
+      continue;
+    }
+    if (!configPath) {
+      result.skipped.push({ reason: "missing-config", schemaPath, scopeId });
+      continue;
+    }
+    if (!existsSync(schemaPath)) {
+      result.skipped.push({ configPath, reason: "missing-schema", schemaPath, scopeId });
+      continue;
+    }
+    result.validated.push({ configPath, schemaPath, scopeId });
+  }
+  validateRuntimeConfigSchemaTargets(result.validated, {
+    ...options.formatError ? { formatError: options.formatError } : {}
+  });
+  return result;
+}
+export {
+  collectRuntimeConfigFragmentFiles,
+  ensureParentDir,
+  getRuntimeConfigScopeView,
+  getRuntimeConfigValue,
+  listRuntimeConfigFragments,
+  listRuntimeConfigScopeFiles,
+  loadRuntimeConfigEnvVars,
+  loadRuntimeConfigFragment,
+  loadRuntimeConfigShellAssignments,
+  loadRuntimeConfigSourceTree,
+  loadRuntimeConfigTree,
+  parseRuntimeConfigFragmentFiles,
+  projectRuntimeConfigTree,
+  readJsonFile,
+  readRequiredJsonFile,
+  readRuntimeConfigScopeJson,
+  readTextFile,
+  resolveRuntimeConfigFilePath,
+  resolveRuntimeConfigPaths,
+  resolveRuntimeConfigPublicFilePath,
+  resolveRuntimeConfigPublicRootPath,
+  resolveRuntimeConfigScopeFilePath,
+  resolveRuntimeConfigSource,
+  resolveRuntimeConfigSourceFiles,
+  resolveRuntimeConfigSourcePublicRootPath,
+  showRuntimeConfigFragment,
+  validateRuntimeConfigSchemaTargets,
+  validateRuntimeConfigScopes,
+  validateRuntimeConfigSourceScopes,
+  writeJsonFile,
+  writeRuntimeConfigFragment,
+  writeRuntimeConfigScopeJson,
+  writeTextFile
+};

package/examples/env-assignments.ts

@@ -0,0 +1,21 @@
+import {
+  loadRuntimeConfigShellAssignments,
+  writeRuntimeConfigFragment,
+} from '@lorion-org/runtime-config-node';
+
+writeRuntimeConfigFragment('./var', 'billing', {
+  public: {
+    apiBase: '/api/billing',
+  },
+  private: {
+    token: 'billing-token',
+  },
+});
+
+const assignments = loadRuntimeConfigShellAssignments('./var', {
+  prefix: 'APP',
+});
+
+console.log(assignments);
+// APP_PUBLIC_BILLING_API_BASE='"/api/billing"'
+// APP_PRIVATE_BILLING_TOKEN='"billing-token"'

package/examples/load-runtime-config-tree.ts

@@ -0,0 +1,17 @@
+import { projectSectionedRuntimeConfig } from '@lorion-org/runtime-config';
+import { loadRuntimeConfigTree, writeRuntimeConfigFragment } from '@lorion-org/runtime-config-node';
+
+writeRuntimeConfigFragment('./var', 'billing', {
+  public: {
+    apiBase: '/api/billing',
+  },
+});
+
+const fragments = loadRuntimeConfigTree('./var');
+const runtimeConfig = projectSectionedRuntimeConfig(fragments);
+
+console.log(runtimeConfig.public);
+// { billingApiBase: '/api/billing' }
+
+console.log(runtimeConfig.private);
+// {}

package/examples/query-runtime-config-tree.ts

@@ -0,0 +1,53 @@
+import {
+  getRuntimeConfigScopeView,
+  getRuntimeConfigValue,
+  listRuntimeConfigFragments,
+  projectRuntimeConfigTree,
+  writeRuntimeConfigFragment,
+} from '@lorion-org/runtime-config-node';
+
+writeRuntimeConfigFragment('./var', 'billing', {
+  public: {
+    apiBase: '/api/billing',
+  },
+  private: {
+    token: 'billing-token',
+  },
+  contexts: {
+    tenantA: {
+      public: {
+        apiBase: '/tenant-a/billing',
+      },
+    },
+  },
+});
+
+const listResult = listRuntimeConfigFragments('./var');
+console.log(listResult.scopes);
+// [{ scopeId: 'billing', publicKeys: ['apiBase'], privateKeys: ['token'], contextIds: ['tenantA'], ... }]
+
+const projectResult = projectRuntimeConfigTree('./var', {
+  contextOutputKey: '__tenants',
+});
+console.log(projectResult.runtimeConfig.public);
+// {
+//   billingApiBase: '/api/billing',
+//   __tenants: {
+//     tenantA: {
+//       billingApiBase: '/tenant-a/billing',
+//     },
+//   },
+// }
+
+const valueResult = getRuntimeConfigValue('./var', 'billing', 'apiBase', {
+  contextId: 'tenantA',
+  contextOutputKey: '__tenants',
+});
+console.log(valueResult.value);
+// /tenant-a/billing
+
+const scopeResult = getRuntimeConfigScopeView('./var', 'billing', {
+  visibility: 'private',
+});
+console.log(scopeResult.config);
+// { token: 'billing-token' }

package/examples/source-and-scope-files.ts

@@ -0,0 +1,24 @@
+import {
+  readRuntimeConfigScopeJson,
+  resolveRuntimeConfigPublicFilePath,
+  resolveRuntimeConfigSource,
+  writeRuntimeConfigScopeJson,
+} from '@lorion-org/runtime-config-node';
+
+const source = resolveRuntimeConfigSource({
+  defaultVarDir: './var',
+  env: process.env,
+  envKey: 'APP_VAR_DIR',
+});
+
+writeRuntimeConfigScopeJson(source, 'billing', 'settings.json', {
+  apiBase: '/api/billing',
+});
+
+const settings = readRuntimeConfigScopeJson(source, 'billing', 'settings.json');
+console.log(settings);
+// { apiBase: '/api/billing' }
+
+const logoPath = resolveRuntimeConfigPublicFilePath(source, 'billing/logo.svg');
+console.log(logoPath);
+// /absolute/project/path/var/runtime-config/public/billing/logo.svg