@pikku/core 0.12.2 → 0.12.4

package/src/wirings/http/http-routes.test.ts

@@ -1,322 +0,0 @@
-import { test, describe, beforeEach, afterEach } from 'node:test'
-import * as assert from 'assert'
-import { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { addFunction } from '../../function/function-runner.js'
-import { httpRouter } from './routers/http-router.js'
-import type { CorePikkuMiddleware } from '../../types/core.types.js'
-
-// Mock function for testing
-const mockFunc = async () => ({ success: true })
-
-// Mock middleware
-const mockMiddleware: CorePikkuMiddleware = async (_services, _wire, next) => {
-  await next()
-}
-
-// Helper to set up function metadata for routes
-const setupFunctionMeta = (
-  routes: Array<{ method: string; route: string }>
-) => {
-  const meta: Record<string, Record<string, any>> = {
-    get: {},
-    post: {},
-    delete: {},
-    patch: {},
-    head: {},
-    put: {},
-    options: {},
-  }
-
-  for (const { method, route } of routes) {
-    meta[method][route] = {
-      pikkuFuncId: `func_${route.replace(/[^a-z0-9]/gi, '_')}`,
-      route,
-      method,
-    }
-  }
-
-  pikkuState(null, 'http', 'meta', meta)
-
-  for (const { method, route } of routes) {
-    const funcName = `func_${route.replace(/[^a-z0-9]/gi, '_')}`
-    pikkuState(null, 'function', 'meta', {
-      [funcName]: {
-        pikkuFuncId: funcName,
-        services: [],
-      },
-    } as any)
-    addFunction(funcName, { func: mockFunc })
-  }
-}
-
-describe('defineHTTPRoutes', () => {
-  test('should accept routes directly', () => {
-    const routes = defineHTTPRoutes({
-      list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-      get: { method: 'get', route: '/todos/:id', func: { func: mockFunc } },
-    })
-
-    assert.ok(routes.routes.list)
-    assert.ok(routes.routes.get)
-    assert.strictEqual(routes.routes.list.method, 'get')
-    assert.strictEqual(routes.routes.list.route, '/todos')
-  })
-
-  test('should accept config with routes', () => {
-    const routes = defineHTTPRoutes({
-      auth: true,
-      tags: ['todos'],
-      routes: {
-        list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-      },
-    })
-
-    assert.strictEqual(routes.auth, true)
-    assert.deepStrictEqual(routes.tags, ['todos'])
-    assert.ok(routes.routes.list)
-  })
-
-  test('should handle basePath in config', () => {
-    const routes = defineHTTPRoutes({
-      basePath: '/api',
-      routes: {
-        list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-      },
-    })
-
-    assert.strictEqual(routes.basePath, '/api')
-  })
-})
-
-describe('wireHTTPRoutes', () => {
-  beforeEach(() => {
-    resetPikkuState()
-    httpRouter.reset()
-  })
-
-  afterEach(() => {
-    resetPikkuState()
-    httpRouter.reset()
-  })
-
-  test('should wire flat array of routes', () => {
-    setupFunctionMeta([
-      { method: 'get', route: '/todos' },
-      { method: 'post', route: '/todos' },
-    ])
-
-    wireHTTPRoutes({
-      routes: [
-        { method: 'get', route: '/todos', func: { func: mockFunc } },
-        { method: 'post', route: '/todos', func: { func: mockFunc } },
-      ],
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    assert.ok(routes.get('get')?.has('/todos'))
-    assert.ok(routes.get('post')?.has('/todos'))
-  })
-
-  test('should wire nested object routes', () => {
-    setupFunctionMeta([
-      { method: 'get', route: '/todos' },
-      { method: 'get', route: '/todos/:id' },
-      { method: 'post', route: '/auth/login' },
-    ])
-
-    wireHTTPRoutes({
-      routes: {
-        todos: {
-          list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-          get: {
-            method: 'get',
-            route: '/todos/:id',
-            func: { func: mockFunc },
-          },
-        },
-        auth: {
-          login: {
-            method: 'post',
-            route: '/auth/login',
-            func: { func: mockFunc },
-          },
-        },
-      },
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    assert.ok(routes.get('get')?.has('/todos'))
-    assert.ok(routes.get('get')?.has('/todos/:id'))
-    assert.ok(routes.get('post')?.has('/auth/login'))
-  })
-
-  test('should apply basePath to all routes', () => {
-    setupFunctionMeta([
-      { method: 'get', route: '/api/v1/todos' },
-      { method: 'post', route: '/api/v1/todos' },
-    ])
-
-    wireHTTPRoutes({
-      basePath: '/api/v1',
-      routes: [
-        { method: 'get', route: '/todos', func: { func: mockFunc } },
-        { method: 'post', route: '/todos', func: { func: mockFunc } },
-      ],
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    assert.ok(routes.get('get')?.has('/api/v1/todos'))
-    assert.ok(routes.get('post')?.has('/api/v1/todos'))
-  })
-
-  test('should merge tags from group config and route config', () => {
-    setupFunctionMeta([{ method: 'get', route: '/todos' }])
-
-    wireHTTPRoutes({
-      tags: ['api'],
-      routes: [
-        {
-          method: 'get',
-          route: '/todos',
-          func: { func: mockFunc },
-          tags: ['todos'],
-        },
-      ],
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    const route = routes.get('get')?.get('/todos')
-    assert.deepStrictEqual(route?.tags, ['api', 'todos'])
-  })
-
-  test('should merge middleware from group config and route config', () => {
-    setupFunctionMeta([{ method: 'get', route: '/todos' }])
-
-    const groupMiddleware: CorePikkuMiddleware = async (_s, _w, next) => {
-      await next()
-    }
-    const routeMiddleware: CorePikkuMiddleware = async (_s, _w, next) => {
-      await next()
-    }
-
-    wireHTTPRoutes({
-      middleware: [groupMiddleware],
-      routes: [
-        {
-          method: 'get',
-          route: '/todos',
-          func: { func: mockFunc },
-          middleware: [routeMiddleware],
-        },
-      ],
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    const route = routes.get('get')?.get('/todos')
-    assert.strictEqual(route?.middleware?.length, 2)
-  })
-
-  test('should allow route auth to override group auth', () => {
-    setupFunctionMeta([
-      { method: 'get', route: '/todos' },
-      { method: 'post', route: '/auth/login' },
-    ])
-
-    wireHTTPRoutes({
-      auth: true,
-      routes: [
-        { method: 'get', route: '/todos', func: { func: mockFunc } },
-        {
-          method: 'post',
-          route: '/auth/login',
-          func: { func: mockFunc },
-          auth: false,
-        },
-      ],
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    const todosRoute = routes.get('get')?.get('/todos')
-    const loginRoute = routes.get('post')?.get('/auth/login')
-
-    assert.strictEqual(todosRoute?.auth, true)
-    assert.strictEqual(loginRoute?.auth, false)
-  })
-
-  test('should wire routes from defineHTTPRoutes contracts', () => {
-    const todosRoutes = defineHTTPRoutes({
-      tags: ['todos'],
-      routes: {
-        list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-      },
-    })
-
-    setupFunctionMeta([{ method: 'get', route: '/api/todos' }])
-
-    wireHTTPRoutes({
-      basePath: '/api',
-      tags: ['api'],
-      routes: {
-        todos: todosRoutes,
-      },
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    const route = routes.get('get')?.get('/api/todos')
-    assert.ok(route)
-    assert.deepStrictEqual(route?.tags, ['api', 'todos'])
-  })
-
-  test('should cascade basePath from multiple levels', () => {
-    const todosRoutes = defineHTTPRoutes({
-      basePath: '/todos',
-      routes: {
-        list: { method: 'get', route: '', func: { func: mockFunc } },
-        get: { method: 'get', route: '/:id', func: { func: mockFunc } },
-      },
-    })
-
-    setupFunctionMeta([
-      { method: 'get', route: '/api/v1/todos' },
-      { method: 'get', route: '/api/v1/todos/:id' },
-    ])
-
-    wireHTTPRoutes({
-      basePath: '/api/v1',
-      routes: {
-        todos: todosRoutes,
-      },
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    assert.ok(routes.get('get')?.has('/api/v1/todos'))
-    assert.ok(routes.get('get')?.has('/api/v1/todos/:id'))
-  })
-
-  test('should handle deeply nested route maps', () => {
-    setupFunctionMeta([
-      { method: 'get', route: '/todos' },
-      { method: 'get', route: '/todos/:id' },
-    ])
-
-    wireHTTPRoutes({
-      routes: {
-        level1: {
-          level2: {
-            list: { method: 'get', route: '/todos', func: { func: mockFunc } },
-            get: {
-              method: 'get',
-              route: '/todos/:id',
-              func: { func: mockFunc },
-            },
-          },
-        },
-      },
-    })
-
-    const routes = pikkuState(null, 'http', 'routes')
-    assert.ok(routes.get('get')?.has('/todos'))
-    assert.ok(routes.get('get')?.has('/todos/:id'))
-  })
-})

package/src/wirings/http/http-routes.ts

@@ -1,198 +0,0 @@
-import type {
-  HTTPRouteConfig,
-  HTTPRouteMap,
-  HTTPRouteContract,
-  HTTPRoutesGroupConfig,
-  WireHTTPRoutesConfig,
-} from './http.types.js'
-import { wireHTTP } from './http-runner.js'
-
-/**
- * Type-safe helper for defining route contracts that can be composed.
- * Supports optional group-level config that cascades to all routes.
- *
- * @example
- * ```typescript
- * // Simple routes without group config
- * export const todosRoutes = defineHTTPRoutes({
- *   list: { method: 'get', route: '/todos', func: listTodos },
- *   get: { method: 'get', route: '/todos/:id', func: getTodo },
- * })
- *
- * // Routes with group-level config
- * export const todosRoutes = defineHTTPRoutes({
- *   auth: true,
- *   tags: ['todos'],
- *   routes: {
- *     list: { method: 'get', route: '/todos', func: listTodos },
- *     get: { method: 'get', route: '/todos/:id', func: getTodo },
- *   }
- * })
- * ```
- */
-export function defineHTTPRoutes<T extends HTTPRouteMap>(
-  routes: T
-): HTTPRouteContract<T>
-export function defineHTTPRoutes<T extends HTTPRouteMap>(
-  config: HTTPRoutesGroupConfig & { routes: T }
-): HTTPRouteContract<T>
-export function defineHTTPRoutes<T extends HTTPRouteMap>(
-  configOrRoutes: T | (HTTPRoutesGroupConfig & { routes: T })
-): HTTPRouteContract<T> {
-  // If it has a 'routes' property and contains a map (not a route config), it's config + routes
-  if (
-    'routes' in configOrRoutes &&
-    typeof configOrRoutes.routes === 'object' &&
-    !isRouteConfig(configOrRoutes.routes)
-  ) {
-    return configOrRoutes as HTTPRouteContract<T>
-  }
-  // Otherwise it's just routes
-  return { routes: configOrRoutes as T }
-}
-
-/**
- * Wires multiple HTTP routes from a nested map or array configuration.
- * Inspired by ts-rest's contract pattern, provides a single place to wire an entire API.
- *
- * @example
- * ```typescript
- * // Nested object format
- * wireHTTPRoutes({
- *   basePath: '/api/v1',
- *   tags: ['api'],
- *   routes: {
- *     todos: {
- *       list: { method: 'get', route: '/todos', func: listTodos },
- *       get: { method: 'get', route: '/todos/:id', func: getTodo },
- *     },
- *     auth: {
- *       login: { method: 'post', route: '/auth/login', func: login, auth: false },
- *     },
- *   },
- * })
- *
- * // Flat array format
- * wireHTTPRoutes({
- *   basePath: '/api',
- *   routes: [
- *     { method: 'get', route: '/todos', func: listTodos },
- *     { method: 'post', route: '/todos', func: createTodo },
- *   ],
- * })
- *
- * // Composing route contracts
- * wireHTTPRoutes({
- *   basePath: '/api/v1',
- *   routes: {
- *     todos: todosRoutes,  // from defineHTTPRoutes()
- *     auth: authRoutes,    // from defineHTTPRoutes()
- *   },
- * })
- * ```
- */
-export const wireHTTPRoutes = (config: WireHTTPRoutesConfig): void => {
-  const { routes, ...groupConfig } = config
-
-  if (Array.isArray(routes)) {
-    routes.forEach((route) => registerRoute(route, groupConfig))
-  } else {
-    processRouteMap(routes, groupConfig)
-  }
-}
-
-/**
- * Recursively processes a route map, handling nested maps and contracts
- */
-function processRouteMap(
-  map: HTTPRouteMap,
-  parentConfig: HTTPRoutesGroupConfig
-): void {
-  for (const [_key, value] of Object.entries(map)) {
-    if (isRouteConfig(value)) {
-      registerRoute(value, parentConfig)
-    } else if (isRouteContract(value)) {
-      // Merge parent config with contract config, then process routes
-      const mergedConfig = mergeGroupConfig(parentConfig, value)
-      processRouteMap(value.routes, mergedConfig)
-    } else {
-      // Nested map without config
-      processRouteMap(value as HTTPRouteMap, parentConfig)
-    }
-  }
-}
-
-/**
- * Merge group configs with proper cascading behavior:
- * - basePath: Concatenates
- * - tags: Merges (parent + child)
- * - middleware: Merges (parent runs first)
- * - auth: Inner overrides outer
- * - permissions: Inner overrides outer
- */
-function mergeGroupConfig(
-  parent: HTTPRoutesGroupConfig,
-  child: HTTPRoutesGroupConfig
-): HTTPRoutesGroupConfig {
-  return {
-    basePath: (parent.basePath || '') + (child.basePath || ''),
-    tags: [...(parent.tags || []), ...(child.tags || [])],
-    middleware: [...(parent.middleware || []), ...(child.middleware || [])],
-    auth: child.auth ?? parent.auth,
-    permissions: child.permissions ?? parent.permissions,
-  }
-}
-
-/**
- * Registers a single route by calling wireHTTP with merged configuration
- */
-function registerRoute(
-  route: HTTPRouteConfig,
-  groupConfig: HTTPRoutesGroupConfig
-): void {
-  const fullRoute = (groupConfig.basePath || '') + route.route
-
-  wireHTTP({
-    method: route.method,
-    route: fullRoute,
-    func: route.func,
-    auth: route.auth ?? groupConfig.auth,
-    tags: [...(groupConfig.tags || []), ...(route.tags || [])],
-    middleware: [
-      ...(groupConfig.middleware || []),
-      ...(route.middleware || []),
-    ],
-    permissions: route.permissions ?? groupConfig.permissions,
-    contentType: route.contentType,
-    timeout: route.timeout,
-    headers: route.headers,
-    docs: route.docs,
-    sse: route.sse,
-  } as any)
-}
-
-/**
- * Type guard to check if a value is an individual route config
- */
-function isRouteConfig(value: unknown): value is HTTPRouteConfig {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'method' in value &&
-    'func' in value &&
-    'route' in value
-  )
-}
-
-/**
- * Type guard to check if a value is a route contract (has routes property but is not a route config)
- */
-function isRouteContract(value: unknown): value is HTTPRouteContract {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'routes' in value &&
-    !('method' in value) &&
-    !('func' in value)
-  )
-}

package/src/wirings/http/http-runner.test.ts

@@ -1,144 +0,0 @@
-import { test, describe, beforeEach, afterEach } from 'node:test'
-import * as assert from 'assert'
-import { NotFoundError } from '../../errors/errors.js'
-import type { JSONValue, CorePikkuMiddleware } from '../../types/core.types.js'
-import { fetch, wireHTTP } from './http-runner.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import {
-  PikkuMockRequest,
-  PikkuMockResponse,
-} from '../channel/local/local-channel-runner.test.js'
-import { addFunction } from '../../function/function-runner.js'
-import { httpRouter } from './routers/http-router.js'
-
-const sessionMiddleware: CorePikkuMiddleware = async (services, wire, next) => {
-  wire.setSession?.({ userId: 'test' } as any)
-  await next()
-}
-
-const setHTTPFunctionMap = (func: any) => {
-  pikkuState(null, 'function', 'meta', {
-    pikku_func_name: {
-      pikkuFuncId: 'pikku_func_name',
-      services: ['userSession'],
-    },
-  } as any)
-  pikkuState(null, 'http', 'meta', {
-    get: {
-      test: {
-        pikkuFuncId: 'pikku_func_name',
-        route: 'test',
-        method: 'get',
-      },
-    },
-    post: {},
-    delete: {},
-    patch: {},
-    head: {},
-    put: {},
-    options: {},
-  })
-  addFunction('pikku_func_name', { func })
-}
-
-describe('fetch', () => {
-  let request: any
-  let response: any
-
-  beforeEach(() => {
-    resetPikkuState()
-    httpRouter.reset()
-
-    const singletonServices = {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-      },
-    }
-
-    const createWireServices = async () => ({})
-
-    pikkuState(null, 'package', 'singletonServices', singletonServices as any)
-    pikkuState(null, 'package', 'factories', { createWireServices } as any)
-
-    request = new PikkuMockRequest('/test', 'get')
-    response = new PikkuMockResponse()
-
-    request.getData = async () => ({})
-    request.getHeader = (name: string) =>
-      name === 'content-type' ? 'application/json' : undefined
-    response.setStatus = (status: number) => {}
-    response.setJson = (json: JSONValue) => {}
-  })
-
-  afterEach(() => {})
-
-  test('should throw RouteNotFoundError when no matching route is found', async () => {
-    await assert.rejects(
-      async () =>
-        fetch(request, {
-          bubbleErrors: true,
-        }),
-      NotFoundError
-    )
-  })
-
-  test('should call the route function and return its result when a matching route is found', async () => {
-    const routeFunc = async () => ({ success: true })
-    setHTTPFunctionMap(routeFunc)
-
-    wireHTTP({
-      route: 'test',
-      method: 'get',
-      func: { func: routeFunc, middleware: [sessionMiddleware] },
-    })
-
-    // Initialize router after adding route (for tests)
-    httpRouter.initialize()
-
-    const result = await fetch(request)
-
-    assert.deepStrictEqual(await result.json(), { success: true })
-  })
-
-  test('should verify permissions if provided', async () => {
-    const permissions = { test: async () => true }
-    const routeFunc = async () => ({ success: true })
-    setHTTPFunctionMap(routeFunc)
-
-    wireHTTP({
-      route: 'test',
-      method: 'get',
-      func: {
-        func: routeFunc,
-        permissions,
-        middleware: [sessionMiddleware],
-      },
-    })
-
-    await fetch(request)
-
-    assert.strictEqual(await permissions.test(), true)
-  })
-
-  test('should handle errors and set appropriate response', async () => {
-    const error = new Error('Test error')
-    const routeFunc = async () => {
-      throw error
-    }
-    setHTTPFunctionMap(routeFunc)
-    wireHTTP({
-      route: 'test',
-      method: 'get',
-      func: { func: routeFunc, middleware: [sessionMiddleware] },
-    })
-    await assert.rejects(
-      async () =>
-        fetch(request, {
-          bubbleErrors: true,
-        }),
-      error
-    )
-  })
-})