@magidoc/plugin-starter-variables 0.10.0 → 0.11.1

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/index.d.ts

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

package/build/variables/converters/record.js

@@ -5,16 +5,11 @@ function recordConverter(valueType) {
                 return target;
             }
             if (typeof target === 'string') {
-                try {
-                    const result = JSON.parse(target);
-                    if (typeof result !== 'object') {
-                        return null;
-                    }
-                    return result;
-                }
-                catch {
+                const result = JSON.parse(target);
+                if (typeof result !== 'object') {
                     return null;
                 }
+                return result;
             }
             return null;
         },

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

@@ -1 +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;;;;"}
+{"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/templates.d.ts

@@ -1,6 +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, unknown>>;
+    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,11 +1,25 @@
 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', stringConverter()),
     APP_TITLE: createVariable('APP_TITLE', stringConverter()),
-    QUERY_GENERATION_FACTORIES: createVariable('QUERY_GENERATION_FACTORIES', recordConverter((zod) => zod.unknown())),
+    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":";;;;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;;;;"}
+{"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/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.10.0",
+  "version": "0.11.1",
   "type": "module",
   "license": "MIT",
   "main": "./build/index.js",

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/index.ts

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

package/src/variables/converters/record.ts

@@ -10,15 +10,11 @@ export function recordConverter<V>(
       }
 
       if (typeof target === 'string') {
-        try {
-          const result = JSON.parse(target) as Record<string, V>
-          if (typeof result !== 'object') {
-            return null
-          }
-          return result
-        } catch {
+        const result = JSON.parse(target) as Record<string, V>
+        if (typeof result !== 'object') {
           return null
         }
+        return result
       }
 
       return null

package/src/variables/templates.ts

@@ -1,11 +1,42 @@
-import { recordConverter, stringConverter } from './converters'
+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', stringConverter()),
   APP_TITLE: createVariable<string>('APP_TITLE', stringConverter()),
-  QUERY_GENERATION_FACTORIES: createVariable<Record<string, unknown>>(
+  QUERY_GENERATION_FACTORIES: createVariable<
+    Record<
+      string,
+      string | boolean | number | Record<string, unknown> | null | undefined
+    >
+  >(
     'QUERY_GENERATION_FACTORIES',
-    recordConverter((zod) => zod.unknown()),
+    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/tests/index.spec.ts

@@ -1,38 +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',
-      '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',
-    )
+  describe('template variables', () => {
+    it('contains the right templates variables', () => {
+      expect(Object.keys(variables.templates)).toEqual([
+        'APP_LOGO',
+        'APP_TITLE',
+        'QUERY_GENERATION_FACTORIES',
+        'PAGES',
+      ])
+    })
+
+    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'])
-
-    testBooleanVariable(
-      variables.magidoc.MAGIDOC_GENERATE,
-      'VITE_MAGIDOC_GENERATE',
-    )
+  describe('magidoc variables', () => {
+    it('contains the right magidoc variables', () => {
+      expect(Object.keys(variables.magidoc)).toEqual(['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')
@@ -48,9 +106,15 @@ function testStringVariable(target: Variable<string>, viteKey: string) {
   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)
@@ -75,11 +139,14 @@ function testBooleanVariable(target: Variable<boolean>, viteKey: string) {
 
   expect(target.asEnv(true)).toEqual({ [viteKey]: 'true' })
   expect(target.asEnv(false)).toEqual({ [viteKey]: 'false' })
+
+  ensureZodTypeEqual(target, expectedZod)
 }
 
 function testRecordVariable(
-  target: Variable<Record<string, unknown>>,
+  target: Variable<Record<string, any>>,
   viteKey: string,
+  expectedZod: ZodType<any>,
 ) {
   expect(target.vite.key).toEqual(viteKey)
 
@@ -103,4 +170,54 @@ function testRecordVariable(
     [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)),
+  )
 }