@magidoc/plugin-starter-variables 0.9.3 → 0.10.0

package/build/variables/converters/boolean.d.ts

@@ -0,0 +1,2 @@
+import type { Converter } from '../variable';
+export declare function booleanConverter(): Converter<boolean>;

package/build/variables/converters/boolean.js

@@ -0,0 +1,26 @@
+function booleanConverter() {
+    return {
+        convert: (target) => {
+            if (target === null)
+                return null;
+            if (target === undefined)
+                return null;
+            switch (typeof target) {
+                case 'boolean':
+                    return target;
+                case 'string':
+                    const lowerCase = target.toLowerCase().trim();
+                    return lowerCase === 'true' || lowerCase === 't' || lowerCase === '1';
+                case 'number':
+                    return target !== 0;
+                default:
+                    return null;
+            }
+        },
+        asString: (value) => String(value),
+        type: (z) => z.boolean().optional(),
+    };
+}
+
+export { booleanConverter };
+//# sourceMappingURL=boolean.js.map

package/build/variables/converters/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sources":["../../../../src/variables/converters/boolean.ts"],"sourcesContent":[null],"names":[],"mappings":"SAEgB,gBAAgB,GAAA;IAC9B,OAAO;AACL,QAAA,OAAO,EAAE,CAAC,MAAe,KAAoB;YAC3C,IAAI,MAAM,KAAK,IAAI;AAAE,gBAAA,OAAO,IAAI,CAAA;YAChC,IAAI,MAAM,KAAK,SAAS;AAAE,gBAAA,OAAO,IAAI,CAAA;YAErC,QAAQ,OAAO,MAAM;AACnB,gBAAA,KAAK,SAAS;AACZ,oBAAA,OAAO,MAAM,CAAA;AACf,gBAAA,KAAK,QAAQ;oBACX,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAA;oBAC7C,OAAO,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,GAAG,IAAI,SAAS,KAAK,GAAG,CAAA;AACvE,gBAAA,KAAK,QAAQ;oBACX,OAAO,MAAM,KAAK,CAAC,CAAA;AACrB,gBAAA;AACE,oBAAA,OAAO,IAAI,CAAA;AACd,aAAA;SACF;QACD,QAAQ,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC;AAClC,QAAA,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KACpC,CAAA;AACH;;;;"}

package/build/variables/converters/index.d.ts

@@ -0,0 +1,4 @@
+import { stringConverter } from './string';
+import { booleanConverter } from './boolean';
+import { recordConverter } from './record';
+export { stringConverter, booleanConverter, recordConverter };

package/build/variables/converters/record.d.ts

@@ -0,0 +1,2 @@
+import type { Converter, ZodTypeProvider } from '../variable';
+export declare function recordConverter<V>(valueType: ZodTypeProvider<V>): Converter<Record<string, V | undefined>>;

package/build/variables/converters/record.js

@@ -0,0 +1,27 @@
+function recordConverter(valueType) {
+    return {
+        convert: (target) => {
+            if (typeof target === 'object') {
+                return target;
+            }
+            if (typeof target === 'string') {
+                try {
+                    const result = JSON.parse(target);
+                    if (typeof result !== 'object') {
+                        return null;
+                    }
+                    return result;
+                }
+                catch {
+                    return null;
+                }
+            }
+            return null;
+        },
+        asString: (value) => JSON.stringify(value),
+        type: (z) => z.record(valueType(z).optional()).optional(),
+    };
+}
+
+export { recordConverter };
+//# sourceMappingURL=record.js.map

package/build/variables/converters/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","sources":["../../../../src/variables/converters/record.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEM,SAAU,eAAe,CAC7B,SAA6B,EAAA;IAE7B,OAAO;AACL,QAAA,OAAO,EAAE,CAAC,MAAM,KAAI;AAClB,YAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,gBAAA,OAAO,MAA2B,CAAA;AACnC,aAAA;AAED,YAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;gBAC9B,IAAI;oBACF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAsB,CAAA;AACtD,oBAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,wBAAA,OAAO,IAAI,CAAA;AACZ,qBAAA;AACD,oBAAA,OAAO,MAAM,CAAA;AACd,iBAAA;gBAAC,MAAM;AACN,oBAAA,OAAO,IAAI,CAAA;AACZ,iBAAA;AACF,aAAA;AAED,YAAA,OAAO,IAAI,CAAA;SACZ;QACD,QAAQ,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;QAC1C,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;KAC1D,CAAA;AACH;;;;"}

package/build/variables/converters/string.d.ts

@@ -0,0 +1,2 @@
+import type { Converter } from '../variable';
+export declare function stringConverter(): Converter<string>;

package/build/variables/converters/string.js

@@ -0,0 +1,15 @@
+function stringConverter() {
+    return {
+        convert: (target) => {
+            if (target === null || target === undefined || target === '') {
+                return null;
+            }
+            return String(target);
+        },
+        asString: (value) => String(value),
+        type: (z) => z.string().optional(),
+    };
+}
+
+export { stringConverter };
+//# sourceMappingURL=string.js.map

package/build/variables/converters/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sources":["../../../../src/variables/converters/string.ts"],"sourcesContent":[null],"names":[],"mappings":"SAEgB,eAAe,GAAA;IAC7B,OAAO;AACL,QAAA,OAAO,EAAE,CAAC,MAAe,KAAmB;YAC1C,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,EAAE,EAAE;AAC5D,gBAAA,OAAO,IAAI,CAAA;AACZ,aAAA;AAED,YAAA,OAAO,MAAM,CAAC,MAAM,CAAC,CAAA;SACtB;QACD,QAAQ,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC;AAClC,QAAA,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACnC,CAAA;AACH;;;;"}

package/build/variables/magidoc.js

@@ -1,7 +1,8 @@
-import { createVariable, booleanConversion } from './variable.js';
+import { booleanConverter } from './converters/boolean.js';
+import { createVariable } from './variable.js';
 
 var magidoc = {
-    MAGIDOC_GENERATE: createVariable('MAGIDOC_GENERATE', booleanConversion()),
+    MAGIDOC_GENERATE: createVariable('MAGIDOC_GENERATE', booleanConverter()),
 };
 
 export { magidoc as default };

package/build/variables/magidoc.js.map

@@ -1 +1 @@
-{"version":3,"file":"magidoc.js","sources":["../../../src/variables/magidoc.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA,cAAe;AACb,IAAA,gBAAgB,EAAE,cAAc,CAC9B,kBAAkB,EAClB,iBAAiB,EAAE,CACpB;CACF;;;;"}
+{"version":3,"file":"magidoc.js","sources":["../../../src/variables/magidoc.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA,cAAe;AACb,IAAA,gBAAgB,EAAE,cAAc,CAC9B,kBAAkB,EAClB,gBAAgB,EAAE,CACnB;CACF;;;;"}

package/build/variables/templates.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     APP_LOGO: import("./variable").Variable<string>;
     APP_TITLE: import("./variable").Variable<string>;
+    QUERY_GENERATION_FACTORIES: import("./variable").Variable<Record<string, unknown>>;
 };
 export default _default;

package/build/variables/templates.js

@@ -1,8 +1,11 @@
-import { createVariable, stringConversion } from './variable.js';
+import { stringConverter } from './converters/string.js';
+import { recordConverter } from './converters/record.js';
+import { createVariable } from './variable.js';
 
 var templates = {
-    APP_LOGO: createVariable('APP_LOGO', stringConversion()),
-    APP_TITLE: createVariable('APP_TITLE', stringConversion()),
+    APP_LOGO: createVariable('APP_LOGO', stringConverter()),
+    APP_TITLE: createVariable('APP_TITLE', stringConverter()),
+    QUERY_GENERATION_FACTORIES: createVariable('QUERY_GENERATION_FACTORIES', recordConverter((zod) => zod.unknown())),
 };
 
 export { templates as default };

package/build/variables/templates.js.map

@@ -1 +1 @@
-{"version":3,"file":"templates.js","sources":["../../../src/variables/templates.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA,gBAAe;AACb,IAAA,QAAQ,EAAE,cAAc,CAAS,UAAU,EAAE,gBAAgB,EAAE,CAAC;AAChE,IAAA,SAAS,EAAE,cAAc,CAAS,WAAW,EAAE,gBAAgB,EAAE,CAAC;CACnE;;;;"}
+{"version":3,"file":"templates.js","sources":["../../../src/variables/templates.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA,gBAAe;AACb,IAAA,QAAQ,EAAE,cAAc,CAAS,UAAU,EAAE,eAAe,EAAE,CAAC;AAC/D,IAAA,SAAS,EAAE,cAAc,CAAS,WAAW,EAAE,eAAe,EAAE,CAAC;AACjE,IAAA,0BAA0B,EAAE,cAAc,CACxC,4BAA4B,EAC5B,eAAe,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC,CACxC;CACF;;;;"}

package/build/variables/variable.d.ts

@@ -1,3 +1,4 @@
+import type { ZodType, ZodTypeDef } from 'zod';
 /**
  * Copy of the ViteJS import meta interface
  */
@@ -5,15 +6,24 @@ interface MetaEnv {
     [key: string]: unknown;
 }
 export declare type Variable<T> = {
-    names: string[];
+    name: string;
+    asEnv: (value: T) => Record<string, string>;
+    zod: ZodVariable<T>;
     vite: ViteVariable<T>;
 };
+export declare type ZodTypeProvider<T> = (zod: typeof import('zod')) => ZodType<T | undefined, ZodTypeDef, T | undefined>;
+export declare type ZodVariable<T> = {
+    type: ZodTypeProvider<T>;
+};
+export declare type Converter<T> = {
+    convert: (target: unknown) => T | null;
+    asString: (value: T) => string;
+    type: ZodTypeProvider<T>;
+};
 export declare type ViteVariable<T> = {
     key: string;
     get: (env: MetaEnv) => T | null;
     getOrDefault: (env: MetaEnv, def: T) => T;
 };
-export declare function createVariable<T = string | boolean>(key: string, conversion: (target: unknown) => T | null): Variable<T>;
-export declare function stringConversion(): (target: unknown) => string | null;
-export declare function booleanConversion(): (target: unknown) => boolean | null;
+export declare function createVariable<T>(key: string, converter: Converter<T>): Variable<T>;
 export {};

package/build/variables/variable.js

@@ -1,8 +1,12 @@
-function createVariable(key, conversion) {
+function createVariable(key, converter) {
     const viteKey = `VITE_${key.toUpperCase()}`;
-    const viteGet = (env) => conversion(env[viteKey]);
+    const viteGet = (env) => converter.convert(env[viteKey]);
     return {
-        names: [key, toCamelCase(key)],
+        name: toCamelCase(key),
+        asEnv: (value) => ({ [viteKey]: converter.asString(value) }),
+        zod: {
+            type: converter.type,
+        },
         vite: {
             key: viteKey,
             get: viteGet,
@@ -15,33 +19,6 @@ function toCamelCase(key) {
         return $1.toUpperCase().replace('-', '').replace('_', '');
     });
 }
-function stringConversion() {
-    return (target) => {
-        if (target === null || target === undefined || target === '') {
-            return null;
-        }
-        return String(target);
-    };
-}
-function booleanConversion() {
-    return (target) => {
-        if (target === null)
-            return null;
-        if (target === undefined)
-            return null;
-        switch (typeof target) {
-            case 'boolean':
-                return target;
-            case 'string':
-                const lowerCase = target.toLowerCase().trim();
-                return lowerCase === 'true' || lowerCase === 't' || lowerCase === '1';
-            case 'number':
-                return target !== 0;
-            default:
-                return null;
-        }
-    };
-}
 
-export { booleanConversion, createVariable, stringConversion };
+export { createVariable };
 //# sourceMappingURL=variable.js.map

package/build/variables/variable.js.map

@@ -1 +1 @@
-{"version":3,"file":"variable.js","sources":["../../../src/variables/variable.ts"],"sourcesContent":[null],"names":[],"mappings":"AAkBgB,SAAA,cAAc,CAC5B,GAAW,EACX,UAAyC,EAAA;IAEzC,MAAM,OAAO,GAAG,CAAQ,KAAA,EAAA,GAAG,CAAC,WAAW,EAAE,EAAE,CAAA;AAC3C,IAAA,MAAM,OAAO,GAAG,CAAC,GAAY,KAAK,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAE1D,OAAO;QACL,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;AAC9B,QAAA,IAAI,EAAE;AACJ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG;AAChD,SAAA;KACF,CAAA;AACH,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAA;AAC9B,IAAA,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,EAAE,KAAI;AACvD,QAAA,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3D,KAAC,CAAC,CAAA;AACJ,CAAC;SAEe,gBAAgB,GAAA;IAC9B,OAAO,CAAC,MAAe,KAAmB;QACxC,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,EAAE,EAAE;AAC5D,YAAA,OAAO,IAAI,CAAA;AACZ,SAAA;AAED,QAAA,OAAO,MAAM,CAAC,MAAM,CAAC,CAAA;AACvB,KAAC,CAAA;AACH,CAAC;SAEe,iBAAiB,GAAA;IAC/B,OAAO,CAAC,MAAe,KAAoB;QACzC,IAAI,MAAM,KAAK,IAAI;AAAE,YAAA,OAAO,IAAI,CAAA;QAChC,IAAI,MAAM,KAAK,SAAS;AAAE,YAAA,OAAO,IAAI,CAAA;QAErC,QAAQ,OAAO,MAAM;AACnB,YAAA,KAAK,SAAS;AACZ,gBAAA,OAAO,MAAM,CAAA;AACf,YAAA,KAAK,QAAQ;gBACX,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAA;gBAC7C,OAAO,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,GAAG,IAAI,SAAS,KAAK,GAAG,CAAA;AACvE,YAAA,KAAK,QAAQ;gBACX,OAAO,MAAM,KAAK,CAAC,CAAA;AACrB,YAAA;AACE,gBAAA,OAAO,IAAI,CAAA;AACd,SAAA;AACH,KAAC,CAAA;AACH;;;;"}
+{"version":3,"file":"variable.js","sources":["../../../src/variables/variable.ts"],"sourcesContent":[null],"names":[],"mappings":"AAoCgB,SAAA,cAAc,CAC5B,GAAW,EACX,SAAuB,EAAA;IAEvB,MAAM,OAAO,GAAG,CAAQ,KAAA,EAAA,GAAG,CAAC,WAAW,EAAE,EAAE,CAAA;AAC3C,IAAA,MAAM,OAAO,GAAG,CAAC,GAAY,KAAK,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAEjE,OAAO;AACL,QAAA,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC;AACtB,QAAA,KAAK,EAAE,CAAC,KAAQ,MAAM,EAAE,CAAC,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AAC/D,QAAA,GAAG,EAAE;YACH,IAAI,EAAE,SAAS,CAAC,IAAI;AACrB,SAAA;AACD,QAAA,IAAI,EAAE;AACJ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG;AAChD,SAAA;KACF,CAAA;AACH,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAA;AAC9B,IAAA,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,EAAE,KAAI;AACvD,QAAA,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3D,KAAC,CAAC,CAAA;AACJ;;;;"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@magidoc/plugin-starter-variables",
   "description": "A shared library that contains common Magidoc starter environment variables keys.",
   "private": false,
-  "version": "0.9.3",
+  "version": "0.10.0",
   "type": "module",
   "license": "MIT",
   "main": "./build/index.js",
@@ -20,6 +20,9 @@
     "tslib": "^2.4.0",
     "typescript": "^4.6.3"
   },
+  "optionalDependencies": {
+    "zod": "^3.14.4"
+  },
   "scripts": {
     "start": "pnpm build:rollup && node build/index.js",
     "build": "run-p build:*",

package/src/variables/converters/boolean.ts

@@ -0,0 +1,24 @@
+import type { Converter } from '../variable'
+
+export function booleanConverter(): Converter<boolean> {
+  return {
+    convert: (target: unknown): boolean | null => {
+      if (target === null) return null
+      if (target === undefined) return null
+
+      switch (typeof target) {
+        case 'boolean':
+          return target
+        case 'string':
+          const lowerCase = target.toLowerCase().trim()
+          return lowerCase === 'true' || lowerCase === 't' || lowerCase === '1'
+        case 'number':
+          return target !== 0
+        default:
+          return null
+      }
+    },
+    asString: (value) => String(value),
+    type: (z) => z.boolean().optional(),
+  }
+}

package/src/variables/converters/index.ts

@@ -0,0 +1,5 @@
+import { stringConverter } from './string'
+import { booleanConverter } from './boolean'
+import { recordConverter } from './record'
+
+export { stringConverter, booleanConverter, recordConverter }

package/src/variables/converters/record.ts

@@ -0,0 +1,29 @@
+import type { Converter, ZodTypeProvider } from '../variable'
+
+export function recordConverter<V>(
+  valueType: ZodTypeProvider<V>,
+): Converter<Record<string, V | undefined>> {
+  return {
+    convert: (target) => {
+      if (typeof target === 'object') {
+        return target as Record<string, V>
+      }
+
+      if (typeof target === 'string') {
+        try {
+          const result = JSON.parse(target) as Record<string, V>
+          if (typeof result !== 'object') {
+            return null
+          }
+          return result
+        } catch {
+          return null
+        }
+      }
+
+      return null
+    },
+    asString: (value) => JSON.stringify(value),
+    type: (z) => z.record(valueType(z).optional()).optional(),
+  }
+}

package/src/variables/converters/string.ts

@@ -0,0 +1,15 @@
+import type { Converter } from '../variable'
+
+export function stringConverter(): Converter<string> {
+  return {
+    convert: (target: unknown): string | null => {
+      if (target === null || target === undefined || target === '') {
+        return null
+      }
+
+      return String(target)
+    },
+    asString: (value) => String(value),
+    type: (z) => z.string().optional(),
+  }
+}

package/src/variables/magidoc.ts

@@ -1,8 +1,9 @@
-import { booleanConversion, createVariable } from './variable'
+import { booleanConverter } from './converters'
+import { createVariable } from './variable'
 
 export default {
   MAGIDOC_GENERATE: createVariable<boolean>(
     'MAGIDOC_GENERATE',
-    booleanConversion(),
+    booleanConverter(),
   ),
 }

package/src/variables/templates.ts

@@ -1,6 +1,11 @@
-import { createVariable, stringConversion } from './variable'
+import { recordConverter, stringConverter } from './converters'
+import { createVariable } from './variable'
 
 export default {
-  APP_LOGO: createVariable<string>('APP_LOGO', stringConversion()),
-  APP_TITLE: createVariable<string>('APP_TITLE', stringConversion()),
+  APP_LOGO: createVariable<string>('APP_LOGO', stringConverter()),
+  APP_TITLE: createVariable<string>('APP_TITLE', stringConverter()),
+  QUERY_GENERATION_FACTORIES: createVariable<Record<string, unknown>>(
+    'QUERY_GENERATION_FACTORIES',
+    recordConverter((zod) => zod.unknown()),
+  ),
 }

package/src/variables/variable.ts

@@ -1,3 +1,5 @@
+import type { ZodType, ZodTypeDef } from 'zod'
+
 /**
  * Copy of the ViteJS import meta interface
  */
@@ -6,25 +8,45 @@ interface MetaEnv {
 }
 
 export type Variable<T> = {
-  names: string[]
+  name: string
+  asEnv: (value: T) => Record<string, string>
+  zod: ZodVariable<T>
   vite: ViteVariable<T>
 }
 
+export type ZodTypeProvider<T> = (
+  zod: typeof import('zod'),
+) => ZodType<T | undefined, ZodTypeDef, T | undefined>
+
+export type ZodVariable<T> = {
+  type: ZodTypeProvider<T>
+}
+
+export type Converter<T> = {
+  convert: (target: unknown) => T | null
+  asString: (value: T) => string
+  type: ZodTypeProvider<T>
+}
+
 export type ViteVariable<T> = {
   key: string
   get: (env: MetaEnv) => T | null
   getOrDefault: (env: MetaEnv, def: T) => T
 }
 
-export function createVariable<T = string | boolean>(
+export function createVariable<T>(
   key: string,
-  conversion: (target: unknown) => T | null,
+  converter: Converter<T>,
 ): Variable<T> {
   const viteKey = `VITE_${key.toUpperCase()}`
-  const viteGet = (env: MetaEnv) => conversion(env[viteKey])
+  const viteGet = (env: MetaEnv) => converter.convert(env[viteKey])
 
   return {
-    names: [key, toCamelCase(key)],
+    name: toCamelCase(key),
+    asEnv: (value: T) => ({ [viteKey]: converter.asString(value) }),
+    zod: {
+      type: converter.type,
+    },
     vite: {
       key: viteKey,
       get: viteGet,
@@ -38,32 +60,3 @@ function toCamelCase(key: string): string {
     return $1.toUpperCase().replace('-', '').replace('_', '')
   })
 }
-
-export function stringConversion() {
-  return (target: unknown): string | null => {
-    if (target === null || target === undefined || target === '') {
-      return null
-    }
-
-    return String(target)
-  }
-}
-
-export function booleanConversion() {
-  return (target: unknown): boolean | null => {
-    if (target === null) return null
-    if (target === undefined) return null
-
-    switch (typeof target) {
-      case 'boolean':
-        return target
-      case 'string':
-        const lowerCase = target.toLowerCase().trim()
-        return lowerCase === 'true' || lowerCase === 't' || lowerCase === '1'
-      case 'number':
-        return target !== 0
-      default:
-        return null
-    }
-  }
-}

package/tests/index.spec.ts

@@ -1,5 +1,6 @@
 import * as variables from '../src/index'
 import type { Variable } from '../src/variables/variable'
+import z from 'zod'
 
 describe('variables', () => {
   it('contains the right number of export keys', () => {
@@ -7,10 +8,18 @@ describe('variables', () => {
   })
 
   it('contains the right templates variables', () => {
-    expect(Object.keys(variables.templates)).toEqual(['APP_LOGO', 'APP_TITLE'])
+    expect(Object.keys(variables.templates)).toEqual([
+      'APP_LOGO',
+      'APP_TITLE',
+      'QUERY_GENERATION_FACTORIES',
+    ])
 
     testStringVariable(variables.templates.APP_TITLE, 'VITE_APP_TITLE')
     testStringVariable(variables.templates.APP_LOGO, 'VITE_APP_LOGO')
+    testRecordVariable(
+      variables.templates.QUERY_GENERATION_FACTORIES,
+      'VITE_QUERY_GENERATION_FACTORIES',
+    )
   })
 
   it('contains the right magidoc variables', () => {
@@ -37,6 +46,8 @@ function testStringVariable(target: Variable<string>, viteKey: string) {
     'false',
   )
   expect(target.vite.getOrDefault({}, 'Default')).toBe('Default')
+
+  expect(target.asEnv('Potato')).toEqual({ [viteKey]: 'Potato' })
 }
 
 function testBooleanVariable(target: Variable<boolean>, viteKey: string) {
@@ -61,4 +72,35 @@ function testBooleanVariable(target: Variable<boolean>, viteKey: string) {
   expect(target.vite.getOrDefault({ [viteKey]: false }, true)).toBe(false)
   expect(target.vite.getOrDefault({ [viteKey]: {} }, true)).toBe(true)
   expect(target.vite.getOrDefault({}, true)).toBe(true)
+
+  expect(target.asEnv(true)).toEqual({ [viteKey]: 'true' })
+  expect(target.asEnv(false)).toEqual({ [viteKey]: 'false' })
+}
+
+function testRecordVariable(
+  target: Variable<Record<string, unknown>>,
+  viteKey: string,
+) {
+  expect(target.vite.key).toEqual(viteKey)
+
+  expect(target.vite.get({ [viteKey]: true })).toBeNull()
+  expect(target.vite.get({ [viteKey]: 'true' })).toBeNull()
+  expect(target.vite.get({ [viteKey]: '4234' })).toBeNull()
+  expect(target.vite.get({ [viteKey]: 4234 })).toBeNull()
+
+  expect(target.vite.get({ [viteKey]: { abc: '123' } })).toEqual({ abc: '123' })
+  expect(
+    target.vite.get({ [viteKey]: JSON.stringify({ abc: '123' }) }),
+  ).toEqual({ abc: '123' })
+
+  expect(target.vite.getOrDefault({ [viteKey]: false }, { abc: 123 })).toEqual({
+    abc: 123,
+  })
+  expect(target.vite.getOrDefault({ [viteKey]: {} }, { abc: 123 })).toEqual({})
+  expect(target.vite.getOrDefault({}, { abc: 123 })).toEqual({ abc: 123 })
+
+  expect(target.asEnv({ abc: 123 })).toEqual({
+    [viteKey]: JSON.stringify({ abc: 123 }),
+  })
+  expect(target.asEnv({})).toEqual({ [viteKey]: '{}' })
 }