Use zod for defining template manifest types

package.json

@@ -39,7 +39,8 @@
     "resolve-bin": "^0.4.0",
     "rimraf": "^2.6.3",
     "rxjs": "^6.4.0",
-    "yargs": "^13.2.2"
+    "yargs": "^13.2.2",
+    "zod": "^1.7.0"
   },
   "devDependencies": {
     "eslint": "^5.15.1",
@@ -52,6 +53,7 @@
     "jest": "^24.8.0",
     "prettier": "^2.0.5",
     "prettier-eslint-cli": "^4.7.1",
+    "ts-jest": "^26.1.0",
     "typescript": "^3.9.3"
   }
 }

src/manifest/v1/manifest.ts

@@ -1,37 +1,41 @@
-import {NetlifyDeployment} from './netlify'
-import {VercelDeployment} from './vercel'
-
-export interface TemplateTechnology {
-  id: string
-  name: string
-  url: string
-}
-
-export interface TemplateImageMedia {
-  type: 'image'
-  alt: string
-  src: string
-}
-
-export interface TokenSpec {
-  role: 'deploy-studio' | 'read' | 'write'
-  label: string
-}
-
-export type SupportedDeploymentProvider = VercelDeployment | NetlifyDeployment
-
-export type TemplateMedia = TemplateImageMedia
-
-export interface TemplateManifest {
-  version: 1
-  title: string
-  description: string
-  previewMedia?: TemplateMedia
-  deployment?: SupportedDeploymentProvider
-  technologies?: TemplateTechnology[]
-}
-
-export interface SanityCorsOrigin {
-  origin: string
-  allowCredentials: boolean
-}
+import * as z from 'zod'
+
+import {netlifyDeployment} from './netlify'
+import {vercelDeployment} from './vercel'
+
+export const templateTechnology = z.object({id: z.string(), name: z.string(), url: z.string()})
+export const templateImageMedia = z.object({
+  type: z.literal('image'),
+  alt: z.string(),
+  src: z.string(),
+})
+export type TemplateImageMedia = z.infer<typeof templateImageMedia>
+
+// just keep as an alias for now
+export const templateMedia = templateImageMedia
+export type TemplateMedia = z.infer<typeof templateMedia>
+
+export const tokenSpec = z.object({
+  role: z.union([z.literal('deploy-studio'), z.literal('read'), z.literal('write')]),
+  label: z.string(),
+})
+export type TokenSpec = z.infer<typeof tokenSpec>
+
+export const supportedDeploymentProvider = z.union([netlifyDeployment, vercelDeployment])
+export type SupportedDeploymentProvider = z.infer<typeof supportedDeploymentProvider>
+
+export type TemplateTechnology = z.infer<typeof templateTechnology>
+
+export const templateManifest = z.object({
+  version: z.literal(1),
+  title: z.string(),
+  description: z.string(),
+  previewMedia: templateMedia.optional(),
+  deployment: supportedDeploymentProvider.optional(),
+  technologies: z.array(templateTechnology).optional(),
+})
+
+export type TemplateManifest = z.infer<typeof templateManifest>
+
+export const sanityCorsOrigin = z.object({origin: z.string(), allowCredentials: z.boolean()})
+export type SanityCorsOrigin = z.infer<typeof sanityCorsOrigin>

src/manifest/v1/netlify.ts

@@ -1,24 +1,29 @@
-import {SanityCorsOrigin, TemplateMedia, TokenSpec} from './manifest'
+import * as z from 'zod'
 
-export type ProviderRequirement = 'build-hook' // Add future requirement flags here
+import {sanityCorsOrigin, templateMedia, tokenSpec} from './manifest'
 
-export interface NetlifyDeployment {
-  provider: 'netlify'
-  sites: NetlifySite[]
-}
+export const providerRequirement = z.literal('build-hook') // Add future requirement flags here
+export type ProviderRequirement = z.infer<typeof providerRequirement>
 
-interface NetlifySite {
-  id: string
-  title: string
-  description: string
-  dir: string
-  buildSettings: {
-    base: string
-    dir: string
-    cmd: string
-  }
-  requiredTokens?: TokenSpec[]
-  requirements?: ProviderRequirement[]
-  previewMedia?: TemplateMedia
-  requiredCorsOrigins?: SanityCorsOrigin[]
-}
+const netlifySite = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  dir: z.string(),
+  buildSettings: z.object({
+    base: z.string(),
+    dir: z.string(),
+    cmd: z.string(),
+  }),
+  requiredTokens: z.array(tokenSpec).optional(),
+  requirements: z.array(providerRequirement).optional(),
+  previewMedia: templateMedia.optional(),
+  requiredCorsOrigins: z.array(sanityCorsOrigin).optional(),
+})
+export type NetlifySite = z.infer<typeof netlifySite>
+
+export const netlifyDeployment = z.object({
+  provider: z.literal('netlify'),
+  sites: z.array(netlifySite),
+})
+export type NetlifyDeployment = z.infer<typeof netlifyDeployment>

src/manifest/v1/vercel.ts

@@ -1,3 +1,3 @@
-export interface VercelDeployment {
-  provider: 'vercel'
-}
+import * as z from 'zod'
+export const vercelDeployment = z.object({provider: z.literal('vercel')})
+export type VercelDeployment = z.infer<typeof vercelDeployment>