@teleporthq/teleport-plugin-next-workflows 0.45.13 → 0.45.15

package/__tests__/global-state-read-only-wiring.test.ts

@@ -0,0 +1,257 @@
+// A workflow reads a global state through the state values its file hands the
+// workflow runtime, and a global state is among them only when the file takes
+// it from `useGlobalState()`. A file whose workflows only READ a global state
+// used to get none of that, so the read was undefined: a timer in a component,
+// gated on a global on/off switch that a page flips, never ticked.
+
+import generate from '@babel/generator'
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+import { buildStateGetHandlerSource } from '../src/nodes/state/_state-get'
+
+const GLOBAL_STATES = {
+  TQ_switch: { id: 'TQ_switch', name: 'tickerTimerEnabled', type: 'boolean', defaultValue: true },
+}
+
+const COMPONENT = { componentId: 'TQ_ticker', componentName: 'Ticker' }
+
+const node = (id: string, type: string, config: Record<string, unknown>) => ({
+  id,
+  type,
+  config,
+  stepNumber: 1,
+  label: id,
+})
+
+const UPDATE_COUNT = node('bump', 'state-update-local-state', { property: 'count', value: 1 })
+
+const timerWorkflow = (
+  nodes: Array<ReturnType<typeof node>>,
+  trigger: Record<string, unknown> = { scope: 'component', config: COMPONENT }
+) => ({
+  id: 'wf-ticker',
+  name: 'Ticker Count Update',
+  trigger: {
+    type: 'event-interval',
+    nodeId: 'tick',
+    scope: trigger.scope,
+    config: { intervalMs: 1000, autoStart: true, ...(trigger.config as object) },
+  },
+  nodes,
+  edges: nodes.map((target, index) => ({
+    id: `e${index}`,
+    source: index === 0 ? 'tick' : nodes[index - 1].id,
+    target: target.id,
+  })),
+})
+
+const jsxComponentChunk = () => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        id: { type: 'Identifier', name: 'Ticker' },
+        init: {
+          type: 'ArrowFunctionExpression',
+          params: [] as unknown[],
+          body: {
+            type: 'BlockStatement',
+            body: [{ type: 'ReturnStatement', argument: null as unknown }],
+            directives: [] as unknown[],
+          },
+        },
+      },
+    ],
+  },
+})
+
+interface Generated {
+  component: string
+  module: string
+  dependencies: Record<string, { path?: string }>
+}
+
+const generateFile = async (params: {
+  workflow: any
+  isPage: boolean
+  globalStateDefinitions?: Record<string, unknown>
+  customNodes?: Record<string, unknown>
+}): Promise<Generated> => {
+  const { workflow, isPage, globalStateDefinitions = GLOBAL_STATES, customNodes = {} } = params
+  const plugin = createNextWorkflowPlugin({ isPage })
+  const structure: any = {
+    uidl: {
+      name: isPage ? 'Home' : 'Ticker',
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: { count: { type: 'number', defaultValue: 0 } },
+      ...(isPage ? { outputOptions: { pageId: 'page-1', fileName: 'index' } } : {}),
+    },
+    chunks: [jsxComponentChunk()],
+    options: {
+      workflows: { workflows: { [workflow.id]: workflow }, customNodes },
+      globalStateDefinitions,
+    },
+    dependencies: {},
+  }
+  await plugin(structure)
+  const componentChunk = structure.chunks.find((c: any) => c.name === 'jsx-component')
+  const moduleChunk = structure.chunks.find((c: any) => c.name === 'workflow-module')
+  return {
+    component: generate(componentChunk.content).code,
+    module: moduleChunk ? String(moduleChunk.content) : '',
+    dependencies: structure.dependencies,
+  }
+}
+
+const HOOK =
+  /const \{\s*tickerTimerEnabled,\s*setTickerTimerEnabled,\s*refreshGlobalState\s*\} = useGlobalState\(\)/
+const VALUE_IN_REF =
+  /__wfStateRef\.current = \{\s*count: count,\s*tickerTimerEnabled: tickerTimerEnabled\s*\}/
+
+const expectGlobalStateWired = (file: Generated) => {
+  expect(file.dependencies.useGlobalState).toEqual({
+    type: 'local',
+    path: '@/global-state-context',
+    meta: { namedImport: true },
+  })
+  expect(file.component).toMatch(HOOK)
+  // Assigned on every render, after the hook: a change of the global value
+  // re-renders the file, and the next run reads the new value.
+  expect(file.component).toMatch(VALUE_IN_REF)
+  expect(file.component.indexOf('useGlobalState()')).toBeLessThan(
+    file.component.indexOf('__wfStateRef.current =')
+  )
+  // The runtime is told the state's type, and each run starts from the ref.
+  expect(file.component).toMatch(/tickerTimerEnabled: "boolean"/)
+  expect(file.module).toContain(
+    'triggerContext.__stateValues = Object.assign({}, stateValuesRef.current);'
+  )
+}
+
+const expectNoGlobalStateWiring = (file: Generated) => {
+  expect(file.dependencies.useGlobalState).toBeUndefined()
+  expect(file.component).not.toContain('useGlobalState')
+  expect(file.component).not.toContain('tickerTimerEnabled')
+  expect(file.component).toMatch(/__wfStateRef\.current = \{\s*count: count\s*\}/)
+}
+
+const READ_SWITCH = node('read-switch', 'state-get-global-state', {
+  property: 'tickerTimerEnabled',
+})
+
+describe('a file whose workflows only read a global state', () => {
+  it('a component gets the import, the hook, and the value in its state ref', async () => {
+    const file = await generateFile({
+      workflow: timerWorkflow([READ_SWITCH, UPDATE_COUNT]),
+      isPage: false,
+    })
+
+    expectGlobalStateWired(file)
+  })
+
+  it('a page gets the same', async () => {
+    const file = await generateFile({
+      workflow: timerWorkflow([READ_SWITCH, UPDATE_COUNT], {
+        scope: 'page',
+        config: { pageId: 'page-1' },
+      }),
+      isPage: true,
+    })
+
+    expectGlobalStateWired(file)
+  })
+
+  it('counts a read made inside a custom node the workflow calls', async () => {
+    const file = await generateFile({
+      workflow: timerWorkflow([
+        node('call', 'general-custom-node', { customNodeId: 'shared-check' }),
+        UPDATE_COUNT,
+      ]),
+      isPage: false,
+      customNodes: { 'shared-check': { id: 'shared-check', nodes: [READ_SWITCH], edges: [] } },
+    })
+
+    expectGlobalStateWired(file)
+  })
+
+  it.each([
+    ['a {{state.<name>}} token', { value: '{{state.tickerTimerEnabled}}' }],
+    [
+      'a context reference into the state values',
+      {
+        value: {
+          type: 'workflowContext',
+          nodeId: 'tick',
+          path: ['tick', '__stateValues', 'tickerTimerEnabled'],
+        },
+      },
+    ],
+    [
+      'an expression over the state values',
+      { expression: 'context.__stateValues.tickerTimerEnabled === true' },
+    ],
+  ])('counts a read written as %s', async (_form, config) => {
+    const file = await generateFile({
+      workflow: timerWorkflow([node('gate', 'general-if-statement', config), UPDATE_COUNT]),
+      isPage: false,
+    })
+
+    expectGlobalStateWired(file)
+  })
+})
+
+describe('a file that uses no global state is generated as before', () => {
+  it('a workflow on local state only gets no hook, in a project that has global states', async () => {
+    const file = await generateFile({ workflow: timerWorkflow([UPDATE_COUNT]), isPage: false })
+
+    expectNoGlobalStateWiring(file)
+  })
+
+  it.each([
+    ['a token naming a local state', { value: '{{state.count}}' }],
+    ['an expression over the state values naming none', { expression: '__stateValues.count > 3' }],
+    [
+      'a name that merely contains a global state name',
+      { expression: '__stateValues.tickerTimerEnabledLabel' },
+    ],
+  ])('%s gets no hook', async (_form, config) => {
+    const file = await generateFile({
+      workflow: timerWorkflow([node('gate', 'general-if-statement', config), UPDATE_COUNT]),
+      isPage: false,
+    })
+
+    expectNoGlobalStateWiring(file)
+  })
+
+  it('a read node in a project that declares no global state adds nothing', async () => {
+    const file = await generateFile({
+      workflow: timerWorkflow([READ_SWITCH, UPDATE_COUNT]),
+      isPage: false,
+      globalStateDefinitions: {},
+    })
+
+    expect(file.dependencies.useGlobalState).toBeUndefined()
+    expect(file.component).not.toContain('useGlobalState')
+  })
+})
+
+describe('the read node itself', () => {
+  it('returns the value the state ref held when the run started', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    const handler = new Function(`return ${buildStateGetHandlerSource('state_get_global_state')}`)()
+    const stateValuesRef = { current: { tickerTimerEnabled: true } }
+    const context = { __stateValues: { ...stateValuesRef.current } }
+
+    await expect(handler({ property: 'tickerTimerEnabled' }, context)).resolves.toEqual({
+      value: true,
+      key: 'tickerTimerEnabled',
+    })
+    await expect(handler({ property: 'tickerTimerEnabled' }, {})).resolves.toEqual({
+      value: undefined,
+      key: 'tickerTimerEnabled',
+    })
+  })
+})

package/__tests__/server-loop-types.test.ts

@@ -0,0 +1,371 @@
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+import { withEnv } from './_helpers/fake-fetch'
+
+/**
+ * A loop steps by its loopType wherever it runs. The server routes walked
+ * `collection` for every type, so a for, while or until loop whose body ran on
+ * the server made no pass at all. Each route kind is booted here and run with
+ * every loop type, next to the client executor running the same loops.
+ */
+
+const LOOP_ID = 'loop-1'
+const BODY_ID = 'body-1'
+const ITER_ID = LOOP_ID + '_iter'
+const PASSES_KEY = '__serverLoopTypePasses'
+
+const passes = (): number => (globalThis as Record<string, any>)[PASSES_KEY] || 0
+
+const COUNT_PASSES_CODE = [
+  'function customHandler() {',
+  `  globalThis.${PASSES_KEY} = (globalThis.${PASSES_KEY} || 0) + 1;`,
+  `  return { n: globalThis.${PASSES_KEY} };`,
+  '}',
+].join('\n')
+
+const loopEdges = [
+  {
+    id: 'e1',
+    source: LOOP_ID,
+    target: BODY_ID,
+    sourceHandle: 'loop',
+    targetHandle: 'loop-body-in',
+  },
+  {
+    id: 'e2',
+    source: BODY_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+]
+
+const loopNode = (config: Record<string, unknown>) => ({
+  id: LOOP_ID,
+  type: 'general-loop',
+  config,
+  stepNumber: 1,
+  label: 'Loop',
+})
+
+const countingBody = () => ({
+  id: BODY_ID,
+  type: 'general-custom-js',
+  config: { code: COUNT_PASSES_CODE, context: 'server' },
+  stepNumber: 2,
+  label: 'Count The Pass',
+})
+
+const BODY_RAN_FEWER_THAN_THREE_TIMES = `!context['${BODY_ID}'] || context['${BODY_ID}'].n < 3`
+const BODY_RAN_THREE_TIMES = `!!context['${BODY_ID}'] && context['${BODY_ID}'].n >= 3`
+
+interface LoopCase {
+  name: string
+  config: Record<string, unknown>
+  expectedPasses: number
+}
+
+const NON_COLLECTION_LOOPS: LoopCase[] = [
+  {
+    name: 'a for loop up to endIndex',
+    config: { loopType: 'for', endIndex: 4 },
+    expectedPasses: 4,
+  },
+  {
+    name: 'a for loop from startIndex by step',
+    config: { loopType: 'for', startIndex: 2, endIndex: 9, step: 3 },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a for loop counting down',
+    config: { loopType: 'for', startIndex: 3, endIndex: 0, step: -1 },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a for loop whose bounds arrive as text',
+    config: { loopType: 'for', startIndex: '0', endIndex: '3' },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a while loop, its condition read again before every pass',
+    config: { loopType: 'while', condition: BODY_RAN_FEWER_THAN_THREE_TIMES },
+    expectedPasses: 3,
+  },
+  {
+    name: 'an until loop, its condition read again before every pass',
+    config: { loopType: 'until', condition: BODY_RAN_THREE_TIMES },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a while loop that never ends, stopped at maxIterations',
+    config: { loopType: 'while', condition: 'true', maxIterations: 7 },
+    expectedPasses: 7,
+  },
+  {
+    name: 'an until loop that never ends, stopped at the default cap',
+    config: { loopType: 'until', condition: 'false' },
+    expectedPasses: 1000,
+  },
+]
+
+const NON_COLLECTION_LOOP_ROWS = NON_COLLECTION_LOOPS.map(
+  (loop): [string, Record<string, unknown>, number] => [loop.name, loop.config, loop.expectedPasses]
+)
+
+const requireRuntime = (extra: Record<string, unknown> = {}) => {
+  const runtime = loadServerRuntime()
+  return (id: string): unknown => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    const known = Object.keys(extra).find((suffix) => id.endsWith(suffix))
+    if (known) {
+      return extra[known]
+    }
+    throw new Error('Unexpected require: ' + id)
+  }
+}
+
+const bootRoute = (source: string, requireFn: (id: string) => unknown) => {
+  const routeModule: { exports: any } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', source)(routeModule, routeModule.exports, requireFn)
+  return routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+}
+
+const jsonReply = () => {
+  const reply = { status: 0, body: undefined as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  return { reply, res }
+}
+
+const segmentOf = (config: Record<string, unknown>): WorkflowSegment =>
+  ({
+    id: 'seg-loop',
+    env: 'server',
+    nodeIds: [LOOP_ID, BODY_ID],
+    nodes: [loopNode(config), countingBody()],
+    edges: loopEdges,
+  } as unknown as WorkflowSegment)
+
+type SegmentRouteGenerator = (segment: WorkflowSegment) => string
+
+const runSegmentRoute = async (
+  generate: SegmentRouteGenerator,
+  config: Record<string, unknown>
+) => {
+  const handler = bootRoute(generate(segmentOf(config)), requireRuntime())
+  const { reply, res } = jsonReply()
+  await handler({ method: 'POST', body: { context: {} }, headers: { host: 'site.example' } }, res)
+  return reply
+}
+
+const scheduledWorkflow = (
+  config: Record<string, unknown>,
+  body: Record<string, unknown>
+): any => ({
+  id: 'wf-scheduled-loop',
+  name: 'Scheduled Loop',
+  trigger: {
+    type: 'event-cron-triggered',
+    nodeId: 't',
+    scope: 'global',
+    config: { schedule: '5 * * * *', urlPath: 'cron_loop' },
+  },
+  nodes: [loopNode(config), body],
+  edges: [{ id: 'e0', source: 't', target: LOOP_ID }, ...loopEdges],
+})
+
+const runScheduledRoute = async (
+  workflow: any,
+  customNodes?: Record<string, unknown>,
+  customNodeModule: Record<string, unknown> = {}
+) => {
+  const handler = bootRoute(
+    generateCronAPIRoute(workflow, customNodes as never),
+    requireRuntime({ '/utils/workflows/custom-nodes': customNodeModule })
+  )
+  const { reply, res } = jsonReply()
+  const req = {
+    method: 'POST',
+    url: '/api/workflows/cron_loop',
+    headers: { host: 'site.example', 'x-forwarded-proto': 'https' },
+    body: {},
+  }
+  await withEnv({ TELEPORT_CRON_ALLOW_UNSIGNED: 'true', TELEPORT_CRON_SECRET: undefined }, () =>
+    handler(req, res)
+  )
+  return reply
+}
+
+const runOnClient = async (config: Record<string, unknown>) => {
+  const shared: { exports: Record<string, any> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', generateSharedRuntimeUtilsCode())(shared, shared.exports)
+  const context: Record<string, any> = {}
+  let ran = 0
+  const handlers = {
+    'general-custom-js': async () => {
+      ran++
+      return { n: ran }
+    },
+  }
+  await shared.exports.executeNodes(
+    [loopNode(config), countingBody()],
+    loopEdges,
+    context,
+    handlers,
+    {},
+    null,
+    'exec-1'
+  )
+  return { ran, context }
+}
+
+beforeEach(() => {
+  delete (globalThis as Record<string, any>)[PASSES_KEY]
+})
+
+afterAll(() => {
+  delete (globalThis as Record<string, any>)[PASSES_KEY]
+})
+
+describe.each<[string, SegmentRouteGenerator]>([
+  ['a server segment route', (segment) => generateServerSegmentAPIRoute(segment)],
+  [
+    'a streaming server segment route',
+    (segment) => generateStreamingServerSegmentAPIRoute(segment),
+  ],
+])('%s steps a loop by its type', (_route, generate) => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('runs %s', async (_name, config, expectedPasses) => {
+    const reply = await runSegmentRoute(generate, config)
+
+    expect(reply.status).toBe(200)
+    expect(passes()).toBe(expectedPasses)
+    expect(reply.body.results[LOOP_ID]).toEqual({
+      completed: true,
+      iterations: expectedPasses,
+      results: [],
+    })
+  })
+
+  it('still walks the collection of a forEach and a map loop', async () => {
+    const forEach = await runSegmentRoute(generate, { loopType: 'forEach', collection: ['a', 'b'] })
+    expect(passes()).toBe(2)
+    expect(forEach.body.results[LOOP_ID]).toEqual({ completed: true, iterations: 2, results: [] })
+
+    const map = await runSegmentRoute(generate, { loopType: 'map', collection: ['a', 'b', 'c'] })
+    expect(passes()).toBe(5)
+    expect(map.body.results[LOOP_ID]).toEqual({
+      completed: true,
+      iterations: 3,
+      results: [{ n: 3 }, { n: 4 }, { n: 5 }],
+    })
+  })
+})
+
+describe('a scheduled route steps a loop by its type', () => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('runs %s', async (_name, config, expectedPasses) => {
+    const reply = await runScheduledRoute(scheduledWorkflow(config, countingBody()))
+
+    expect(reply.status).toBe(200)
+    expect(passes()).toBe(expectedPasses)
+  })
+
+  const customNodeBody = (parameters: Record<string, unknown>) => ({
+    id: BODY_ID,
+    type: 'general-custom-node',
+    config: { customNodeId: 'cn-record', parameters },
+    stepNumber: 2,
+    label: 'Record The Pass',
+  })
+  const customNodes: Record<string, unknown> = {
+    'cn-record': { id: 'cn-record', name: 'Record', nodes: [], edges: [] },
+  }
+  const iterationRef = (field: string) => ({
+    type: 'workflowContext',
+    nodeId: ITER_ID,
+    path: [ITER_ID, field],
+  })
+  const recordingModule = () => {
+    const seen: unknown[] = []
+    const module = {
+      'cn-record': async (_context: unknown, parameters: unknown) => {
+        seen.push(parameters)
+        return { n: seen.length }
+      },
+    }
+    return { seen, module }
+  }
+
+  it('hands a for loop body the index of its pass', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'for', startIndex: 1, endIndex: 7, step: 2 },
+      customNodeBody({ index: iterationRef('index') })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([{ index: 1 }, { index: 3 }, { index: 5 }])
+  })
+
+  it('hands a while loop body the number of its pass, and its condition too', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'while', condition: `context['${ITER_ID}'].iteration < 2` },
+      customNodeBody({ iteration: iterationRef('iteration') })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([{ iteration: 0 }, { iteration: 1 }])
+  })
+
+  it('still hands a forEach loop body the item of its pass', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'forEach', collection: [{ id: 'a' }, { id: 'b' }] },
+      customNodeBody({
+        id: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'currentItem', 'id'] },
+        index: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'index'] },
+        isLast: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'isLast'] },
+      })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([
+      { id: 'a', index: 0, isLast: false },
+      { id: 'b', index: 1, isLast: true },
+    ])
+  })
+})
+
+describe('the client executor and the server routes make the same passes', () => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('for %s', async (_name, config, expectedPasses) => {
+    const client = await runOnClient(config)
+
+    expect(client.ran).toBe(expectedPasses)
+    expect(client.context[LOOP_ID]).toEqual({ completed: true, iterations: expectedPasses })
+  })
+})

package/dist/cjs/api-route-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAGb,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAuEvE,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;CACrD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,wEAAwE;AACxE,eAAO,MAAM,wBAAwB;;;CAAiC,CAAA;AAEtE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,4CAA4C,CAAA;AA+O7E,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAyXF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAycF,CAAA;AA6ID;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aA4D5B,CAAA;AAEF,qDAAqD;AACrD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAqBD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MA0HF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAsTD,uHAAuH;AACvH,eAAO,MAAM,uBAAuB,kBAAmB,iBAAiB,KAAG,OAES,CAAA;AAEpF,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MAkOF,CAAA;AAkED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,aACxB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA8KF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}
+{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAGb,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAuEvE,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;CACrD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,wEAAwE;AACxE,eAAO,MAAM,wBAAwB;;;CAAiC,CAAA;AAEtE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,4CAA4C,CAAA;AA+O7E,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MA0XF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MA0cF,CAAA;AA6ID;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aA4D5B,CAAA;AAEF,qDAAqD;AACrD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAqBD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MA0HF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAuTD,uHAAuH;AACvH,eAAO,MAAM,uBAAuB,kBAAmB,iBAAiB,KAAG,OAES,CAAA;AAEpF,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MAkOF,CAAA;AAkED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,aACxB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA8KF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}