@magidoc/plugin-starter-variables 0.9.3 → 0.11.0

package/build/index.d.ts

@@ -1,6 +1,7 @@
 import templates from './variables/templates';
 import magidoc from './variables/magidoc';
 import type { Variable, ViteVariable } from './variables/variable';
+import type { Page } from './variables/templates';
 export { templates };
 export { magidoc };
-export type { Variable, ViteVariable };
+export type { Variable, ViteVariable, Page };

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

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

package/build/variables/converters/array.js

@@ -0,0 +1,22 @@
+function arrayConverter(valueType) {
+    return {
+        convert: (target) => {
+            if (Array.isArray(target)) {
+                return target;
+            }
+            if (typeof target === 'string') {
+                const result = JSON.parse(target);
+                if (!Array.isArray(result)) {
+                    return null;
+                }
+                return result;
+            }
+            return null;
+        },
+        asString: (value) => JSON.stringify(value),
+        type: (z) => z.array(valueType(z)).optional(),
+    };
+}
+
+export { arrayConverter };
+//# sourceMappingURL=array.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sources":["../../../../src/variables/converters/array.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEM,SAAU,cAAc,CAC5B,SAA6B,EAAA;IAE7B,OAAO;AACL,QAAA,OAAO,EAAE,CAAC,MAAM,KAAI;AAClB,YAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AACzB,gBAAA,OAAO,MAAkB,CAAA;AAC1B,aAAA;AAED,YAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;gBAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAsB,CAAA;AACtD,gBAAA,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AAC1B,oBAAA,OAAO,IAAI,CAAA;AACZ,iBAAA;AACD,gBAAA,OAAO,MAAM,CAAA;AACd,aAAA;AAED,YAAA,OAAO,IAAI,CAAA;SACZ;QACD,QAAQ,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC1C,QAAA,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;KAC9C,CAAA;AACH;;;;"}

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,5 @@
+import { stringConverter } from './string';
+import { booleanConverter } from './boolean';
+import { recordConverter } from './record';
+import { arrayConverter } from './array';
+export { stringConverter, booleanConverter, recordConverter, arrayConverter };

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,22 @@
+function recordConverter(valueType) {
+    return {
+        convert: (target) => {
+            if (typeof target === 'object') {
+                return target;
+            }
+            if (typeof target === 'string') {
+                const result = JSON.parse(target);
+                if (typeof result !== 'object') {
+                    return null;
+                }
+                return result;
+            }
+            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,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAsB,CAAA;AACtD,gBAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,oBAAA,OAAO,IAAI,CAAA;AACZ,iBAAA;AACD,gBAAA,OAAO,MAAM,CAAA;AACd,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,11 @@
+export declare type Page = {
+    title: string;
+    content: string | Page[];
+};
 declare const _default: {
     APP_LOGO: import("./variable").Variable<string>;
     APP_TITLE: import("./variable").Variable<string>;
+    QUERY_GENERATION_FACTORIES: import("./variable").Variable<Record<string, string | number | boolean | Record<string, unknown> | null | undefined>>;
+    PAGES: import("./variable").Variable<(Page | undefined)[]>;
 };
 export default _default;

package/build/variables/templates.js

@@ -1,8 +1,25 @@
-import { createVariable, stringConversion } from './variable.js';
+import { stringConverter } from './converters/string.js';
+import { recordConverter } from './converters/record.js';
+import { arrayConverter } from './converters/array.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.union([
+        zod.string(),
+        zod.boolean(),
+        zod.number(),
+        zod.null(),
+        zod.record(zod.unknown()),
+    ]))),
+    PAGES: createVariable('PAGES', arrayConverter((zod) => {
+        const type = zod.lazy(() => zod.object({
+            title: zod.string().nonempty(),
+            content: zod.union([zod.array(type), zod.string().nonempty()]),
+        }));
+        return type;
+    })),
 };
 
 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":";;;;;AASA,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,CAMxC,4BAA4B,EAC5B,eAAe,CAAC,CAAC,GAAG,KAClB,GAAG,CAAC,KAAK,CAAC;QACR,GAAG,CAAC,MAAM,EAAE;QACZ,GAAG,CAAC,OAAO,EAAE;QACb,GAAG,CAAC,MAAM,EAAE;QACZ,GAAG,CAAC,IAAI,EAAE;AACV,QAAA,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;AAC1B,KAAA,CAAC,CACH,CACF;IACD,KAAK,EAAE,cAAc,CACnB,OAAO,EACP,cAAc,CAAC,CAAC,GAAG,KAAI;AACrB,QAAA,MAAM,IAAI,GAAkB,GAAG,CAAC,IAAI,CAAC,MACnC,GAAG,CAAC,MAAM,CAAC;AACT,YAAA,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC9B,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC/D,SAAA,CAAC,CACH,CAAA;AACD,QAAA,OAAO,IAAI,CAAA;AACb,KAAC,CAAC,CACH;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.11.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/rollup.config.cjs

@@ -1,10 +1,10 @@
 const { defineConfig } = require('rollup')
 const typescript = require('@rollup/plugin-typescript')
-const shebang = require('rollup-plugin-preserve-shebang')
 
 module.exports = defineConfig({
   input: ['src/index.ts'],
   plugins: [typescript()],
+  external: ['zod'],
   output: {
     dir: 'build',
     format: 'esm',

package/src/index.ts

@@ -1,7 +1,8 @@
 import templates from './variables/templates'
 import magidoc from './variables/magidoc'
 import type { Variable, ViteVariable } from './variables/variable'
+import type { Page } from './variables/templates'
 
 export { templates }
 export { magidoc }
-export type { Variable, ViteVariable }
+export type { Variable, ViteVariable, Page }

package/src/variables/converters/array.ts

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

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,6 @@
+import { stringConverter } from './string'
+import { booleanConverter } from './boolean'
+import { recordConverter } from './record'
+import { arrayConverter } from './array'
+
+export { stringConverter, booleanConverter, recordConverter, arrayConverter }

package/src/variables/converters/record.ts

@@ -0,0 +1,25 @@
+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') {
+        const result = JSON.parse(target) as Record<string, V>
+        if (typeof result !== 'object') {
+          return null
+        }
+        return result
+      }
+
+      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,42 @@
-import { createVariable, stringConversion } from './variable'
+import type { ZodType } from 'zod'
+import { arrayConverter, recordConverter, stringConverter } from './converters'
+import { createVariable } from './variable'
+
+export type Page = {
+  title: string
+  content: string | Page[]
+}
 
 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,
+      string | boolean | number | Record<string, unknown> | null | undefined
+    >
+  >(
+    'QUERY_GENERATION_FACTORIES',
+    recordConverter((zod) =>
+      zod.union([
+        zod.string(),
+        zod.boolean(),
+        zod.number(),
+        zod.null(),
+        zod.record(zod.unknown()),
+      ]),
+    ),
+  ),
+  PAGES: createVariable<Array<Page | undefined>>(
+    'PAGES',
+    arrayConverter((zod) => {
+      const type: ZodType<Page> = zod.lazy(() =>
+        zod.object({
+          title: zod.string().nonempty(),
+          content: zod.union([zod.array(type), zod.string().nonempty()]),
+        }),
+      )
+      return type
+    }),
+  ),
 }

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,29 +1,96 @@
+import type { ZodType } from 'zod'
 import * as variables from '../src/index'
 import type { Variable } from '../src/variables/variable'
+import z from 'zod'
+import type { Page } from '../src/index'
 
 describe('variables', () => {
   it('contains the right number of export keys', () => {
     expect(Object.keys(variables)).toEqual(['templates', 'magidoc'])
   })
 
-  it('contains the right templates variables', () => {
-    expect(Object.keys(variables.templates)).toEqual(['APP_LOGO', 'APP_TITLE'])
+  describe('template variables', () => {
+    it('contains the right templates variables', () => {
+      expect(Object.keys(variables.templates)).toEqual([
+        'APP_LOGO',
+        'APP_TITLE',
+        'QUERY_GENERATION_FACTORIES',
+        'PAGES',
+      ])
+    })
 
-    testStringVariable(variables.templates.APP_TITLE, 'VITE_APP_TITLE')
-    testStringVariable(variables.templates.APP_LOGO, 'VITE_APP_LOGO')
+    test('app title', () => {
+      testStringVariable(
+        variables.templates.APP_TITLE,
+        'VITE_APP_TITLE',
+        z.string().optional(),
+      )
+    })
+
+    test('app logo', () => {
+      testStringVariable(
+        variables.templates.APP_LOGO,
+        'VITE_APP_LOGO',
+        z.string().optional(),
+      )
+    })
+
+    test('query generation factories', () => {
+      testRecordVariable(
+        variables.templates.QUERY_GENERATION_FACTORIES,
+        'VITE_QUERY_GENERATION_FACTORIES',
+        z
+          .record(
+            z
+              .union([
+                z.string(),
+                z.boolean(),
+                z.number(),
+                z.null(),
+                z.record(z.unknown()),
+              ])
+              .optional(),
+          )
+          .optional(),
+      )
+    })
+
+    test('pages', () => {
+      const pagesType: ZodType<Page> = z.lazy(() =>
+        z.object({
+          title: z.string(),
+          content: z.union([z.array(pagesType), z.string()]),
+        }),
+      )
+
+      testArrayVariable(
+        variables.templates.PAGES,
+        'VITE_PAGES',
+        z.array(pagesType).optional(),
+      )
+    })
   })
 
-  it('contains the right magidoc variables', () => {
-    expect(Object.keys(variables.magidoc)).toEqual(['MAGIDOC_GENERATE'])
+  describe('magidoc variables', () => {
+    it('contains the right magidoc variables', () => {
+      expect(Object.keys(variables.magidoc)).toEqual(['MAGIDOC_GENERATE'])
+    })
 
-    testBooleanVariable(
-      variables.magidoc.MAGIDOC_GENERATE,
-      'VITE_MAGIDOC_GENERATE',
-    )
+    test('magidoc generate', () => {
+      testBooleanVariable(
+        variables.magidoc.MAGIDOC_GENERATE,
+        'VITE_MAGIDOC_GENERATE',
+        z.boolean().optional(),
+      )
+    })
   })
 })
 
-function testStringVariable(target: Variable<string>, viteKey: string) {
+function testStringVariable(
+  target: Variable<string>,
+  viteKey: string,
+  expectedZod: ZodType<any>,
+) {
   expect(target.vite.key).toEqual(viteKey)
 
   expect(target.vite.get({ [viteKey]: 'Potato' })).toBe('Potato')
@@ -37,9 +104,17 @@ function testStringVariable(target: Variable<string>, viteKey: string) {
     'false',
   )
   expect(target.vite.getOrDefault({}, 'Default')).toBe('Default')
+
+  expect(target.asEnv('Potato')).toEqual({ [viteKey]: 'Potato' })
+
+  ensureZodTypeEqual(target, expectedZod)
 }
 
-function testBooleanVariable(target: Variable<boolean>, viteKey: string) {
+function testBooleanVariable(
+  target: Variable<boolean>,
+  viteKey: string,
+  expectedZod: ZodType<any>,
+) {
   expect(target.vite.key).toEqual(viteKey)
 
   expect(target.vite.get({ [viteKey]: true })).toBe(true)
@@ -61,4 +136,88 @@ 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' })
+
+  ensureZodTypeEqual(target, expectedZod)
+}
+
+function testRecordVariable(
+  target: Variable<Record<string, any>>,
+  viteKey: string,
+  expectedZod: ZodType<any>,
+) {
+  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]: '{}' })
+
+  ensureZodTypeEqual(target, expectedZod)
+}
+
+function testArrayVariable(
+  target: Variable<Array<any>>,
+  viteKey: string,
+  expectedZod: ZodType<any>,
+) {
+  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]: {} })).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]: '[]' })
+
+  ensureZodTypeEqual(target, expectedZod)
+}
+
+function ensureZodTypeEqual(target: Variable<any>, expected: ZodType<any>) {
+  // @ts-ignore
+  // this does a good enough compare to make sure they have the same schema
+  expect(JSON.parse(JSON.stringify(target.zod.type(z)))).toEqual(
+    JSON.parse(JSON.stringify(expected, null, 2)),
+  )
 }