@pikku/core 0.12.3 → 0.12.4

package/src/handle-error.test.ts

@@ -1,424 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert'
-import { handleHTTPError } from './handle-error.js'
-import { addError } from './errors/error-handler.js'
-import {
-  NotFoundError,
-  BadRequestError,
-  ForbiddenError,
-} from './errors/errors.js'
-import { resetPikkuState } from './pikku-state.js'
-
-const createMockLogger = () => {
-  const logs: { level: string; args: any[] }[] = []
-  return {
-    info: (...args: any[]) => logs.push({ level: 'info', args }),
-    warn: (...args: any[]) => logs.push({ level: 'warn', args }),
-    error: (...args: any[]) => logs.push({ level: 'error', args }),
-    debug: (...args: any[]) => logs.push({ level: 'debug', args }),
-    _logs: logs,
-  }
-}
-
-const createMockHTTP = () => {
-  const state = {
-    statusCode: undefined as number | undefined,
-    jsonBody: undefined as any,
-    closed: false,
-  }
-  return {
-    request: {},
-    response: {
-      status: (code: number) => {
-        state.statusCode = code
-        return {
-          json: (body: any) => {
-            state.jsonBody = body
-          },
-        }
-      },
-      json: (body: any) => {
-        state.jsonBody = body
-      },
-      close: () => {
-        state.closed = true
-      },
-    },
-    _state: state,
-  }
-}
-
-beforeEach(() => {
-  resetPikkuState()
-})
-
-describe('handleHTTPError', () => {
-  test('should skip NotFoundError when respondWith404 is false', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new NotFoundError()
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-1',
-      logger as any,
-      [],
-      false,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, undefined)
-    assert.strictEqual(http._state.jsonBody, undefined)
-  })
-
-  test('should handle NotFoundError when respondWith404 is true', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new NotFoundError()
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-1',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 404)
-    assert.deepStrictEqual(http._state.jsonBody, {
-      message: 'The server cannot find the requested resource.',
-      payload: undefined,
-      traceId: 'tracker-1',
-    })
-  })
-
-  test('should set correct status and message for known errors', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('Invalid input')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-2',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 400)
-    assert.ok(http._state.jsonBody.message.includes('client error'))
-    assert.strictEqual(http._state.jsonBody.traceId, 'tracker-2')
-  })
-
-  test('should set status 403 for ForbiddenError', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new ForbiddenError()
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-3',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 403)
-  })
-
-  test('should log warning when status code is in logWarningsForStatusCodes', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-4',
-      logger as any,
-      [400],
-      true,
-      false
-    )
-
-    const warns = logger._logs.filter((l) => l.level === 'warn')
-    assert.ok(warns.length >= 1)
-    assert.ok(warns.some((w) => w.args[0].includes('tracker-4')))
-  })
-
-  test('should not log warning when status code is not in logWarningsForStatusCodes', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-5',
-      logger as any,
-      [500],
-      true,
-      false
-    )
-
-    const warns = logger._logs.filter((l) => l.level === 'warn')
-    assert.strictEqual(warns.length, 0)
-  })
-
-  test('should handle unknown errors with 500 status', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new Error('something unexpected')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-6',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    assert.deepStrictEqual(http._state.jsonBody, { errorId: 'tracker-6' })
-  })
-
-  test('should log unknown errors with error level', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new Error('unexpected')
-
-    handleHTTPError(
-      error,
-      http as any,
-      undefined,
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    const errors = logger._logs.filter((l) => l.level === 'error')
-    assert.ok(errors.length >= 1)
-    assert.ok(errors.some((e) => e.args[0] === 'unexpected'))
-  })
-
-  test('should not include errorId in response when trackerId is undefined for unknown errors', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new Error('unexpected')
-
-    handleHTTPError(
-      error,
-      http as any,
-      undefined,
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    assert.strictEqual(http._state.jsonBody, undefined)
-  })
-
-  test('should bubble error when bubbleError is true', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    assert.throws(
-      () =>
-        handleHTTPError(
-          error,
-          http as any,
-          'tracker',
-          logger as any,
-          [],
-          true,
-          true
-        ),
-      (e: any) => e === error
-    )
-  })
-
-  test('should not bubble error when bubbleError is false', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker',
-      logger as any,
-      [],
-      true,
-      false
-    )
-    // Should not throw
-  })
-
-  test('should not call response.close automatically', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.closed, false)
-  })
-
-  test('should handle undefined http gracefully', () => {
-    const logger = createMockLogger()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(error, undefined, 'tracker', logger as any, [], true, false)
-    // Should not throw
-  })
-
-  test('should include payload from error in known error response', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad') as any
-    error.payload = { field: 'email', reason: 'invalid' }
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.deepStrictEqual(http._state.jsonBody.payload, {
-      field: 'email',
-      reason: 'invalid',
-    })
-  })
-
-  test('should handle non-Error objects as errors', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = 'just a string error'
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker',
-      logger as any,
-      [],
-      true,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    const errors = logger._logs.filter((l) => l.level === 'error')
-    assert.ok(errors.some((e) => e.args[0] === 'just a string error'))
-  })
-
-  test('should include message and stack when exposeErrors is true', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new Error('something unexpected')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-expose',
-      logger as any,
-      [],
-      true,
-      false,
-      true
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    assert.strictEqual(http._state.jsonBody.errorId, 'tracker-expose')
-    assert.strictEqual(http._state.jsonBody.message, 'something unexpected')
-    assert.ok(typeof http._state.jsonBody.stack === 'string')
-  })
-
-  test('should not include message and stack when exposeErrors is false', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new Error('something unexpected')
-
-    handleHTTPError(
-      error,
-      http as any,
-      'tracker-no-expose',
-      logger as any,
-      [],
-      true,
-      false,
-      false
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    assert.deepStrictEqual(http._state.jsonBody, {
-      errorId: 'tracker-no-expose',
-    })
-  })
-
-  test('should not expose details for non-Error objects even when exposeErrors is true', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-
-    handleHTTPError(
-      'string error',
-      http as any,
-      'tracker-str',
-      logger as any,
-      [],
-      true,
-      false,
-      true
-    )
-
-    assert.strictEqual(http._state.statusCode, 500)
-    assert.deepStrictEqual(http._state.jsonBody, { errorId: 'tracker-str' })
-  })
-
-  test('should handle warning log without trackerId', () => {
-    const logger = createMockLogger()
-    const http = createMockHTTP()
-    const error = new BadRequestError('bad')
-
-    handleHTTPError(
-      error,
-      http as any,
-      undefined,
-      logger as any,
-      [400],
-      true,
-      false
-    )
-
-    const warns = logger._logs.filter((l) => l.level === 'warn')
-    assert.ok(warns.length >= 1)
-    assert.ok(
-      !warns.some(
-        (w) => typeof w.args[0] === 'string' && w.args[0].includes('Warning id')
-      )
-    )
-  })
-})

package/src/handle-error.ts

@@ -1,69 +0,0 @@
-import { getErrorResponse } from './errors/error-handler.js'
-import { NotFoundError } from './errors/errors.js'
-import type { Logger } from './services/logger.js'
-import type { PikkuHTTP } from './wirings/http/http.types.js'
-
-/**
- * Handle errors that occur during route processing
- *
- * @param {any} e - The error that occurred
- * @param {PikkuHTTP | undefined} http - HTTP wire object
- * @param {string} trackerId - Unique ID for tracking this error
- * @param {Logger} logger - Logger service
- * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings
- * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
- * @param {boolean} bubbleError - Whether to throw the error after handling
- */
-export const handleHTTPError = (
-  e: any,
-  http: PikkuHTTP | undefined,
-  trackerId: string | undefined,
-  logger: Logger,
-  logWarningsForStatusCodes: number[],
-  respondWith404: boolean,
-  bubbleError: boolean,
-  exposeErrors: boolean = false
-) => {
-  // Skip 404 handling if configured to do so
-  if (e instanceof NotFoundError && !respondWith404) {
-    return
-  }
-
-  // Get appropriate error response
-  const errorResponse = getErrorResponse(e)
-  if (errorResponse != null) {
-    // Set status and response body
-    http?.response?.status(errorResponse.status)
-    http?.response?.json({
-      message: errorResponse.message,
-      payload: (e as any).payload,
-      traceId: trackerId,
-    })
-
-    // Log certain status codes as warnings
-    if (logWarningsForStatusCodes.includes(errorResponse.status)) {
-      if (trackerId) {
-        logger.warn(`Warning id: ${trackerId}`)
-      }
-      logger.warn(e instanceof Error ? e.message : e)
-    }
-  } else {
-    // Handle unexpected errors
-    logger.error(e instanceof Error ? e.message : e)
-    http?.response?.status(500)
-
-    if (trackerId) {
-      logger.warn(`Error id: ${trackerId}`)
-      const errorBody: Record<string, unknown> = { errorId: trackerId }
-      if (exposeErrors && e instanceof Error) {
-        errorBody.message = e.message
-        errorBody.stack = e.stack
-      }
-      http?.response?.json(errorBody)
-    }
-  }
-
-  if (bubbleError) {
-    throw e
-  }
-}

package/src/index.ts

@@ -1,118 +0,0 @@
-/**
- * @module @pikku/core
- */
-export type {
-  CommonWireMeta,
-  CoreConfig,
-  CorePikkuMiddleware,
-  CorePikkuMiddlewareConfig,
-  CorePikkuMiddlewareFactory,
-  CorePikkuMiddlewareGroup,
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-  CreateConfig,
-  FunctionMeta,
-  FunctionRuntimeMeta,
-  FunctionServicesMeta,
-  FunctionWiresMeta,
-  FunctionsMeta,
-  FunctionsRuntimeMeta,
-  JSONPrimitive,
-  JSONValue,
-  MakeRequired,
-  MiddlewareMetadata,
-  PermissionMetadata,
-  PickOptional,
-  PickRequired,
-  PikkuAIMiddlewareHooks,
-  PikkuWire,
-  PikkuWiringTypes,
-  RequireAtLeastOne,
-  SerializedError,
-  WireServices,
-} from './types/core.types.js'
-export {
-  pikkuAIMiddleware,
-  pikkuChannelMiddleware,
-  pikkuChannelMiddlewareFactory,
-  pikkuMiddleware,
-  pikkuMiddlewareFactory,
-} from './types/core.types.js'
-export type {
-  CorePikkuAuth,
-  CorePikkuAuthConfig,
-  CorePikkuFunction,
-  CorePikkuFunctionConfig,
-  CorePikkuPermission,
-  CorePikkuPermissionConfig,
-  CorePikkuPermissionFactory,
-  CorePikkuApprovalDescription,
-  CorePermissionGroup,
-  ZodLike,
-} from './function/functions.types.js'
-export {
-  pikkuAuth,
-  pikkuPermission,
-  pikkuPermissionFactory,
-  pikkuApprovalDescription,
-} from './function/functions.types.js'
-export { addFunction, getAllFunctionNames } from './function/index.js'
-export { PikkuRequest } from './pikku-request.js'
-export {
-  getRelativeTimeOffsetFromNow,
-  parseDurationString,
-} from './time-utils.js'
-export type { RelativeTimeInput } from './time-utils.js'
-export {
-  formatVersionedId,
-  isVersionedId,
-  parseVersionedId,
-} from './version.js'
-export { runPikkuFunc } from './function/function-runner.js'
-export { runCLICommand, pikkuCLIRender } from './wirings/cli/cli-runner.js'
-export { fetch } from './wirings/http/http-runner.js'
-export {
-  runMCPTool,
-  runMCPResource,
-  runMCPPrompt,
-} from './wirings/mcp/mcp-runner.js'
-export type {
-  MCPToolResponse,
-  MCPResourceResponse,
-  MCPPromptResponse,
-} from './wirings/mcp/mcp.types.js'
-export { runQueueJob } from './wirings/queue/queue-runner.js'
-export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js'
-export { NotFoundError } from './errors/errors.js'
-export type { EventHubService } from './wirings/channel/eventhub-service.js'
-export type { QueueService } from './wirings/queue/queue.types.js'
-export type { JWTService } from './services/jwt-service.js'
-export type { SecretService } from './services/secret-service.js'
-export type { VariablesService } from './services/variables-service.js'
-export type { ContentService } from './services/content-service.js'
-export type { DeploymentService } from './services/deployment-service.js'
-export type { WorkflowService } from './services/workflow-service.js'
-export type { GatewayService } from './services/gateway-service.js'
-export type { TriggerService } from './services/trigger-service.js'
-export type { SchemaService } from './services/schema-service.js'
-export type { SessionService } from './services/user-session-service.js'
-export type { AIAgentRunnerService } from './services/ai-agent-runner-service.js'
-export type { AIRunStateService } from './services/ai-run-state-service.js'
-export type { AIStorageService } from './services/ai-storage-service.js'
-export type { HTTPMethod } from './wirings/http/http.types.js'
-export type { GraphNodeConfig } from './wirings/workflow/graph/workflow-graph.types.js'
-export { createGraph } from './wirings/workflow/graph/graph-node.js'
-export { workflow as wireWorkflow } from './wirings/workflow/workflow-helpers.js'
-export { wireAddon } from './wirings/rpc/wire-addon.js'
-export type { WireAddonConfig } from './wirings/rpc/wire-addon.js'
-export type { PikkuPackageState } from './types/state.types.js'
-export { runMiddleware, addMiddleware } from './middleware-runner.js'
-export { addPermission } from './permissions.js'
-export { isSerializable, stopSingletonServices } from './utils.js'
-export { getSingletonServices, getCreateWireServices } from './pikku-state.js'
-export {
-  type ScheduledTaskInfo,
-  type ScheduledTaskSummary,
-} from './services/scheduler-service.js'
-export { SchedulerService } from './services/scheduler-service.js'

package/src/internal.ts

@@ -1,6 +0,0 @@
-export { pikkuState, resetPikkuState } from './pikku-state.js'
-export { httpRouter } from './wirings/http/routers/http-router.js'
-export type {
-  CreateSingletonServices,
-  CreateWireServices,
-} from './types/core.types.js'