zcb 0.2.5 → 0.2.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zcb",
   "description": "Build configs with type safety from zod schema.",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "author": "Dylan Aubrey",
   "license": "MIT",
   "homepage": "https://github.com/badbatch/zod-config-builder",

package/src/__testUtils__/builtConfig.ts

@@ -68,6 +68,7 @@ export default {
       path: "contact-details"
     }
   ],
+  templateString: 'Simple {{name}} met a {{profession}} going to the fair',
   timeouts: {
     apollo: 10000
   },

package/src/createConfigReader.test.ts

@@ -17,6 +17,34 @@ describe('createConfigReader', () => {
     });
   });
 
+  describe('when vars options are passed in', () => {
+    const vars = {
+      name: 'Simon',
+      profession: 'pieman',
+    };
+
+    describe('when a user accesses a property that is not a string', () => {
+      it('should throw the correct error', () => {
+        const reader = createReader();
+
+        // @ts-expect-error path does not resovle to a string
+        expect(() => reader.read('pages.contactDetails', { vars })).toThrow(
+          new Error(
+            'config reader received variables to use in string template, but the path did not resolve to a string.'
+          )
+        );
+      });
+    });
+
+    describe('when a user accesses a property that is a string', () => {
+      it('should return the correct string value with template placeholders populated', () => {
+        const reader = createReader();
+        const value = reader.read('templateString', { vars });
+        expect(value).toBe('Simple Simon met a pieman going to the fair');
+      });
+    });
+  });
+
   describe('when the reader is scoped', () => {
     describe('when a user accesses a known property', () => {
       it('should return the correct value', () => {

package/src/createConfigReader.ts

@@ -1,15 +1,35 @@
-import { get } from 'lodash-es';
+import { get, isString } from 'lodash-es';
 import { type Get } from 'type-fest';
 import { type Path, type Scope } from './types.ts';
 
+export type ReadOptions = {
+  vars?: Record<string, string | number>;
+};
+
 export interface ConfigReader<Config extends object> {
-  read: <P extends Path<Config>>(path: P) => Get<Config, P>;
+  read: <P extends Path<Config>>(path: P, options?: ReadOptions) => Get<Config, P>;
   scope: <S extends Scope<Config>>(scope: S) => ConfigReader<Get<Config, S>>;
 }
 
 export const createConfigReader = <Config extends object>(config: Config): ConfigReader<Config> => {
   const configReader = {
-    read: <P extends Path<Config>>(path: P) => get(config, path),
+    read: <P extends Path<Config>>(path: P, { vars }: ReadOptions = {}) => {
+      if (!vars) {
+        return get(config, path);
+      }
+
+      const output = get(config, path);
+
+      if (!isString(output)) {
+        throw new Error(
+          'config reader received variables to use in string template, but the path did not resolve to a string.'
+        );
+      }
+
+      return Object.keys(vars).reduce<string>((acc, key) => {
+        return acc.replace(new RegExp(`{{${key}}}`), String(vars[key]));
+      }, output);
+    },
     scope: <S extends Scope<Config>>(scope: S) => createConfigReader(get(config, scope) as Get<Config, S>),
   } as ConfigReader<Config>;