@pikku/core 0.6.23 → 0.6.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.6.23",
+  "version": "0.6.25",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/channel/channel-runner.ts

@@ -1,6 +1,6 @@
 import { NotFoundError } from '../errors/errors.js'
 import { pikkuState } from '../pikku-state.js'
-import { coerceQueryStringToArray, validateSchema } from '../schema.js'
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
 import { UserSessionService } from '../services/user-session-service.js'
 import {
   CoreAPIChannel,
@@ -56,11 +56,11 @@ export const getMatchingChannelConfig = (request: string) => {
 export const openChannel = async ({
   route,
   singletonServices,
-  coerceToArray = false,
+  coerceDataFromSchema = true,
   request,
 }: Pick<CoreAPIChannel<unknown, string>, 'route'> &
   RunChannelParams<unknown> & {
-    userSessionService: UserSessionService<any>
+    userSession: UserSessionService<any>
   } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreAPIChannel<unknown, any>
@@ -83,12 +83,12 @@ export const openChannel = async ({
   let openingData: any | undefined
   if (request) {
     openingData = await request.data()
-    if (coerceToArray && schemaName) {
-      coerceQueryStringToArray(schemaName, openingData)
+    if (coerceDataFromSchema && schemaName) {
+      coerceTopLevelDataFromSchema(schemaName, openingData)
     }
     await validateSchema(
       singletonServices.logger,
-      singletonServices.schemaService,
+      singletonServices.schema,
       schemaName,
       openingData
     )

package/src/channel/channel.types.ts

@@ -16,7 +16,7 @@ import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js'
 export type RunChannelOptions = Partial<{
   skipUserSession: boolean
   respondWith404: boolean
-  coerceToArray: boolean
+  coerceDataFromSchema: boolean
   logWarningsForStatusCodes: number[]
   bubbleErrors: boolean
 }>

package/src/channel/local/local-channel-runner.test.ts

@@ -149,8 +149,6 @@ test('runChannel should return a channel handler if channel matches and no auth
     createSessionServices: mockCreateSessionServices,
   })
 
-  console.log(result)
-
   assert.ok(result, 'Should return a PikkuChannelHandler instance')
 
   // Simulate opening the channel

package/src/channel/local/local-channel-runner.ts

@@ -23,7 +23,7 @@ export const runLocalChannel = async ({
   createSessionServices,
   skipUserSession = false,
   respondWith404 = true,
-  coerceToArray = false,
+  coerceDataFromSchema = true,
   logWarningsForStatusCodes = [],
   bubbleErrors = false,
 }: Partial<Pick<CoreAPIChannel<unknown, any>, 'route'>> &
@@ -32,7 +32,7 @@ export const runLocalChannel = async ({
   let sessionServices: SessionServices<typeof singletonServices> | undefined
 
   let channelHandler: PikkuLocalChannelHandler | undefined
-  const userSessionService = new PikkuUserSessionService()
+  const userSession = new PikkuUserSessionService()
 
   let http: PikkuHTTP | undefined
   if (request) {
@@ -51,8 +51,8 @@ export const runLocalChannel = async ({
         route,
         singletonServices,
         skipUserSession,
-        coerceToArray,
-        userSessionService,
+        coerceDataFromSchema,
+        userSession,
       })
 
       channelHandler = new PikkuLocalChannelHandler(
@@ -61,7 +61,7 @@ export const runLocalChannel = async ({
         openingData
       )
       const channel = channelHandler.getChannel()
-      const session = await userSessionService.get()
+      const session = await userSession.get()
       if (createSessionServices) {
         sessionServices = await createSessionServices(
           singletonServices,
@@ -73,7 +73,7 @@ export const runLocalChannel = async ({
       const allServices = {
         ...singletonServices,
         ...sessionServices,
-        userSession: userSessionService,
+        userSession: userSession,
       }
 
       channelHandler.registerOnOpen(() => {
@@ -115,7 +115,7 @@ export const runLocalChannel = async ({
   await runMiddleware(
     {
       ...singletonServices,
-      userSessionService,
+      userSession,
     },
     { http },
     route.middleware || [],

package/src/channel/serverless/serverless-channel-runner.ts

@@ -64,7 +64,7 @@ export const runChannelConnect = async ({
   createSessionServices,
   channelStore,
   channelHandlerFactory,
-  coerceToArray = false,
+  coerceDataFromSchema = true,
   logWarningsForStatusCodes = [],
   respondWith404 = true,
   bubbleErrors = false,
@@ -78,10 +78,7 @@ export const runChannelConnect = async ({
     http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response)
   }
 
-  const userSessionService = new PikkuUserSessionService(
-    channelStore,
-    channelId
-  )
+  const userSession = new PikkuUserSessionService(channelStore, channelId)
 
   const { channelConfig, openingData } = await openChannel({
     channelId,
@@ -89,8 +86,8 @@ export const runChannelConnect = async ({
     request,
     route,
     singletonServices,
-    coerceToArray,
-    userSessionService,
+    coerceDataFromSchema,
+    userSession,
   })
 
   const main = async () => {
@@ -110,7 +107,7 @@ export const runChannelConnect = async ({
         sessionServices = await createSessionServices(
           singletonServices,
           { http },
-          await userSessionService.get()
+          await userSession.get()
         )
       }
       await channelConfig.onConnect?.(
@@ -138,7 +135,7 @@ export const runChannelConnect = async ({
   await runMiddleware(
     {
       ...singletonServices,
-      userSessionService,
+      userSession,
     },
     { http },
     channelConfig.middleware || [],

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

@@ -10,7 +10,7 @@ import {
 } from '../channel/local/local-channel-runner.test.js'
 
 const sessionMiddleware: PikkuMiddleware = async (services, _, next) => {
-  services.userSessionService.set({ userId: 'test' } as any)
+  services.userSession.set({ userId: 'test' } as any)
   await next()
 }
 

package/src/http/http-route-runner.ts

@@ -7,7 +7,11 @@ import {
   PikkuHTTPRequest,
   PikkuHTTPResponse,
 } from './http-routes.types.js'
-import { PikkuMiddleware, SessionServices } from '../types/core.types.js'
+import {
+  CoreUserSession,
+  PikkuMiddleware,
+  SessionServices,
+} from '../types/core.types.js'
 import { match } from 'path-to-regexp'
 import {
   ForbiddenError,
@@ -15,8 +19,11 @@ import {
   NotFoundError,
 } from '../errors/errors.js'
 import { closeSessionServices } from '../utils.js'
-import { coerceQueryStringToArray, validateSchema } from '../schema.js'
-import { PikkuUserSessionService } from '../services/user-session-service.js'
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
+import {
+  PikkuUserSessionService,
+  UserSessionService,
+} from '../services/user-session-service.js'
 import { runMiddleware } from '../middleware-runner.js'
 import { handleError } from '../handle-error.js'
 import { pikkuState } from '../pikku-state.js'
@@ -195,7 +202,7 @@ export const createHTTPInteraction = (
 const executeRouteWithMiddleware = async (
   services: {
     singletonServices: any
-    userSessionService: any
+    userSession: UserSessionService<CoreUserSession>
     createSessionServices: Function
     skipUserSession: boolean
   },
@@ -208,13 +215,13 @@ const executeRouteWithMiddleware = async (
   },
   http: PikkuHTTP | undefined,
   options: {
-    coerceToArray: boolean
+    coerceDataFromSchema: boolean
   }
 ) => {
   const { matchedPath, params, route, middleware, schemaName } = matchedRoute
   const {
     singletonServices,
-    userSessionService,
+    userSession,
     createSessionServices,
     skipUserSession,
   } = services
@@ -232,7 +239,7 @@ const executeRouteWithMiddleware = async (
 
   // Main route execution logic wrapped for middleware handling
   const runMain = async () => {
-    const session = userSessionService.get()
+    const session = userSession.get()
 
     // Ensure session is available when required
     if (skipUserSession && requiresSession) {
@@ -251,7 +258,7 @@ const executeRouteWithMiddleware = async (
 
     // Create session-specific services for handling the request
     sessionServices = await createSessionServices(
-      { ...singletonServices, userSessionService },
+      { ...singletonServices, userSession },
       { http },
       session
     )
@@ -259,6 +266,7 @@ const executeRouteWithMiddleware = async (
     const allServices = {
       ...singletonServices,
       ...sessionServices,
+      userSession,
       http,
     }
     const data = await http?.request?.data()
@@ -266,14 +274,14 @@ const executeRouteWithMiddleware = async (
     // Validate request data against the defined schema, if any
     await validateSchema(
       singletonServices.logger,
-      singletonServices.schemaService,
+      singletonServices.schema,
       schemaName,
       data
     )
 
-    // Coerce query string parameters to arrays if specified by the schema
-    if (options.coerceToArray && schemaName) {
-      coerceQueryStringToArray(schemaName, data)
+    // Coerce (top level) query string parameters or date objects if specified by the schema
+    if (options.coerceDataFromSchema && schemaName) {
+      coerceTopLevelDataFromSchema(schemaName, data)
     }
 
     // Execute permission checks
@@ -307,7 +315,7 @@ const executeRouteWithMiddleware = async (
 
   // Execute middleware, then run the main logic
   await runMiddleware(
-    { ...singletonServices, userSessionService },
+    { ...singletonServices, userSession },
     { http },
     middleware,
     runMain
@@ -388,11 +396,11 @@ export const fetchData = async <In, Out>(
     skipUserSession = false,
     respondWith404 = true,
     logWarningsForStatusCodes = [],
-    coerceToArray = false,
+    coerceDataFromSchema = true,
     bubbleErrors = false,
   }: RunRouteOptions & RunRouteParams
 ): Promise<Out | void> => {
-  const userSessionService = new PikkuUserSessionService()
+  const userSession = new PikkuUserSessionService()
   let sessionServices: SessionServices<typeof singletonServices> | undefined
   let result: Out
 
@@ -422,13 +430,13 @@ export const fetchData = async <In, Out>(
     ;({ result, sessionServices } = await executeRouteWithMiddleware(
       {
         singletonServices,
-        userSessionService,
+        userSession,
         createSessionServices,
         skipUserSession,
       },
       matchedRoute,
       http,
-      { coerceToArray }
+      { coerceDataFromSchema }
     ))
 
     return result

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

@@ -30,7 +30,7 @@ export type RunRouteOptions = Partial<{
   skipUserSession: boolean
   respondWith404: boolean
   logWarningsForStatusCodes: number[]
-  coerceToArray: boolean
+  coerceDataFromSchema: boolean
   bubbleErrors: boolean
 }>
 

package/src/http/pikku-fetch-http-request.test.ts

@@ -0,0 +1,237 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request'
+
+const createRequest = (method, url, body, headers = {}) => {
+  return new Request(url, {
+    method,
+    headers,
+    body:
+      method === 'POST'
+        ? typeof body === 'string'
+          ? body
+          : JSON.stringify(body)
+        : undefined,
+  })
+}
+
+test('method() returns lowercase HTTP method', () => {
+  const req = createRequest('POST', 'http://localhost/test', null)
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.equal(pikkuReq.method(), 'post')
+})
+
+test('path() returns pathname only', () => {
+  const req = createRequest('GET', 'http://localhost/foo/bar?x=1', null)
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.equal(pikkuReq.path(), '/foo/bar')
+})
+
+test('header() retrieves headers case-insensitively', () => {
+  const req = createRequest('GET', 'http://localhost', null, {
+    'Content-Type': 'application/json',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.equal(pikkuReq.header('content-type'), 'application/json')
+})
+
+test('cookie() parses cookies correctly', () => {
+  const req = createRequest('GET', 'http://localhost', null, {
+    Cookie: 'session=abc; user=test',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.equal(pikkuReq.cookie('session'), 'abc')
+  assert.equal(pikkuReq.cookie('user'), 'test')
+  assert.equal(pikkuReq.cookie('missing'), null)
+})
+
+test('params() and setParams()', () => {
+  const req = createRequest('GET', 'http://localhost', null)
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.deepEqual(pikkuReq.params(), {})
+  pikkuReq.setParams({ id: '123' })
+  assert.deepEqual(pikkuReq.params(), { id: '123' })
+})
+
+test('query() parses URL search params', () => {
+  const req = createRequest('GET', 'http://localhost?x=1&y=2', null)
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.equal(pikkuReq.query().x, '1')
+  assert.equal(pikkuReq.query().y, '2')
+})
+
+test('data() merges json body, query, and params', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost/test?a=5',
+    { foo: 'bar' },
+    { 'Content-Type': 'application/json' }
+  )
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  pikkuReq.setParams({ id: '22' })
+  const result = await pikkuReq.data()
+  assert.deepEqual(result, { id: '22', a: '5', foo: 'bar' })
+})
+
+test('data() wraps string JSON body under data key', async () => {
+  const req = createRequest('POST', 'http://localhost', '"hello"', {
+    'Content-Type': 'application/json',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  const result = await pikkuReq.data()
+  assert.deepEqual(result, { data: 'hello' })
+})
+
+test('data() handles text/plain correctly', async () => {
+  const req = new Request('http://localhost', {
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'hello world',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  const result = await pikkuReq.data()
+  assert.deepEqual(result, { data: 'hello world' })
+})
+
+test('data() returns arrayBuffer for unknown content-type', async () => {
+  const buffer = Buffer.from('raw')
+  const req = new Request('http://localhost', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: buffer,
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest<any>(req)
+  const result = await pikkuReq.data()
+  assert(result.data instanceof ArrayBuffer)
+  const str = Buffer.from(result.data).toString()
+  assert.equal(str, 'raw')
+})
+
+test('data() handles invalid JSON safely', async () => {
+  const req = new Request('http://localhost', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: 'not-json',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  try {
+    await pikkuReq.data()
+    assert(false, 'Should have thrown')
+  } catch (e) {
+    assert(e.message.includes('Error parsing body'))
+  }
+})
+
+test('data() parses application/x-www-form-urlencoded correctly', async () => {
+  const formBody = 'name=Yasser&age=35&active=true'
+
+  const req = new Request('http://localhost/form?ref=abc', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: formBody,
+  })
+
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  pikkuReq.setParams({ userId: '999' })
+
+  const result = await pikkuReq.data()
+
+  assert.deepEqual(result, {
+    userId: '999',
+    ref: 'abc',
+    name: 'Yasser',
+    age: '35',
+    active: 'true',
+  })
+})
+
+// --- Compatible types
+
+test('data() treats "123" and 123 as equivalent', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost?id=123',
+    { id: 123 },
+    {
+      'Content-Type': 'application/json',
+    }
+  )
+
+  const r = new PikkuFetchHTTPRequest(req)
+  r.setParams({ id: '123' }) // All match
+  const result = await r.data()
+  assert.deepEqual(result, { id: '123' })
+})
+
+test('data() treats "true" and true as equivalent', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost?flag=true',
+    { flag: true },
+    {
+      'Content-Type': 'application/json',
+    }
+  )
+
+  const r = new PikkuFetchHTTPRequest(req)
+  r.setParams({ flag: 'true' }) // All match
+  const result = await r.data()
+  assert.deepEqual(result, { flag: 'true' })
+})
+
+// --- Conflicts
+
+test('data() throws on conflicting values', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost?foo=123',
+    { foo: 456 },
+    {
+      'Content-Type': 'application/json',
+    }
+  )
+
+  const r = new PikkuFetchHTTPRequest(req)
+  r.setParams({ foo: '123' })
+
+  await assert.rejects(async () => await r.data(), {
+    message: 'Conflicting values for key "foo": "123" vs "456"',
+  })
+})
+
+test('data() throws on boolean conflict', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost?debug=false',
+    { debug: true },
+    {
+      'Content-Type': 'application/json',
+    }
+  )
+
+  const r = new PikkuFetchHTTPRequest(req)
+  r.setParams({})
+
+  await assert.rejects(async () => await r.data(), {
+    message: 'Conflicting values for key "debug": "false" vs "true"',
+  })
+})
+
+// --- Safe fallback: only one source
+
+test('data() works when only body has values', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost',
+    { test: 'ok' },
+    {
+      'Content-Type': 'application/json',
+    }
+  )
+
+  const r = new PikkuFetchHTTPRequest(req)
+  const result = await r.data()
+  assert.deepEqual(result, { test: 'ok' })
+})

package/src/http/pikku-fetch-http-request.ts

@@ -5,6 +5,7 @@ import {
   PikkuHTTPRequest,
   PikkuQuery,
 } from './http-routes.types.js'
+import { UnprocessableContentError } from '../errors/errors.js'
 
 /**
  * Abstract class representing a pikku request.
@@ -96,16 +97,71 @@ export class PikkuFetchHTTPRequest<In = unknown>
    * @returns A promise that resolves to an object containing the combined data.
    */
   public async data(): Promise<In> {
+    const body = await this.body()
+    const parts = [this.params(), this.query(), body]
+    const merged: Record<string, unknown> = {}
+    for (const part of parts) {
+      for (const [key, value] of Object.entries(part)) {
+        if (key in merged && !valuesAreEquivalent(merged[key], value)) {
+          throw new UnprocessableContentError(
+            `Conflicting values for key "${key}": "${merged[key]}" vs "${value}"`
+          )
+        }
+        merged[key] ??= value
+      }
+    }
+    return merged as In
+  }
+
+  private async body(): Promise<any> {
+    const noBodyMethods: HTTPMethod[] = ['get', 'head', 'options']
+    if (noBodyMethods.includes(this.method())) {
+      return {}
+    }
+
     let body: any = {}
+    const contentType = this.header('content-type') || ''
     try {
-      body = await this.json()
-    } catch (e) {}
-
-    return {
-      ...this.params(),
-      ...this.query(),
-      // TODO: If body isn't an object, we should insert it as the word...
-      ...body,
+      if (contentType.includes('application/json')) {
+        const parsed = await this.json()
+        body =
+          typeof parsed === 'object' &&
+          parsed !== null &&
+          !Array.isArray(parsed)
+            ? parsed
+            : { data: parsed }
+      } else if (contentType.includes('text/')) {
+        const text = await this.request.text()
+        body = { data: text }
+      } else if (contentType.includes('application/octet-stream')) {
+        const buffer = await this.request.arrayBuffer()
+        body = { data: buffer }
+      } else if (contentType === 'application/x-www-form-urlencoded') {
+        const text = await this.request.text()
+        body = Object.fromEntries(new URLSearchParams(text))
+      } else {
+        throw new UnprocessableContentError(
+          `Unsupported content type ${contentType}`
+        )
+      }
+    } catch (e) {
+      throw new UnprocessableContentError(`Error parsing body: ${e}`)
     }
+    return body
+  }
+}
+
+function valuesAreEquivalent(a: unknown, b: unknown): boolean {
+  return coerce(a) === coerce(b)
+}
+
+function coerce(value: unknown): string | number | boolean {
+  if (typeof value === 'boolean' || typeof value === 'number') return value
+  if (typeof value === 'string') {
+    if (value === 'true') return true
+    if (value === 'false') return false
+    const num = Number(value)
+    return isNaN(num) ? value : num
   }
+  return value as any
 }