refactor: Generator parts from interfaces into zod objects

package.json

@@ -73,6 +73,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-router-dom": "^6.24.0",
+    "zod": "^3.23.8",
     "zustand": "^4.5.3"
   },
   "lint-staged": {

src/codegen/codegen.test.ts

@@ -4,7 +4,8 @@ import {
   generateRequestSnippets,
   generateVariableDeclarations,
 } from './codegen'
-import { TestRule, CorrelationStateMap } from '@/types/rules'
+import { CorrelationStateMap } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 import { generateSequentialInt } from '@/rules/utils'
 import { ProxyData } from '@/types'
 import { correlationRecording } from '@/test/fixtures/correlationRecording'

src/codegen/codegen.ts

@@ -1,5 +1,6 @@
 import { GroupedProxyData, ProxyData, RequestSnippetSchema } from '@/types'
-import { TestRule, CorrelationStateMap } from '@/types/rules'
+import { CorrelationStateMap } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 import { applyRule } from '@/rules/rules'
 import { generateSequentialInt } from '@/rules/utils'
 

src/hooks/useGeneratorStore/fixtures.ts

@@ -1,4 +1,4 @@
-import { TestRule } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 
 export const rules: TestRule[] = [
   {

src/hooks/useGeneratorStore/slices/rules.ts

@@ -1,4 +1,4 @@
-import { TestRule } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 import { ImmerStateCreator } from '@/utils/typescript'
 import { rules } from '../fixtures'
 

src/hooks/useGeneratorStore/slices/testData.ts

@@ -1,15 +1,11 @@
 import { ImmerStateCreator } from '@/utils/typescript'
-import { Variable } from '@/types'
-
-interface State {
-  variables: Variable[]
-}
+import { Variable, TestData } from '@/schemas/testData'
 
 interface Actions {
   setVariables: (variables: Variable[]) => void
 }
 
-export type TestDataStore = State & Actions
+export type TestDataStore = TestData & Actions
 
 export const createTestDataSlice: ImmerStateCreator<TestDataStore> = (set) => ({
   variables: [],

src/hooks/useGeneratorStore/slices/testOptions/loadProfile.ts

@@ -3,7 +3,7 @@ import {
   RampingStage,
   RampingVUsOptions,
   SharedIterationsOptions,
-} from '@/types/testOptions'
+} from '@/schemas/testOptions'
 import { ImmerStateCreator } from '@/utils/typescript'
 
 interface SharedIterationsState

src/hooks/useGeneratorStore/slices/testOptions/thinkTime.ts

@@ -1,5 +1,5 @@
 import { ImmerStateCreator } from '@/utils/typescript'
-import { SleepType, ThinkTime, Timing } from '@/types/testOptions'
+import { SleepType, ThinkTime, Timing } from '@/schemas/testOptions'
 import { createFixedTiming } from '@/utils/thinkTime'
 
 interface Actions {

src/main.ts

@@ -234,12 +234,38 @@ ipcMain.on('generator:save', async (event, generatorFile: string) => {
   await writeFile(dialogResult.filePath, generatorFile)
 })
 
+ipcMain.handle('generator:open', async (event) => {
+  console.info('generator:open event received')
+  const browserWindow = browserWindowFromEvent(event)
+
+  const dialogResult = await dialog.showOpenDialog(browserWindow, {
+    message: 'Open Generator file',
+    properties: ['openFile'],
+    filters: [{ name: 'JSON', extensions: ['json'] }],
+  })
+
+  if (!dialogResult.canceled && dialogResult.filePaths[0]) {
+    const fileHandle = await open(dialogResult.filePaths[0], 'r')
+    try {
+      const data = await fileHandle?.readFile({ encoding: 'utf-8' })
+      // TODO: we might want to send an error on wrong file, a system to send and show errors from the main process
+      // could be levereged for many things mmmm
+      const generator = await JSON.parse(data)
+
+      return { path: dialogResult.filePaths[0], content: generator }
+    } finally {
+      await fileHandle?.close()
+    }
+  }
+
+  return
+})
+
 // Settings
 ipcMain.on('settings:toggle-theme', () => {
   nativeTheme.themeSource = nativeTheme.shouldUseDarkColors ? 'light' : 'dark'
 })
 
-
 const browserWindowFromEvent = (
   event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent
 ) => {

src/preload.ts

@@ -4,6 +4,7 @@
 import { ipcRenderer, contextBridge, IpcRendererEvent } from 'electron'
 import { ProxyData, K6Log } from './types'
 import { HarFile } from './types/har'
+import { GeneratorFile } from './types/generator'
 
 // Create listener and return clean up function to be used in useEffect
 function createListener<T>(channel: string, callback: (data: T) => void) {
@@ -79,6 +80,9 @@ const generator = {
   saveGenerator: (generatorFile: string) => {
     ipcRenderer.send('generator:save', generatorFile)
   },
+  loadGenerator: (): Promise<GeneratorFile | void> => {
+    return ipcRenderer.invoke('generator:open')
+  },
 } as const
 
 const studio = {

src/rules/correlation.ts

@@ -1,5 +1,6 @@
 import { ProxyData, RequestSnippetSchema, Response, Request } from '@/types'
-import { CorrelationRule, CorrelationStateMap } from '@/types/rules'
+import { CorrelationStateMap } from '@/types/rules'
+import { CorrelationRule } from '@/schemas/rules'
 import { cloneDeep, get, isEqual } from 'lodash-es'
 import { canonicalHeaderKey, matchFilter } from './utils'
 import { getHeaderValues } from '@/utils/headers'

src/rules/correlation.utils.ts

@@ -1,4 +1,4 @@
-import { CorrelationRule } from '@/types/rules'
+import { CorrelationRule } from '@/schemas/rules'
 import { Header, Request } from '@/types'
 
 export function safeJsonParse(value: string) {

src/rules/customCode.ts

@@ -1,5 +1,5 @@
 import { RequestSnippetSchema } from '@/types'
-import { CustomCodeRule } from '@/types/rules'
+import { CustomCodeRule } from '@/schemas/rules'
 import { matchFilter } from './utils'
 
 export function applyCustomCodeRule(

src/rules/rules.ts

@@ -1,6 +1,7 @@
 /* eslint-disable  @typescript-eslint/no-non-null-assertion */
 import { RequestSnippetSchema } from '@/types'
-import { TestRule, CorrelationStateMap } from '@/types/rules'
+import { CorrelationStateMap } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 import { exhaustive } from '../utils/typescript'
 import { applyCustomCodeRule } from './customCode'
 import { applyCorrelationRule } from './correlation'

src/rules/utils.ts

@@ -1,4 +1,4 @@
-import { TestRule } from '@/types/rules'
+import { TestRule } from '@/schemas/rules'
 import { RequestSnippetSchema } from '@/types'
 import { exhaustive } from '@/utils/typescript'
 

src/schemas/generator.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+import { TestRule } from '@/schemas/rules'
+import { TestData } from '@/schemas/testData'
+import { TestOptions } from '@/schemas/testOptions'
+
+export const GeneratorFileData = z.object({
+  name: z.string(),
+  version: z.string(),
+  recordingPath: z.string(),
+  options: TestOptions,
+  testData: TestData,
+  rules: TestRule.array(),
+  allowlist: z.string().array(),
+})
+
+export type GeneratorFileData = z.infer<typeof GeneratorFileData>

src/schemas/rules.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod'
+
+export const VariableValue = z.object({
+  type: z.literal('variable'),
+  variableName: z.string(),
+})
+
+export const ArrayValue = z.object({
+  type: z.literal('array'),
+  arrayName: z.string(),
+})
+
+export const CustomCodeValue = z.object({
+  type: z.literal('customCode'),
+  getValue: z
+    .function()
+    .returns(z.union([z.string(), z.number(), z.null(), z.void()])),
+})
+
+export const RecordedValue = z.object({
+  type: z.literal('recordedValue'),
+})
+
+export const Filter = z.object({
+  path: z.string(),
+})
+
+export const BeginEndSelector = z.object({
+  type: z.literal('begin-end'),
+  from: z.enum(['headers', 'body', 'url']),
+  begin: z.string(),
+  end: z.string(),
+})
+
+export const RegexSelector = z.object({
+  type: z.literal('regex'),
+  from: z.enum(['headers', 'body', 'url']),
+  regex: z.string(),
+})
+
+export const JsonSelector = z.object({
+  type: z.literal('json'),
+  from: z.literal('body'),
+  path: z.string(),
+})
+
+export const CustomCodeSelector = z.object({
+  type: z.literal('custom-code'),
+  snippet: z.string(),
+})
+
+export const Selector = z.discriminatedUnion('type', [
+  BeginEndSelector,
+  RegexSelector,
+  JsonSelector,
+])
+
+export const CorrelationExtractor = z.object({
+  filter: Filter,
+  selector: Selector,
+  variableName: z.string().optional(),
+})
+
+export const CorrelationReplacer = z.object({
+  filter: Filter,
+  selector: Selector,
+})
+
+export const RuleBase = z.object({
+  id: z.string(),
+})
+
+export const ParameterizationRule = RuleBase.extend({
+  type: z.literal('parameterization'),
+  filter: Filter,
+  selector: Selector,
+  value: z.discriminatedUnion('type', [
+    VariableValue,
+    ArrayValue,
+    CustomCodeValue,
+  ]),
+})
+
+export const CorrelationRule = RuleBase.extend({
+  type: z.literal('correlation'),
+  extractor: CorrelationExtractor,
+  replacer: CorrelationReplacer.optional(),
+})
+
+export const VerificationRule = RuleBase.extend({
+  type: z.literal('verification'),
+  filter: Filter,
+  selector: Selector,
+  value: z.discriminatedUnion('type', [
+    VariableValue,
+    ArrayValue,
+    CustomCodeValue,
+    RecordedValue,
+  ]),
+})
+
+export const CustomCodeRule = RuleBase.extend({
+  type: z.literal('customCode'),
+  filter: Filter,
+  placement: z.enum(['before', 'after']),
+  snippet: z.string(),
+})
+
+export const TestRule = z.discriminatedUnion('type', [
+  ParameterizationRule,
+  CorrelationRule,
+  VerificationRule,
+  CustomCodeRule,
+])
+
+export type VariableValue = z.infer<typeof VariableValue>
+export type ArrayValue = z.infer<typeof ArrayValue>
+export type CustomCodeValue = z.infer<typeof CustomCodeValue>
+export type RecordedValue = z.infer<typeof RecordedValue>
+export type Filter = z.infer<typeof Filter>
+export type BeginEndSelector = z.infer<typeof BeginEndSelector>
+export type RegexSelector = z.infer<typeof RegexSelector>
+export type JsonSelector = z.infer<typeof JsonSelector>
+export type CustomCodeSelector = z.infer<typeof CustomCodeSelector>
+export type Selector = z.infer<typeof Selector>
+export type CorrelationExtractor = z.infer<typeof CorrelationExtractor>
+export type CorrelationReplacer = z.infer<typeof CorrelationReplacer>
+export type RuleBase = z.infer<typeof RuleBase>
+export type ParameterizationRule = z.infer<typeof ParameterizationRule>
+export type CorrelationRule = z.infer<typeof CorrelationRule>
+export type VerificationRule = z.infer<typeof VerificationRule>
+export type CustomCodeRule = z.infer<typeof CustomCodeRule>
+export type TestRule = z.infer<typeof TestRule>

src/schemas/testData.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+export const Variable = z.object({
+  name: z.string(),
+  value: z.string(),
+})
+
+export const TestData = z.object({
+  variables: Variable.array(),
+})
+
+export type Variable = z.infer<typeof Variable>
+export type TestData = z.infer<typeof TestData>