@lorion-org/runtime-config 1.0.0-beta.0 → 1.0.0-beta.1

package/examples/context-input-key.ts

@@ -6,15 +6,15 @@ import {
 const runtimeConfig = projectSectionedRuntimeConfig(
   [
     {
-      scopeId: 'billing',
+      scopeId: 'checkout',
       config: {
         public: {
-          apiBase: '/api/billing',
+          successPath: '/orders/confirmed',
         },
-        tenants: {
-          tenantA: {
+        stores: {
+          'eu-store': {
             public: {
-              apiBase: '/tenant-a/billing',
+              successPath: '/eu-store/orders/confirmed',
             },
           },
         },
@@ -22,25 +22,25 @@ const runtimeConfig = projectSectionedRuntimeConfig(
     },
   ],
   {
-    contextInputKey: 'tenants',
-    contextOutputKey: '__tenants',
+    contextInputKey: 'stores',
+    contextOutputKey: '__stores',
   },
 );
 
 console.log(runtimeConfig.public);
 // {
-//   billingApiBase: '/api/billing',
-//   __tenants: {
-//     tenantA: {
-//       billingApiBase: '/tenant-a/billing'
+//   checkoutSuccessPath: '/orders/confirmed',
+//   __stores: {
+//     'eu-store': {
+//       checkoutSuccessPath: '/eu-store/orders/confirmed'
 //     }
 //   }
 // }
 
 console.log(
-  resolveRuntimeConfigValue(runtimeConfig.public, 'billing', 'apiBase', {
-    contextId: 'tenantA',
-    contextOutputKey: '__tenants',
+  resolveRuntimeConfigValue(runtimeConfig.public, 'checkout', 'successPath', {
+    contextId: 'eu-store',
+    contextOutputKey: '__stores',
   }),
 );
-// '/tenant-a/billing'
+// '/eu-store/orders/confirmed'

package/examples/env-vars.ts

@@ -7,19 +7,19 @@ import {
 const envVars = toRuntimeEnvVars(
   {
     public: {
-      billingApiBase: '/api/billing',
+      checkoutSuccessPath: '/orders/confirmed',
     },
     private: {
-      billingApiSecret: 'secret',
+      checkoutSigningSecret: 'checkout_signing_secret_demo',
     },
   },
   'APP',
 );
 
 console.log(runtimeEnvVarsToString(envVars));
-// APP_PUBLIC_BILLING_API_BASE=/api/billing
-// APP_PRIVATE_BILLING_API_SECRET=secret
+// APP_PUBLIC_CHECKOUT_SUCCESS_PATH=/orders/confirmed
+// APP_PRIVATE_CHECKOUT_SIGNING_SECRET=checkout_signing_secret_demo
 
 console.log(runtimeEnvVarsToShellAssignments(envVars));
-// APP_PUBLIC_BILLING_API_BASE='"/api/billing"'
-// APP_PRIVATE_BILLING_API_SECRET='"secret"'
+// APP_PUBLIC_CHECKOUT_SUCCESS_PATH='"/orders/confirmed"'
+// APP_PRIVATE_CHECKOUT_SIGNING_SECRET='"checkout_signing_secret_demo"'

package/examples/namespaced-runtime-config.ts

@@ -3,48 +3,48 @@ import {
   projectRuntimeConfigNamespaces,
 } from '@lorion-org/runtime-config';
 
-const billingRuntimeConfig = projectRuntimeConfigNamespace('billing', {
+const checkoutRuntimeConfig = projectRuntimeConfigNamespace('checkout', {
   public: {
-    apiBase: '/api/billing',
+    successPath: '/orders/confirmed',
   },
   private: {
-    token: 'billing-token',
+    signingSecret: 'checkout_signing_secret_demo',
   },
 });
 
-console.log(billingRuntimeConfig.public.billing);
-// { apiBase: '/api/billing' }
+console.log(checkoutRuntimeConfig.public.checkout);
+// { successPath: '/orders/confirmed' }
 
-console.log(billingRuntimeConfig.billing);
-// { token: 'billing-token' }
+console.log(checkoutRuntimeConfig.checkout);
+// { signingSecret: 'checkout_signing_secret_demo' }
 
 const combinedRuntimeConfig = projectRuntimeConfigNamespaces([
   {
-    scopeId: 'billing',
+    scopeId: 'checkout',
     config: {
       public: {
-        apiBase: '/api/billing',
+        successPath: '/orders/confirmed',
       },
       private: {
-        token: 'billing-token',
+        signingSecret: 'checkout_signing_secret_demo',
       },
     },
   },
   {
-    scopeId: 'mail',
+    scopeId: 'payments',
     config: {
       public: {
-        apiBase: '/api/mail',
+        configuredProvider: 'payment-provider-stripe',
       },
     },
   },
 ]);
 
-console.log(combinedRuntimeConfig.public.billing);
-// { apiBase: '/api/billing' }
+console.log(combinedRuntimeConfig.public.checkout);
+// { successPath: '/orders/confirmed' }
 
-console.log(combinedRuntimeConfig.public.mail);
-// { apiBase: '/api/mail' }
+console.log(combinedRuntimeConfig.public.payments);
+// { configuredProvider: 'payment-provider-stripe' }
 
-console.log(combinedRuntimeConfig.billing);
-// { token: 'billing-token' }
+console.log(combinedRuntimeConfig.checkout);
+// { signingSecret: 'checkout_signing_secret_demo' }

package/examples/scope-view.ts

@@ -5,28 +5,28 @@ import {
   toRuntimeEnvVars,
 } from '@lorion-org/runtime-config';
 
-const runtimeConfig = projectRuntimeConfigFragment('auth', {
+const runtimeConfig = projectRuntimeConfigFragment('checkout', {
   public: {
-    url: 'https://auth.example.test',
-    realm: 'main',
+    currency: 'EUR',
+    successPath: '/orders/confirmed',
   },
   private: {
-    clientSecret: 'secret',
+    signingSecret: 'checkout_signing_secret_demo',
   },
 });
 
-console.log(runtimeConfig.public.authUrl);
-// 'https://auth.example.test'
+console.log(runtimeConfig.public.checkoutCurrency);
+// 'EUR'
 
 console.log(toRuntimeEnvVars(runtimeConfig, 'APP'));
 // {
-//   APP_PUBLIC_AUTH_URL: 'https://auth.example.test',
-//   APP_PUBLIC_AUTH_REALM: 'main',
-//   APP_PRIVATE_AUTH_CLIENT_SECRET: 'secret'
+//   APP_PUBLIC_CHECKOUT_CURRENCY: 'EUR',
+//   APP_PUBLIC_CHECKOUT_SUCCESS_PATH: '/orders/confirmed',
+//   APP_PRIVATE_CHECKOUT_SIGNING_SECRET: 'checkout_signing_secret_demo'
 // }
 
-console.log(getPublicRuntimeConfigScope(runtimeConfig, 'auth'));
-// { url: 'https://auth.example.test', realm: 'main' }
+console.log(getPublicRuntimeConfigScope(runtimeConfig, 'checkout'));
+// { currency: 'EUR', successPath: '/orders/confirmed' }
 
-console.log(getPrivateRuntimeConfigScope(runtimeConfig, 'auth'));
-// { clientSecret: 'secret' }
+console.log(getPrivateRuntimeConfigScope(runtimeConfig, 'checkout'));
+// { signingSecret: 'checkout_signing_secret_demo' }

package/examples/sectioned-runtime-config.ts

@@ -7,46 +7,51 @@ import {
 
 const fragments: RuntimeConfigFragmentMap = new Map([
   [
-    'billing',
+    'checkout',
     {
       public: {
-        apiBase: '/api/billing',
+        successPath: '/orders/confirmed',
       },
       private: {
-        apiSecret: 'secret',
+        signingSecret: 'checkout_signing_secret_demo',
       },
       contexts: {
-        tenantA: {
+        'eu-store': {
           public: {
-            apiBase: '/tenant-a/billing',
+            successPath: '/eu-store/orders/confirmed',
           },
         },
       },
     },
   ],
   [
-    'mail',
+    'payments',
     {
       public: {
-        apiBase: '/api/mail',
+        configuredProvider: 'payment-provider-stripe',
       },
     },
   ],
 ]);
 
 const runtimeConfig = projectSectionedRuntimeConfig(fragments);
-const tenantApiBase = resolveRuntimeConfigValue(runtimeConfig.public, 'billing', 'apiBase', {
-  contextId: 'tenantA',
-});
+const euStoreSuccessPath = resolveRuntimeConfigValue(
+  runtimeConfig.public,
+  'checkout',
+  'successPath',
+  {
+    contextId: 'eu-store',
+  },
+);
 
-console.log(runtimeConfig.public.billingApiBase);
-// '/api/billing'
+console.log(runtimeConfig.public.checkoutSuccessPath);
+// '/orders/confirmed'
 
-console.log(runtimeConfig.private.billingApiSecret);
-// 'secret'
+console.log(runtimeConfig.private.checkoutSigningSecret);
+// 'checkout_signing_secret_demo'
 
-console.log(tenantApiBase);
-// '/tenant-a/billing'
+console.log(euStoreSuccessPath);
+// '/eu-store/orders/confirmed'
 
-console.log(getPublicRuntimeConfigScope(runtimeConfig, 'billing'));
-// { apiBase: '/api/billing' }
+console.log(getPublicRuntimeConfigScope(runtimeConfig, 'checkout'));
+// { successPath: '/orders/confirmed' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorion-org/runtime-config",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "Framework-free runtime-config types and merge helpers.",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,10 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "lorion-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
@@ -35,7 +39,9 @@
   "files": [
     "dist",
     "examples",
-    "LICENSE"
+    "LICENSE",
+    "src/**/*.ts",
+    "!src/**/*.spec.ts"
   ],
   "keywords": [
     "runtime-config",
@@ -46,6 +52,9 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
+  "dependencies": {
+    "ajv": "^8.17.1"
+  },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",
     "clean": "rimraf coverage dist tsconfig.tsbuildinfo",

package/src/env.ts

@@ -0,0 +1,91 @@
+import { toSnakeUpperCase } from './key';
+import {
+  projectSectionedRuntimeConfig,
+  type ProjectSectionedRuntimeConfigOptions,
+} from './project';
+import {
+  runtimeConfigVisibilities,
+  type ConfigVisibility,
+  type NamedRuntimeConfigFragment,
+  type RuntimeConfigFragmentMap,
+  type RuntimeEnvVars,
+  type SectionedRuntimeConfig,
+} from './types';
+
+export type ProjectRuntimeConfigEnvVarsOptions = ProjectSectionedRuntimeConfigOptions & {
+  prefix?: string;
+};
+
+export function createRuntimeConfigEnvKey(input: {
+  key: string;
+  prefix?: string;
+  scopeId?: string;
+  visibility?: ConfigVisibility;
+}): string {
+  return toSnakeUpperCase(
+    [input.prefix ?? 'APP', input.visibility, input.scopeId, input.key].filter(Boolean).join('_'),
+  );
+}
+
+export function toRuntimeEnvVars(
+  runtimeConfig: SectionedRuntimeConfig,
+  prefix = 'APP',
+): RuntimeEnvVars {
+  const envVars: RuntimeEnvVars = {};
+
+  for (const visibility of runtimeConfigVisibilities) {
+    for (const [key, value] of Object.entries(runtimeConfig[visibility])) {
+      if (key.startsWith('__')) continue;
+
+      envVars[createRuntimeConfigEnvKey({ prefix, visibility, key })] = value;
+    }
+  }
+
+  return envVars;
+}
+
+export function projectRuntimeConfigEnvVars(
+  fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap,
+  options: ProjectRuntimeConfigEnvVarsOptions = {},
+): RuntimeEnvVars {
+  const { prefix = 'APP', ...projectOptions } = options;
+
+  return toRuntimeEnvVars(
+    projectSectionedRuntimeConfig(fragments, {
+      ...projectOptions,
+      includeContexts: false,
+    }),
+    prefix,
+  );
+}
+
+export function injectRuntimeEnvVars(
+  envVars: RuntimeEnvVars,
+  processEnv: Record<string, unknown>,
+): RuntimeEnvVars {
+  const items: RuntimeEnvVars = {};
+
+  for (const key of Object.keys(envVars)) {
+    items[key] = processEnv[key] ?? envVars[key];
+  }
+
+  return items;
+}
+
+export function runtimeEnvVarsToString(envVars: RuntimeEnvVars): string {
+  return Object.entries(envVars)
+    .map(([key, value]) => `${key}=${String(value)}`)
+    .join('\n');
+}
+
+export function runtimeEnvValueToShellLiteral(value: unknown): string {
+  const json = JSON.stringify(value) ?? 'undefined';
+
+  return `'${json.replace(/'/g, "'\\''")}'`;
+}
+
+export function runtimeEnvVarsToShellAssignments(envVars: RuntimeEnvVars): string {
+  return Object.entries(envVars)
+    .map(([key, value]) => `${key}=${runtimeEnvValueToShellLiteral(value)}`)
+    .join('\n');
+}

package/src/fragment.ts

@@ -0,0 +1,28 @@
+import type {
+  RuntimeConfigContext,
+  RuntimeConfigFragment,
+  RuntimeConfigFragmentInput,
+} from './types';
+
+export type NormalizeRuntimeConfigFragmentOptions = {
+  contextInputKey?: string;
+};
+
+const isObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+export function toRuntimeConfigFragment(
+  config: RuntimeConfigFragmentInput,
+  options: NormalizeRuntimeConfigFragmentOptions = {},
+): RuntimeConfigFragment {
+  const contextInputKey = options.contextInputKey ?? 'contexts';
+  const contexts =
+    contextInputKey === 'contexts' ? config.contexts : (config.contexts ?? config[contextInputKey]);
+
+  return {
+    ...(isObject(config.public) ? { public: config.public } : {}),
+    ...(isObject(config.private) ? { private: config.private } : {}),
+    ...(isObject(contexts) ? { contexts: contexts as Record<string, RuntimeConfigContext> } : {}),
+  };
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './env';
+export * from './fragment';
+export * from './key';
+export * from './project';
+export * from './resolve';
+export * from './scope';
+export * from './types';
+export * from './validation';

package/src/key.ts

@@ -0,0 +1,54 @@
+export type RuntimeConfigKeyStrategy = (scopeId: string, key: string) => string;
+
+export type RuntimeConfigKeyOptions = {
+  keyStrategy?: RuntimeConfigKeyStrategy;
+};
+
+function upperFirst(input: string): string {
+  return input ? input[0]!.toUpperCase() + input.slice(1) : input;
+}
+
+function uncapitalize(input: string): string {
+  return input ? input[0]!.toLowerCase() + input.slice(1) : input;
+}
+
+function camelCase(input: string): string {
+  return input
+    .replace(/['\u2019]/g, '')
+    .split(/[^A-Za-z0-9]+|(?=[A-Z][a-z])/)
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => part.toLowerCase())
+    .map((part, index) => (index === 0 ? part : upperFirst(part)))
+    .join('');
+}
+
+export function createRuntimeConfigKey(
+  scopeId: string,
+  key: string,
+  options: RuntimeConfigKeyOptions = {},
+): string {
+  return options.keyStrategy?.(scopeId, key) ?? camelCase(`${scopeId} ${key}`);
+}
+
+export function stripRuntimeConfigScopePrefix(
+  scopeId: string,
+  configKey: string,
+  options: RuntimeConfigKeyOptions = {},
+): string | undefined {
+  const prefix = createRuntimeConfigKey(scopeId, '', options);
+  if (!prefix || !configKey.startsWith(prefix) || configKey.length <= prefix.length) {
+    return undefined;
+  }
+
+  return uncapitalize(configKey.slice(prefix.length));
+}
+
+export function toSnakeUpperCase(input: string): string {
+  return input
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^a-zA-Z0-9]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+    .toUpperCase();
+}