imposters 0.1.0

package/src/index.ts

@@ -0,0 +1,153 @@
+
+export * as Program from "./Program.js"
+
+
+export * as AdminApi from "./api/AdminApi.js"
+
+
+export * as ApiErrors from "./api/ApiErrors.js"
+
+
+export * as ApiSchemas from "./api/ApiSchemas.js"
+
+
+export * as Conversions from "./api/Conversions.js"
+
+
+export * as ImpostersGroup from "./api/ImpostersGroup.js"
+
+
+export * as ImpostersHandlers from "./api/ImpostersHandlers.js"
+
+
+export * as SystemGroup from "./api/SystemGroup.js"
+
+
+export * as SystemHandlers from "./api/SystemHandlers.js"
+
+
+export * as Commands from "./cli/Commands.js"
+
+
+export * as ConfigLoader from "./cli/ConfigLoader.js"
+
+
+export * as HandlerHttpClient from "./client/HandlerHttpClient.js"
+
+
+export * as ImpostersClient from "./client/ImpostersClient.js"
+
+
+export * as testing from "./client/testing.js"
+
+/**
+ * Parses and validates imposter creation request
+ */
+export * as imposter from "./domain/imposter.js"
+
+/**
+ * Parses and validates route creation request
+ */
+export * as route from "./domain/route.js"
+
+
+export * as ApiLayer from "./layers/ApiLayer.js"
+
+
+export * as MainLayer from "./layers/MainLayer.js"
+
+/**
+ * Extract expression content from a ${...} pattern using brace-depth counting.
+ * Returns [expressionContent, endIndex] or null if no valid expression found.
+ */
+export * as ExpressionEvaluator from "./matching/ExpressionEvaluator.js"
+
+
+export * as RequestMatcher from "./matching/RequestMatcher.js"
+
+
+export * as ResponseGenerator from "./matching/ResponseGenerator.js"
+
+
+export * as TemplateEngine from "./matching/TemplateEngine.js"
+
+
+export * as ImposterRepository from "./repositories/ImposterRepository.js"
+
+
+export * as ConfigFileSchema from "./schemas/ConfigFileSchema.js"
+
+
+export * as ImposterSchema from "./schemas/ImposterSchema.js"
+
+
+export * as RequestLogSchema from "./schemas/RequestLogSchema.js"
+
+
+export * as StubSchema from "./schemas/StubSchema.js"
+
+
+export * as common from "./schemas/common.js"
+
+
+export * as AdminServer from "./server/AdminServer.js"
+
+
+export * as BunServer from "./server/BunServer.js"
+
+
+export * as FiberManager from "./server/FiberManager.js"
+
+
+export * as ImposterServer from "./server/ImposterServer.js"
+
+
+export * as AppConfig from "./services/AppConfig.js"
+
+
+export * as MetricsService from "./services/MetricsService.js"
+
+
+export * as PortAllocator from "./services/PortAllocator.js"
+
+
+export * as ProxyService from "./services/ProxyService.js"
+
+
+export * as RequestLogger from "./services/RequestLogger.js"
+
+
+export * as Uuid from "./services/Uuid.js"
+
+
+export * as UuidLive from "./services/UuidLive.js"
+
+
+export * as UiRouter from "./ui/UiRouter.js"
+
+
+export * as AdminLayout from "./ui/admin/AdminLayout.js"
+
+
+export * as AdminUiRouter from "./ui/admin/AdminUiRouter.js"
+
+
+export * as AdminDashboard from "./ui/admin/pages/AdminDashboard.js"
+
+
+export * as partials from "./ui/admin/partials.js"
+
+
+export * as html from "./ui/html.js"
+
+
+export * as layout from "./ui/layout.js"
+
+
+export * as dashboard from "./ui/pages/dashboard.js"
+
+
+export * as requests from "./ui/pages/requests.js"
+
+
+export * as stubs from "./ui/pages/stubs.js"

package/src/layers/ApiLayer.ts

@@ -0,0 +1,21 @@
+import { HttpApiBuilder, HttpApiSwagger, HttpServer } from "@effect/platform"
+import * as Layer from "effect/Layer"
+import { AdminApi } from "../api/AdminApi"
+import { ImpostersHandlersLive } from "../api/ImpostersHandlers"
+import { SystemHandlersLive } from "../api/SystemHandlers"
+
+const HandlerLayers = Layer.mergeAll(ImpostersHandlersLive, SystemHandlersLive)
+
+const ApiLive = HttpApiBuilder.api(AdminApi).pipe(Layer.provide(HandlerLayers))
+
+// Middleware layers need Api — provide it from ApiLive
+const MiddlewareLive = Layer.mergeAll(
+  HttpApiBuilder.middlewareOpenApi(),
+  HttpApiSwagger.layer()
+).pipe(Layer.provide(ApiLive))
+
+export const ApiLayer = Layer.mergeAll(
+  ApiLive,
+  MiddlewareLive,
+  HttpServer.layerContext
+)

package/src/layers/MainLayer.ts

@@ -0,0 +1,43 @@
+import * as Layer from "effect/Layer"
+import { ImposterRepositoryLive } from "../repositories/ImposterRepository"
+import { BunServerFactoryLive } from "../server/BunServer"
+import { FiberManagerLive } from "../server/FiberManager"
+import { ImposterServerLive } from "../server/ImposterServer"
+import { AppConfigLive } from "../services/AppConfig"
+import { MetricsServiceLive } from "../services/MetricsService"
+import { PortAllocatorLive } from "../services/PortAllocator"
+import { ProxyServiceLive } from "../services/ProxyService"
+import { RequestLoggerLive } from "../services/RequestLogger"
+import { UuidLive } from "../services/UuidLive"
+
+// PortAllocatorLive depends on AppConfig
+const PortAllocatorWithDeps = PortAllocatorLive.pipe(Layer.provide(AppConfigLive))
+
+// ProxyServiceLive depends on Uuid
+const ProxyServiceWithDeps = ProxyServiceLive.pipe(Layer.provide(UuidLive))
+
+// ImposterServerLive depends on FiberManager + ImposterRepository + ServerFactory + RequestLogger + Metrics + Proxy
+const ImposterServerWithDeps = ImposterServerLive.pipe(
+  Layer.provide(
+    Layer.mergeAll(
+      FiberManagerLive,
+      ImposterRepositoryLive,
+      BunServerFactoryLive,
+      RequestLoggerLive,
+      MetricsServiceLive,
+      ProxyServiceWithDeps
+    )
+  )
+)
+
+// Compose all services
+export const MainLayer = Layer.mergeAll(
+  UuidLive,
+  AppConfigLive,
+  PortAllocatorWithDeps,
+  ImposterRepositoryLive,
+  FiberManagerLive,
+  RequestLoggerLive,
+  MetricsServiceLive,
+  ImposterServerWithDeps
+)

package/src/matching/ExpressionEvaluator.ts

@@ -0,0 +1,102 @@
+import jsonata from "jsonata"
+import type { RequestContext } from "./RequestMatcher"
+
+const MAX_OUTPUT_SIZE = 1_048_576 // 1MB
+
+/**
+ * Extract expression content from a ${...} pattern using brace-depth counting.
+ * Returns [expressionContent, endIndex] or null if no valid expression found.
+ */
+const extractExpression = (str: string, startIndex: number): [string, number] | null => {
+  // startIndex should point to the '$' of '${'
+  if (str[startIndex] !== "$" || str[startIndex + 1] !== "{") return null
+  let depth = 1
+  let i = startIndex + 2
+  while (i < str.length && depth > 0) {
+    if (str[i] === "{") depth++
+    else if (str[i] === "}") depth--
+    i++
+  }
+  if (depth !== 0) return null
+  const content = str.slice(startIndex + 2, i - 1)
+  return [content, i]
+}
+
+/**
+ * Evaluate a single JSONata expression against the request context.
+ * Returns the result or undefined on error.
+ */
+export const evaluateExpression = async (expr: string, ctx: RequestContext): Promise<unknown> => {
+  try {
+    const expression = jsonata(expr)
+    const context = { request: ctx }
+    return await expression.evaluate(context)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Process a string, replacing all ${...} patterns with evaluated JSONata results.
+ */
+const processString = async (str: string, ctx: RequestContext): Promise<unknown> => {
+  // Quick check: if no ${, return as-is
+  if (!str.includes("${")) return str
+
+  // If the entire string is a single expression, return the raw result (preserving type)
+  const singleMatch = extractExpression(str, 0)
+  if (singleMatch && singleMatch[1] === str.length) {
+    const result = await evaluateExpression(singleMatch[0], ctx)
+    if (result === undefined) return str // Preserve raw on failure
+    return result
+  }
+
+  // Multiple expressions or mixed content: concatenate as string
+  let result = ""
+  let i = 0
+  while (i < str.length) {
+    if (str[i] === "$" && i + 1 < str.length && str[i + 1] === "{") {
+      const extracted = extractExpression(str, i)
+      if (extracted) {
+        const [exprContent, endIndex] = extracted
+        const evalResult = await evaluateExpression(exprContent, ctx)
+        if (evalResult === undefined) {
+          // Preserve raw expression on failure
+          result += str.slice(i, endIndex)
+        } else if (typeof evalResult === "object" && evalResult !== null) {
+          const jsonStr = JSON.stringify(evalResult)
+          result += jsonStr
+        } else {
+          result += String(evalResult)
+        }
+        i = endIndex
+        if (result.length > MAX_OUTPUT_SIZE) {
+          return result.slice(0, MAX_OUTPUT_SIZE)
+        }
+        continue
+      }
+    }
+    result += str[i]
+    i++
+  }
+  return result
+}
+
+/**
+ * Recursively walk data structures, processing ${...} expressions in strings.
+ */
+export const processExpressions = async (ctx: RequestContext, data: unknown): Promise<unknown> => {
+  if (typeof data === "string") return processString(data, ctx)
+  if (Array.isArray(data)) {
+    const results = await Promise.all(data.map((item) => processExpressions(ctx, item)))
+    return results
+  }
+  if (data !== null && typeof data === "object") {
+    const entries = Object.entries(data as Record<string, unknown>)
+    const resolved = await Promise.all(
+      entries.map(async ([k, v]) => [k, await processExpressions(ctx, v)] as const)
+    )
+    return Object.fromEntries(resolved)
+  }
+  return data
+}

package/src/matching/RequestMatcher.ts

@@ -0,0 +1,162 @@
+import type { Predicate, Stub } from "../schemas/StubSchema"
+
+export interface RequestContext {
+  readonly method: string
+  readonly path: string
+  readonly headers: Record<string, string>
+  readonly query: Record<string, string>
+  readonly body: unknown
+}
+
+export const extractRequestContext = async (request: Request): Promise<RequestContext> => {
+  const url = new URL(request.url)
+  const method = request.method.toUpperCase()
+  const path = url.pathname
+
+  const headers: Record<string, string> = {}
+  request.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value
+  })
+
+  const query: Record<string, string> = {}
+  url.searchParams.forEach((value, key) => {
+    query[key] = value
+  })
+
+  let body: unknown
+  if (request.body) {
+    const contentType = request.headers.get("content-type") ?? ""
+    const text = await request.text()
+    if (contentType.includes("application/json")) {
+      try {
+        body = JSON.parse(text)
+      } catch {
+        body = text
+      }
+    } else {
+      body = text === "" ? undefined : text
+    }
+  }
+
+  return { method, path, headers, query, body }
+}
+
+const normalize = (s: string, caseSensitive: boolean): string => caseSensitive ? s : s.toLowerCase()
+
+const matchString = (
+  actual: string,
+  expected: unknown,
+  operator: Predicate["operator"],
+  caseSensitive: boolean
+): boolean => {
+  if (operator === "exists") return true
+  if (typeof expected !== "string") return false
+  const a = normalize(actual, caseSensitive)
+  const e = normalize(expected, caseSensitive)
+  switch (operator) {
+    case "equals":
+      return a === e
+    case "contains":
+      return a.includes(e)
+    case "startsWith":
+      return a.startsWith(e)
+    case "matches": {
+      const flags = caseSensitive ? "" : "i"
+      return new RegExp(expected, flags).test(actual)
+    }
+  }
+}
+
+const matchObject = (
+  actual: Record<string, string>,
+  expected: unknown,
+  operator: Predicate["operator"],
+  caseSensitive: boolean
+): boolean => {
+  if (operator === "exists") {
+    if (typeof expected !== "object" || expected === null) return true
+    return Object.keys(expected as Record<string, unknown>).every((key) => key.toLowerCase() in actual || key in actual)
+  }
+  if (typeof expected !== "object" || expected === null) return false
+  const entries = Object.entries(expected as Record<string, unknown>)
+  return entries.every(([key, val]) => {
+    const actualKey = Object.keys(actual).find(
+      (k) => normalize(k, caseSensitive) === normalize(key, caseSensitive)
+    )
+    if (actualKey === undefined) return false
+    const actualVal = actual[actualKey]!
+    if (typeof val !== "string") return false
+    return matchString(actualVal, val, operator, caseSensitive)
+  })
+}
+
+const deepSubsetMatch = (actual: unknown, expected: unknown, caseSensitive: boolean): boolean => {
+  if (expected === null || expected === undefined) return actual === expected
+  if (typeof expected === "string" && typeof actual === "string") {
+    return caseSensitive ? actual === expected : actual.toLowerCase() === expected.toLowerCase()
+  }
+  if (typeof expected === "number" || typeof expected === "boolean") return actual === expected
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false
+    return expected.every((e, i) => i < actual.length && deepSubsetMatch(actual[i], e, caseSensitive))
+  }
+  if (typeof expected === "object" && expected !== null) {
+    if (typeof actual !== "object" || actual === null) return false
+    return Object.entries(expected as Record<string, unknown>).every(([key, val]) =>
+      deepSubsetMatch((actual as Record<string, unknown>)[key], val, caseSensitive)
+    )
+  }
+  return false
+}
+
+const matchBody = (
+  actual: unknown,
+  expected: unknown,
+  operator: Predicate["operator"],
+  caseSensitive: boolean
+): boolean => {
+  switch (operator) {
+    case "exists":
+      return actual !== null && actual !== undefined
+    case "equals":
+      return deepSubsetMatch(actual, expected, caseSensitive)
+    case "contains": {
+      const a = normalize(typeof actual === "string" ? actual : JSON.stringify(actual), caseSensitive)
+      const e = normalize(typeof expected === "string" ? expected : JSON.stringify(expected), caseSensitive)
+      return a.includes(e)
+    }
+    case "startsWith": {
+      const a = normalize(typeof actual === "string" ? actual : JSON.stringify(actual), caseSensitive)
+      const e = normalize(typeof expected === "string" ? expected : JSON.stringify(expected), caseSensitive)
+      return a.startsWith(e)
+    }
+    case "matches": {
+      const a = typeof actual === "string" ? actual : JSON.stringify(actual)
+      const pattern = typeof expected === "string" ? expected : JSON.stringify(expected)
+      const flags = caseSensitive ? "" : "i"
+      return new RegExp(pattern, flags).test(a)
+    }
+  }
+}
+
+export const evaluatePredicate = (ctx: RequestContext, predicate: Predicate): boolean => {
+  const { caseSensitive, field, operator, value } = predicate
+  switch (field) {
+    case "method":
+      return matchString(ctx.method, value, operator, caseSensitive)
+    case "path":
+      return matchString(ctx.path, value, operator, caseSensitive)
+    case "headers":
+      return matchObject(ctx.headers, value, operator, caseSensitive)
+    case "query":
+      return matchObject(ctx.query, value, operator, caseSensitive)
+    case "body":
+      return matchBody(ctx.body, value, operator, caseSensitive)
+  }
+}
+
+export const evaluatePredicates = (ctx: RequestContext, predicates: ReadonlyArray<Predicate>): boolean =>
+  predicates.length === 0 || predicates.every((p) => evaluatePredicate(ctx, p))
+
+export const findMatchingStub = (ctx: RequestContext, stubs: ReadonlyArray<Stub>): Stub | undefined =>
+  stubs.find((stub) => evaluatePredicates(ctx, stub.predicates))

package/src/matching/ResponseGenerator.ts

@@ -0,0 +1,86 @@
+import * as Effect from "effect/Effect"
+import * as HashMap from "effect/HashMap"
+import * as Ref from "effect/Ref"
+import type { ResponseConfig, ResponseMode } from "../schemas/StubSchema"
+import type { RequestContext } from "./RequestMatcher"
+import { applyTemplates } from "./TemplateEngine"
+
+type CounterMap = HashMap.HashMap<string, number>
+type CounterResult = readonly [Effect.Effect<number, never>, CounterMap]
+
+export const makeResponseState = () =>
+  Effect.gen(function*() {
+    const countersRef = yield* Ref.make<CounterMap>(HashMap.empty())
+
+    const getNextIndex = (
+      imposterId: string,
+      stubId: string,
+      count: number,
+      mode: ResponseMode
+    ): Effect.Effect<number> => {
+      const key = `${imposterId}:${stubId}`
+      return Ref.modify(countersRef, (counters): CounterResult => {
+        const current = HashMap.get(counters, key)
+        const index = current._tag === "Some" ? current.value : 0
+        let result: number
+        switch (mode) {
+          case "sequential":
+            result = index % count
+            break
+          case "random":
+            result = Math.floor(Math.random() * count)
+            break
+          case "repeat":
+            result = Math.min(index, count - 1)
+            break
+        }
+        const nextIndex = mode === "random" ? index : index + 1
+        return [Effect.succeed(result), HashMap.set(counters, key, nextIndex)]
+      }).pipe(Effect.flatten)
+    }
+
+    const reset = (imposterId: string): Effect.Effect<void> =>
+      Ref.update(countersRef, (counters) => {
+        let updated = counters
+        for (const key of HashMap.keys(counters)) {
+          if (key.startsWith(`${imposterId}:`)) {
+            updated = HashMap.remove(updated, key)
+          }
+        }
+        return updated
+      })
+
+    return { getNextIndex, reset }
+  })
+
+export const buildResponse = async (config: ResponseConfig, ctx: RequestContext): Promise<Response> => {
+  const headers = new Headers()
+  const responseHeaders = config.headers
+  if (responseHeaders !== undefined) {
+    for (const [key, val] of Object.entries(responseHeaders)) {
+      const templated = await applyTemplates(ctx, val)
+      headers.set(key, typeof templated === "string" ? templated : String(templated))
+    }
+  }
+
+  let bodyStr: string | null = null
+  if (config.body !== undefined) {
+    const templated = await applyTemplates(ctx, config.body)
+    if (typeof templated === "string") {
+      bodyStr = templated
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "text/plain")
+      }
+    } else {
+      bodyStr = JSON.stringify(templated)
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json")
+      }
+    }
+  }
+
+  return new Response(bodyStr, {
+    status: config.status,
+    headers
+  })
+}

package/src/matching/TemplateEngine.ts

@@ -0,0 +1,54 @@
+import { substituteParams } from "../domain/route"
+import { processExpressions } from "./ExpressionEvaluator"
+import type { RequestContext } from "./RequestMatcher"
+
+const flattenObject = (obj: unknown, prefix: string, result: Record<string, string>): void => {
+  if (obj === null || obj === undefined) return
+  if (typeof obj === "string") {
+    result[prefix] = obj
+    return
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    result[prefix] = String(obj)
+    return
+  }
+  if (Array.isArray(obj)) {
+    result[prefix] = JSON.stringify(obj)
+    obj.forEach((item, i) => flattenObject(item, `${prefix}.${i}`, result))
+    return
+  }
+  if (typeof obj === "object") {
+    result[prefix] = JSON.stringify(obj)
+    for (const [key, val] of Object.entries(obj as Record<string, unknown>)) {
+      flattenObject(val, `${prefix}.${key}`, result)
+    }
+  }
+}
+
+export const flattenRequestContext = (ctx: RequestContext): Record<string, string> => {
+  const result: Record<string, string> = {
+    "request.method": ctx.method,
+    "request.path": ctx.path
+  }
+
+  for (const [key, val] of Object.entries(ctx.headers)) {
+    result[`request.headers.${key}`] = val
+  }
+
+  for (const [key, val] of Object.entries(ctx.query)) {
+    result[`request.query.${key}`] = val
+  }
+
+  if (ctx.body !== undefined && ctx.body !== null) {
+    flattenObject(ctx.body, "request.body", result)
+  }
+
+  return result
+}
+
+export const applyTemplates = async (ctx: RequestContext, data: unknown): Promise<unknown> => {
+  // Step 1: Apply {{key}} substitution
+  const substituted = substituteParams(flattenRequestContext(ctx))(data)
+  // Step 2: Apply ${expr} JSONata evaluation
+  return processExpressions(ctx, substituted)
+}