@pikku/core 0.12.106 → 0.12.111

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

@@ -1,318 +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 '../../middleware/middleware.types.js'
-const mockFunc = async () => ({ success: true })
-
-const mockMiddleware: CorePikkuMiddleware = async (_services, _wire, next) => {
-  await next()
-}
-
-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,111 +0,0 @@
-import type {
-  CoreHTTPFunctionWiring,
-  HTTPRouteConfig,
-  HTTPRouteMap,
-  HTTPRouteContract,
-  HTTPRoutesGroupConfig,
-  WireHTTPRoutesConfig,
-} from './http.types.js'
-import { wireHTTP } from './http-runner.js'
-
-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 (
-    'routes' in configOrRoutes &&
-    typeof configOrRoutes.routes === 'object' &&
-    !isRouteConfig(configOrRoutes.routes)
-  ) {
-    return configOrRoutes as HTTPRouteContract<T>
-  }
-  return { routes: configOrRoutes as T }
-}
-
-export const wireHTTPRoutes = (config: WireHTTPRoutesConfig): void => {
-  const { routes, ...groupConfig } = config
-
-  if (Array.isArray(routes)) {
-    routes.forEach((route) => registerRoute(route, groupConfig))
-  } else {
-    processRouteMap(routes, groupConfig)
-  }
-}
-
-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)) {
-      const mergedConfig = mergeGroupConfig(parentConfig, value)
-      processRouteMap(value.routes, mergedConfig)
-    } else {
-      processRouteMap(value as HTTPRouteMap, parentConfig)
-    }
-  }
-}
-
-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,
-  }
-}
-
-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 || []),
-    ],
-    contentType: route.contentType,
-    timeout: route.timeout,
-    headers: route.headers,
-    sse: route.sse,
-    // `CoreHTTPFunctionWiring` is discriminated by `method`, and a group builds
-    // its routes from a method chosen at runtime — no arm can be narrowed to.
-  } as CoreHTTPFunctionWiring<unknown, unknown, string>)
-}
-
-function isRouteConfig(value: unknown): value is HTTPRouteConfig {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'method' in value &&
-    'func' in value &&
-    'route' in value
-  )
-}
-
-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-addon-ref.test.ts

@@ -1,238 +0,0 @@
-import { test, describe, beforeEach } from 'node:test'
-import * as assert from 'assert'
-import { addHTTPMiddleware, fetch, wireHTTP } from './http-runner.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { addSchema } from '../../schema.js'
-import { PikkuMockRequest } from '../channel/local/local-channel-runner.test.js'
-import { httpRouter } from './routers/http-router.js'
-import type { CoreHTTPFunctionWiring, HTTPMethod } from './http.types.js'
-
-const ADDON_PACKAGE = '@acme/addon'
-const ADDON_NAMESPACE = 'ext'
-const TARGET = `${ADDON_NAMESPACE}:greet`
-
-class ParamsRequest extends PikkuMockRequest {
-  override async data() {
-    return this.params()
-  }
-  override header(): string | null {
-    return null
-  }
-}
-
-const registerAddon = (
-  sessionless = true,
-  inputSchemaName: string | null = null
-) => {
-  pikkuState(null, 'addons', 'packages').set(ADDON_NAMESPACE, {
-    package: ADDON_PACKAGE,
-  } as never)
-  pikkuState(ADDON_PACKAGE, 'function', 'meta', {
-    greet: {
-      pikkuFuncId: 'greet',
-      name: 'greet',
-      sessionless,
-      inputSchemaName,
-      outputSchemaName: null,
-      inputs: [],
-      outputs: [],
-      services: { optimized: false, services: [] },
-    },
-  } as never)
-}
-
-const emptyHTTPMeta = () => ({
-  get: {},
-  post: {},
-  delete: {},
-  patch: {},
-  head: {},
-  put: {},
-  options: {},
-})
-
-const setRouteMeta = (
-  route: string,
-  method: HTTPMethod,
-  extra: Record<string, unknown> = {}
-) => {
-  const meta = pikkuState(null, 'http', 'meta')
-  meta[method][route] = {
-    pikkuFuncId: TARGET,
-    route,
-    method,
-    ...extra,
-  }
-}
-
-describe('http routes wired with ref() to an addon function', () => {
-  beforeEach(() => {
-    resetPikkuState()
-    httpRouter.reset()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: { info: () => {}, warn: () => {}, error: () => {} },
-    } as never)
-    pikkuState(null, 'package', 'factories', {
-      createWireServices: async () => ({}),
-    } as never)
-    pikkuState(null, 'http', 'meta', emptyHTTPMeta() as never)
-  })
-
-  test('resolves the namespaced target through the addon package', async () => {
-    registerAddon()
-    setRouteMeta('/addon/greet', 'get', { auth: false })
-
-    wireHTTP({
-      route: '/addon/greet',
-      method: 'get',
-      auth: false,
-      func: { func: async () => ({ message: 'hello' }) },
-    } as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    httpRouter.initialize()
-
-    const response = await fetch(new ParamsRequest('/addon/greet', 'get'))
-
-    assert.strictEqual(response.status, 200)
-    assert.deepStrictEqual(await response.json(), { message: 'hello' })
-  })
-
-  test('serves the same addon function at two routes with different params', async () => {
-    registerAddon()
-    setRouteMeta('/addon/greet/:id', 'get', { auth: false, params: ['id'] })
-    setRouteMeta('/addon/greet-all', 'get', { auth: false })
-
-    const seen: unknown[] = []
-    const proxy = {
-      func: async (_services: never, data: unknown) => {
-        seen.push(data)
-        return data
-      },
-    }
-
-    wireHTTP({
-      route: '/addon/greet/:id',
-      method: 'get',
-      auth: false,
-      func: proxy,
-    } as unknown as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    wireHTTP({
-      route: '/addon/greet-all',
-      method: 'get',
-      auth: false,
-      func: proxy,
-    } as unknown as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    httpRouter.initialize()
-
-    const withParam = await fetch(new ParamsRequest('/addon/greet/42', 'get'))
-    const withoutParam = await fetch(
-      new ParamsRequest('/addon/greet-all', 'get')
-    )
-
-    assert.deepStrictEqual(await withParam.json(), { id: '42' })
-    assert.deepStrictEqual(await withoutParam.json(), {})
-    assert.deepEqual(seen, [{ id: '42' }, {}])
-  })
-
-  /**
-   * The addon registers its schemas in its own package state, and the name the
-   * runner validates against comes from the addon's metadata. Resolving the
-   * target's metadata by namespace while still reading the schema registry of
-   * the wire's package looks the name up under 'main', where the addon never
-   * put it — the route then answers 500 for every input it was given.
-   */
-  test("validates input against the addon package's schema registry", async () => {
-    registerAddon(true, 'GreetInput')
-    addSchema(
-      'GreetInput',
-      { type: 'object', properties: { id: { type: 'string' } } },
-      ADDON_PACKAGE
-    )
-    setRouteMeta('/addon/greet-schema/:id', 'get', {
-      auth: false,
-      params: ['id'],
-    })
-
-    const compiled: string[] = []
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: { info: () => {}, warn: () => {}, error: () => {} },
-      schema: {
-        compileSchema: (key: string) => {
-          compiled.push(key)
-        },
-        validateSchema: () => {},
-        getSchemaKeys: () => [],
-      },
-    } as never)
-
-    wireHTTP({
-      route: '/addon/greet-schema/:id',
-      method: 'get',
-      auth: false,
-      func: { func: async (_s: never, data: unknown) => data },
-    } as unknown as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    httpRouter.initialize()
-
-    const response = await fetch(
-      new ParamsRequest('/addon/greet-schema/42', 'get')
-    )
-
-    assert.strictEqual(response.status, 200)
-    assert.deepStrictEqual(await response.json(), { id: '42' })
-    assert.deepStrictEqual(compiled.length > 0, true)
-  })
-
-  test("runs the consuming app's middleware, not the addon package's", async () => {
-    registerAddon()
-    setRouteMeta('/addon/greet-mw', 'get', {
-      auth: false,
-      middleware: [{ type: 'http', route: '*' }],
-    })
-
-    const ran: string[] = []
-    addHTTPMiddleware('*', [
-      async (_services, _wire, next) => {
-        ran.push('app')
-        await next()
-      },
-    ] as never)
-    addHTTPMiddleware(
-      '*',
-      [
-        async (_services: never, _wire: never, next: () => Promise<void>) => {
-          ran.push('addon')
-          await next()
-        },
-      ] as never,
-      ADDON_PACKAGE
-    )
-
-    wireHTTP({
-      route: '/addon/greet-mw',
-      method: 'get',
-      auth: false,
-      func: { func: async () => ({ message: 'hello' }) },
-    } as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    httpRouter.initialize()
-
-    const response = await fetch(new ParamsRequest('/addon/greet-mw', 'get'))
-
-    assert.strictEqual(response.status, 200)
-    assert.deepStrictEqual(ran, ['app'])
-  })
-
-  test('honours the addon function metadata when a session is required', async () => {
-    registerAddon(false)
-    setRouteMeta('/addon/greet', 'get')
-
-    wireHTTP({
-      route: '/addon/greet',
-      method: 'get',
-      func: { func: async () => ({ message: 'hello' }) },
-    } as CoreHTTPFunctionWiring<unknown, unknown, string>)
-    httpRouter.initialize()
-
-    const response = await fetch(new ParamsRequest('/addon/greet', 'get'))
-
-    assert.strictEqual(response.status, 401)
-  })
-})