@pikku/core 0.6.22 → 0.6.24

package/package.json

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

package/src/channel/channel-handler.ts

@@ -144,7 +144,7 @@ export const processMessageHandlers = (
     )
 
     if (routeMeta) {
-      validateSchema(services.logger, data, routeMeta)
+      await validateSchema(services.logger, data, routeMeta)
     }
 
     const hasPermission = await validatePermissions(

package/src/channel/channel-runner.ts

@@ -60,7 +60,7 @@ export const openChannel = async ({
   request,
 }: Pick<CoreAPIChannel<unknown, string>, 'route'> &
   RunChannelParams<unknown> & {
-    userSessionService: UserSessionService<any>
+    userSession: UserSessionService<any>
   } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreAPIChannel<unknown, any>
@@ -86,9 +86,9 @@ export const openChannel = async ({
     if (coerceToArray && schemaName) {
       coerceQueryStringToArray(schemaName, openingData)
     }
-    validateSchema(
+    await validateSchema(
       singletonServices.logger,
-      singletonServices.schemaService,
+      singletonServices.schema,
       schemaName,
       openingData
     )

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

@@ -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) {
@@ -52,7 +52,7 @@ export const runLocalChannel = async ({
         singletonServices,
         skipUserSession,
         coerceToArray,
-        userSessionService,
+        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

@@ -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,
@@ -90,7 +87,7 @@ export const runChannelConnect = async ({
     route,
     singletonServices,
     coerceToArray,
-    userSessionService,
+    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,
@@ -16,7 +20,10 @@ import {
 } from '../errors/errors.js'
 import { closeSessionServices } from '../utils.js'
 import { coerceQueryStringToArray, validateSchema } from '../schema.js'
-import { PikkuUserSessionService } from '../services/user-session-service.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
   },
@@ -214,7 +221,7 @@ const executeRouteWithMiddleware = async (
   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,22 +266,18 @@ const executeRouteWithMiddleware = async (
     const allServices = {
       ...singletonServices,
       ...sessionServices,
+      userSession,
       http,
     }
     const data = await http?.request?.data()
 
     // Validate request data against the defined schema, if any
-    try {
-      console.log(schemaName, data)
-      validateSchema(
-        singletonServices.logger,
-        singletonServices.schemaService,
-        schemaName,
-        data
-      )
-    } catch (e) {
-      // TODO: Implement proper handling for schema validation failures
-    }
+    await validateSchema(
+      singletonServices.logger,
+      singletonServices.schema,
+      schemaName,
+      data
+    )
 
     // Coerce query string parameters to arrays if specified by the schema
     if (options.coerceToArray && schemaName) {
@@ -312,7 +315,7 @@ const executeRouteWithMiddleware = async (
 
   // Execute middleware, then run the main logic
   await runMiddleware(
-    { ...singletonServices, userSessionService },
+    { ...singletonServices, userSession },
     { http },
     middleware,
     runMain
@@ -397,7 +400,7 @@ export const fetchData = async <In, Out>(
     bubbleErrors = false,
   }: RunRouteOptions & RunRouteParams
 ): Promise<Out | void> => {
-  const userSessionService = new PikkuUserSessionService()
+  const userSession = new PikkuUserSessionService()
   let sessionServices: SessionServices<typeof singletonServices> | undefined
   let result: Out
 
@@ -427,7 +430,7 @@ export const fetchData = async <In, Out>(
     ;({ result, sessionServices } = await executeRouteWithMiddleware(
       {
         singletonServices,
-        userSessionService,
+        userSession,
         createSessionServices,
         skipUserSession,
       },

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
 }

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

@@ -0,0 +1,82 @@
+import { describe, test } from 'node:test'
+import assert from 'assert'
+import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js' // Adjust path if needed
+
+describe('PikkuFetchHTTPResponse', () => {
+  test('sets status code', () => {
+    const res = new PikkuFetchHTTPResponse().status(404).toResponse()
+    assert.strictEqual(res.status, 404)
+  })
+
+  test('sets headers', async () => {
+    const res = new PikkuFetchHTTPResponse()
+      .header('X-Test', 'value')
+      .header('X-Multi', ['a', 'b'])
+      .toResponse()
+
+    assert.strictEqual(res.headers.get('X-Test'), 'value')
+    const multi = res.headers.get('X-Multi')?.split(', ')
+    assert.deepEqual(multi, ['a', 'b'])
+  })
+
+  test('sets cookies', () => {
+    const res = new PikkuFetchHTTPResponse()
+      .cookie('token', 'abc123', { httpOnly: true, path: '/' })
+      .cookie('other', 'val', { maxAge: 3600 })
+      .toResponse()
+
+    const setCookieHeader = res.headers.get('Set-Cookie')
+    assert.ok(setCookieHeader)
+
+    const cookies = setCookieHeader!.split(', ')
+    assert.ok(cookies.some((c) => c.startsWith('token=abc123')))
+    assert.ok(cookies.some((c) => c.startsWith('other=val')))
+  })
+
+  test('json sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse()
+      .json({ hello: 'world' })
+      .toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'application/json')
+    const body = await res.json()
+    assert.deepEqual(body, { hello: 'world' })
+  })
+
+  test('text sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse().text('hello').toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'text/plain')
+    const text = await res.text()
+    assert.strictEqual(text, 'hello')
+  })
+
+  test('html sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse().html('<p>hi</p>').toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'text/html')
+    const text = await res.text()
+    assert.strictEqual(text, '<p>hi</p>')
+  })
+
+  test('arrayBuffer sets correct content type', async () => {
+    const buffer = new Uint8Array([1, 2, 3]).buffer
+    const res = new PikkuFetchHTTPResponse().arrayBuffer(buffer).toResponse()
+
+    assert.strictEqual(
+      res.headers.get('Content-Type'),
+      'application/octet-stream'
+    )
+    const body = await res.arrayBuffer()
+    assert.deepEqual(new Uint8Array(body), new Uint8Array([1, 2, 3]))
+  })
+
+  test('redirect sets Location header and status', () => {
+    const res = new PikkuFetchHTTPResponse()
+      .redirect('/login', 301)
+      .toResponse()
+
+    assert.strictEqual(res.status, 301)
+    assert.strictEqual(res.headers.get('Location'), '/login')
+  })
+})