feat: handle default option values with zod

core/create/src/prompts/options.ts

@@ -144,6 +144,11 @@ export interface OptionsParams {
   configPath: string
 }
 
+type ZodPartial = z.ZodOptional<z.ZodTypeAny> | z.ZodDefault<z.ZodTypeAny>
+
+const isPartialOptional = (partial: ZodPartial): partial is z.ZodOptional<z.ZodTypeAny> =>
+  typeof (partial as z.ZodOptional<z.ZodTypeAny>).unwrap === 'function'
+
 export default async ({ logger, config, toolKitConfig, configPath }: OptionsParams): Promise<boolean> => {
   for (const plugin of Object.keys(config.plugins)) {
     let options: z.AnyZodObject
@@ -163,9 +168,9 @@ export default async ({ logger, config, toolKitConfig, configPath }: OptionsPara
       continue
     }
 
-    const [optional, required] = partition<[string, z.ZodTypeAny], [string, z.ZodOptional<z.ZodTypeAny>]>(
+    const [partial, required] = partition<[string, z.ZodTypeAny], [string, ZodPartial]>(
       Object.entries(options.shape),
-      (schema): schema is [string, z.ZodOptionalType<z.ZodTypeAny>] => schema[1].isOptional()
+      (schema): schema is [string, ZodPartial] => schema[1].isOptional()
     )
     const anyRequired = required.length > 0
 
@@ -196,7 +201,7 @@ export default async ({ logger, config, toolKitConfig, configPath }: OptionsPara
       }
     }
 
-    if (optional.length > 0) {
+    if (partial.length > 0) {
       const { confirm } = await prompt({
         name: 'confirm',
         type: 'confirm',
@@ -211,7 +216,10 @@ export default async ({ logger, config, toolKitConfig, configPath }: OptionsPara
         await optionsPromptForPlugin(
           toolKitConfig,
           plugin,
-          optional.map(([name, optionType]) => [name, optionType.unwrap()])
+          partial.map(([name, partialType]) => [
+            name,
+            isPartialOptional(partialType) ? partialType.unwrap() : partialType.removeDefault()
+          ])
         )
       } else if (!anyRequired) {
         delete toolKitConfig.options[plugin]

lib/types/src/index.ts

@@ -148,15 +148,14 @@ export abstract class Task<O extends z.ZodTypeAny = z.ZodTypeAny> extends Base {
     return taskSymbol
   }
 
-  static defaultOptions: Record<string, unknown> = {}
-  options: z.infer<O>
+  options: z.output<O>
   logger: Logger
 
-  constructor(logger: Logger, options: Partial<z.infer<O>> = {}) {
+  constructor(logger: Logger, options: z.output<O>) {
     super()
 
     const staticThis = this.constructor as typeof Task
-    this.options = Object.assign({}, staticThis.defaultOptions as z.infer<O>, options)
+    this.options = options
     this.logger = logger.child({ task: staticThis.id })
   }
 

lib/types/src/schema.ts

@@ -11,7 +11,7 @@ export type PromptGenerators<T> = T extends z.ZodObject<infer Shape>
   ? {
       [option in keyof Shape as Shape[option] extends z.ZodType
         ? option
-        : never]?: Shape[option] extends z.ZodType ? SchemaPromptGenerator<z.infer<Shape[option]>> : never
+        : never]?: Shape[option] extends z.ZodType ? SchemaPromptGenerator<z.output<Shape[option]>> : never
     }
   : never
 

lib/types/src/schema/eslint.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
 export const ESLintSchema = z.object({
-  files: z.string().array(),
+  files: z.string().array().default(['**/*.js']),
   config: z.record(z.unknown()).optional(), // @deprecated: use options instead
   options: z.record(z.unknown()).optional()
 })

lib/types/src/schema/mocha.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
 export const MochaSchema = z.object({
-  files: z.string(),
+  files: z.string().default('test/**/*.js'),
   configPath: z.string().optional()
 })
 export type MochaOptions = z.infer<typeof MochaSchema>

lib/types/src/schema/node.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod'
 
 export const NodeSchema = z.object({
-  entry: z.string().optional(),
+  entry: z.string().default('./server/app.js'),
   args: z.string().array().optional(),
-  useVault: z.boolean().optional(),
-  ports: z.number().array().optional()
+  useVault: z.boolean().default(true),
+  ports: z.number().array().default([3001, 3002, 3003])
 })
 export type NodeOptions = z.infer<typeof NodeSchema>
 

lib/types/src/schema/nodemon.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod'
 
 export const NodemonSchema = z.object({
-  entry: z.string().optional(),
+  entry: z.string().default('./server/app.js'),
   configPath: z.string().optional(),
-  useVault: z.boolean().optional(),
-  ports: z.number().array().optional()
+  useVault: z.boolean().default(true),
+  ports: z.number().array().default([3001, 3002, 3003])
 })
 export type NodemonOptions = z.infer<typeof NodemonSchema>
 

lib/types/src/schema/prettier.ts

@@ -1,10 +1,16 @@
 import { z } from 'zod'
 
 export const PrettierSchema = z.object({
-  files: z.string().array(),
+  files: z.string().array().default(['**/*.{js,jsx,ts,tsx}']),
   configFile: z.string().optional(),
-  ignoreFile: z.string().optional(),
-  configOptions: z.record(z.unknown())
+  ignoreFile: z.string().default('.prettierignore'),
+  configOptions: z.record(z.unknown()).default({
+    singleQuote: true,
+    useTabs: true,
+    bracketSpacing: true,
+    arrowParens: 'always',
+    trailingComma: 'none'
+  })
 })
 export type PrettierOptions = z.infer<typeof PrettierSchema>
 

lib/types/src/schema/serverless.ts

@@ -2,8 +2,8 @@ import { z } from 'zod'
 
 export const ServerlessSchema = z.object({
   configPath: z.string().optional(),
-  useVault: z.boolean().optional(),
-  ports: z.number().array().optional()
+  useVault: z.boolean().default(true),
+  ports: z.number().array().default([3001, 3002, 3003])
 })
 export type ServerlessOptions = z.infer<typeof ServerlessSchema>
 

lib/types/src/schema/upload-assets-to-s3.ts

@@ -3,15 +3,15 @@ import { z } from 'zod'
 export const UploadAssetsToS3Schema = z.object({
   accessKeyIdEnvVar: z.string().optional(),
   secretAccessKeyEnvVar: z.string().optional(),
-  accessKeyId: z.string().optional(), // @deprecated: use accessKeyIdEnvVar instead
-  secretAccessKey: z.string().optional(), // @deprecated: use secretAccessKeyEnvVar instead
-  directory: z.string(),
-  reviewBucket: z.string().array(),
-  prodBucket: z.string().array(),
-  region: z.string(),
-  destination: z.string(),
-  extensions: z.string(),
-  cacheControl: z.string()
+  accessKeyId: z.string().default('aws_access_hashed_assets'), // @deprecated: use accessKeyIdEnvVar instead
+  secretAccessKey: z.string().default('aws_secret_hashed_assets'), // @deprecated: use secretAccessKeyEnvVar instead
+  directory: z.string().default('public'),
+  reviewBucket: z.string().array().default(['ft-next-hashed-assets-preview']),
+  prodBucket: z.string().array().default(['ft-next-hashed-assets-prod']),
+  region: z.string().default('eu-west-1'),
+  destination: z.string().default('hashed-assets/page-kit'),
+  extensions: z.string().default('js,css,map,gz,br,png,jpg,jpeg,gif,webp,svg,ico,json'),
+  cacheControl: z.string().default('public, max-age=31536000, stale-while-revalidate=60, stale-if-error=3600')
 })
 export type UploadAssetsToS3Options = z.infer<typeof UploadAssetsToS3Schema>
 

plugins/eslint/src/tasks/eslint.ts

@@ -1,16 +1,12 @@
 import { ToolKitError } from '@dotcom-tool-kit/error'
 import { styles } from '@dotcom-tool-kit/logger'
 import { Task } from '@dotcom-tool-kit/types'
-import { ESLintOptions, ESLintSchema } from '@dotcom-tool-kit/types/lib/schema/eslint'
+import { ESLintSchema } from '@dotcom-tool-kit/types/lib/schema/eslint'
 import { ESLint } from 'eslint'
 
 export default class Eslint extends Task<typeof ESLintSchema> {
   static description = ''
 
-  static defaultOptions: ESLintOptions = {
-    files: ['**/*.js']
-  }
-
   async run(files?: string[]): Promise<void> {
     const eslint = new ESLint(this.options.options)
     const results = await eslint.lintFiles(files ?? this.options.files)

plugins/mocha/src/tasks/mocha.ts

@@ -1,18 +1,14 @@
 import { hookFork, waitOnExit } from '@dotcom-tool-kit/logger'
 import { Task } from '@dotcom-tool-kit/types'
 import { glob } from 'glob'
-import { MochaOptions, MochaSchema } from '@dotcom-tool-kit/types/lib/schema/mocha'
+import { MochaSchema } from '@dotcom-tool-kit/types/lib/schema/mocha'
 import { fork } from 'child_process'
 import { promisify } from 'util'
 const mochaCLIPath = require.resolve('mocha/bin/mocha')
 
 export default class Mocha extends Task<typeof MochaSchema> {
   static description = ''
 
-  static defaultOptions: MochaOptions = {
-    files: 'test/**/*.js'
-  }
-
   async run(): Promise<void> {
     const files = await promisify(glob)(this.options.files)
 

plugins/node/src/tasks/node.ts

@@ -1,5 +1,5 @@
 import { Task } from '@dotcom-tool-kit/types'
-import { NodeOptions, NodeSchema } from '@dotcom-tool-kit/types/lib/schema/node'
+import { NodeSchema } from '@dotcom-tool-kit/types/lib/schema/node'
 import { ToolKitError } from '@dotcom-tool-kit/error'
 import { fork } from 'child_process'
 import { VaultEnvVars } from '@dotcom-tool-kit/vault'
@@ -11,12 +11,6 @@ import waitPort from 'wait-port'
 export default class Node extends Task<typeof NodeSchema> {
   static description = ''
 
-  static defaultOptions: NodeOptions = {
-    entry: './server/app.js',
-    useVault: true,
-    ports: [3001, 3002, 3003]
-  }
-
   async run(): Promise<void> {
     const { entry, args, useVault, ports } = this.options
 

plugins/nodemon/src/tasks/nodemon.ts

@@ -1,7 +1,7 @@
 import { ToolKitError } from '@dotcom-tool-kit/error'
 import { hookFork, styles } from '@dotcom-tool-kit/logger'
 import { Task } from '@dotcom-tool-kit/types'
-import { NodemonOptions, NodemonSchema } from '@dotcom-tool-kit/types/lib/schema/nodemon'
+import { NodemonSchema } from '@dotcom-tool-kit/types/lib/schema/nodemon'
 import { writeState } from '@dotcom-tool-kit/state'
 import { VaultEnvVars } from '@dotcom-tool-kit/vault'
 import getPort from 'get-port'
@@ -11,12 +11,6 @@ import { Readable } from 'stream'
 export default class Nodemon extends Task<typeof NodemonSchema> {
   static description = ''
 
-  static defaultOptions: NodemonOptions = {
-    entry: './server/app.js',
-    useVault: true,
-    ports: [3001, 3002, 3003]
-  }
-
   async run(): Promise<void> {
     const { entry, configPath, useVault, ports } = this.options
 

plugins/prettier/src/tasks/prettier.ts

@@ -9,18 +9,6 @@ import { ToolKitError } from '@dotcom-tool-kit/error'
 export default class Prettier extends Task<typeof PrettierSchema> {
   static description = ''
 
-  static defaultOptions: PrettierOptions = {
-    files: ['**/*.{js,jsx,ts,tsx}'],
-    ignoreFile: '.prettierignore',
-    configOptions: {
-      singleQuote: true,
-      useTabs: true,
-      bracketSpacing: true,
-      arrowParens: 'always',
-      trailingComma: 'none'
-    }
-  }
-
   async run(files?: string[]): Promise<void> {
     try {
       const filepaths = await fg(files ?? this.options.files)

plugins/serverless/src/tasks/run.ts

@@ -1,5 +1,5 @@
 import { Task } from '@dotcom-tool-kit/types'
-import { ServerlessOptions, ServerlessSchema } from '@dotcom-tool-kit/types/lib/schema/serverless'
+import { ServerlessSchema } from '@dotcom-tool-kit/types/lib/schema/serverless'
 import { spawn } from 'child_process'
 import { VaultEnvVars } from '@dotcom-tool-kit/vault'
 import { hookConsole, hookFork } from '@dotcom-tool-kit/logger'
@@ -9,11 +9,6 @@ import waitPort from 'wait-port'
 export default class ServerlessRun extends Task<typeof ServerlessSchema> {
   static description = 'Run serverless functions locally'
 
-  static defaultOptions: ServerlessOptions = {
-    useVault: true,
-    ports: [3001, 3002, 3003]
-  }
-
   async run(): Promise<void> {
     const { useVault, ports, configPath } = this.options
 

plugins/upload-assets-to-s3/src/tasks/upload-assets-to-s3.ts

@@ -14,18 +14,6 @@ import {
 export default class UploadAssetsToS3 extends Task<typeof UploadAssetsToS3Schema> {
   static description = ''
 
-  static defaultOptions: UploadAssetsToS3Options = {
-    accessKeyId: 'aws_access_hashed_assets',
-    secretAccessKey: 'aws_secret_hashed_assets',
-    directory: 'public',
-    reviewBucket: ['ft-next-hashed-assets-preview'],
-    prodBucket: ['ft-next-hashed-assets-prod'],
-    region: 'eu-west-1',
-    destination: 'hashed-assets/page-kit',
-    extensions: 'js,css,map,gz,br,png,jpg,jpeg,gif,webp,svg,ico,json',
-    cacheControl: 'public, max-age=31536000, stale-while-revalidate=60, stale-if-error=3600'
-  }
-
   async run(): Promise<void> {
     await this.uploadAssetsToS3(this.options)
   }
@@ -94,10 +82,10 @@ export default class UploadAssetsToS3 extends Task<typeof UploadAssetsToS3Schema
       credentials: {
         accessKeyId:
           /* eslint-disable-next-line */
-          process.env[options.accessKeyIdEnvVar ?? options.accessKeyId!]!,
+          process.env[options.accessKeyIdEnvVar ?? options.accessKeyId]!,
         secretAccessKey:
           /* eslint-disable-next-line */
-          process.env[options.secretAccessKeyEnvVar ?? options.secretAccessKey!]!
+          process.env[options.secretAccessKeyEnvVar ?? options.secretAccessKey]!
       }
     })