json-rest-api 1.0.21 → 1.0.23

package/tests/fastify-plugin.test.js

@@ -0,0 +1,141 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { Api } from 'hooked-api'
+import { RestApiPlugin, FastifyPlugin } from '../index.js'
+import {
+  FakeFastifyApp,
+  FakeReply,
+  findFastifyRoute
+} from './helpers/fake-fastify.js'
+
+async function createFastifyConnectorApi () {
+  const app = new FakeFastifyApp()
+  const api = new Api({
+    name: 'fastify-connector-test-api',
+    log: { level: process.env.LOG_LEVEL || 'silent' }
+  })
+
+  await api.use(RestApiPlugin, {
+    simplifiedApi: false,
+    simplifiedTransport: false
+  })
+
+  await api.use(FastifyPlugin, {
+    app,
+    mountPath: '/api'
+  })
+
+  await api.addResource('users', {
+    schema: {
+      id: { type: 'id' },
+      name: { type: 'string', required: true }
+    }
+  })
+
+  await api.addResource('articles', {
+    schema: {
+      id: { type: 'id' },
+      title: { type: 'string', required: true },
+      body: { type: 'string' },
+      author_id: { type: 'id', belongsTo: 'users', as: 'author' },
+      internal_summary: { type: 'string', computed: true }
+    }
+  })
+
+  return { api, app }
+}
+
+describe('Fastify Plugin', () => {
+  let api
+  let app
+
+  beforeEach(async () => {
+    ({ api, app } = await createFastifyConnectorApi())
+  })
+
+  it('registers Fastify write routes with schema-backed JSON:API body validation', () => {
+    const postRoute = findFastifyRoute(app, 'POST', '/api/articles')
+    const putRoute = findFastifyRoute(app, 'PUT', '/api/articles/:id')
+    const patchRoute = findFastifyRoute(app, 'PATCH', '/api/articles/:id')
+    const getRoute = findFastifyRoute(app, 'GET', '/api/articles/:id')
+    const postRelationshipRoute = findFastifyRoute(app, 'POST', '/api/articles/:id/relationships/:relationshipName')
+    const patchRelationshipRoute = findFastifyRoute(app, 'PATCH', '/api/articles/:id/relationships/:relationshipName')
+    const deleteRelationshipRoute = findFastifyRoute(app, 'DELETE', '/api/articles/:id/relationships/:relationshipName')
+
+    assert.ok(postRoute?.schema?.body, 'POST route should have a body schema')
+    assert.ok(putRoute?.schema?.body, 'PUT route should have a body schema')
+    assert.ok(patchRoute?.schema?.body, 'PATCH route should have a body schema')
+    assert.equal(getRoute?.schema, undefined, 'GET route should not have a body schema')
+    assert.ok(postRelationshipRoute?.schema?.body, 'POST relationship route should have a body schema')
+    assert.ok(patchRelationshipRoute?.schema?.body, 'PATCH relationship route should have a body schema')
+    assert.ok(deleteRelationshipRoute?.schema?.body, 'DELETE relationship route should have a body schema')
+
+    const postDataSchema = postRoute.schema.body.properties.data
+    const postAttributes = postDataSchema.properties.attributes
+
+    assert.deepEqual(postDataSchema.required, ['type'])
+    assert.equal(postAttributes.properties.title.type, 'string')
+    assert.equal(postAttributes.properties.author_id, undefined, 'belongsTo foreign key should not be accepted in attributes')
+    assert.equal(postAttributes.properties.internal_summary, undefined, 'computed fields should not be accepted in attributes')
+    assert.equal(postAttributes.properties.id, undefined, 'resource ids should not appear in attributes')
+    assert.ok(postDataSchema.properties.relationships.properties.author, 'declared belongsTo relationships should be represented in the transport schema')
+
+    const putDataSchema = putRoute.schema.body.properties.data
+    assert.ok(putDataSchema.required.includes('id'), 'PUT body schema should require data.id')
+
+    const patchDataSchema = patchRoute.schema.body.properties.data
+    assert.ok(Array.isArray(patchDataSchema.anyOf), 'PATCH body schema should require at least one writable section')
+    assert.deepEqual(patchDataSchema.anyOf, [
+      { required: ['attributes'] },
+      { required: ['relationships'] }
+    ])
+
+    assert.equal(postRelationshipRoute.schema.body.properties.data.type, 'array')
+    assert.ok(Array.isArray(patchRelationshipRoute.schema.body.properties.data.anyOf))
+    assert.equal(deleteRelationshipRoute.schema.body.properties.data.type, 'array')
+  })
+
+  it('registers the JSON:API content-type parser and rejects unsupported write content types before the route handler', async () => {
+    const parser = app.parsers.find((entry) => entry.contentType === 'application/vnd.api+json')
+    assert.ok(parser, 'Fastify connector should register the JSON:API parser')
+    assert.deepEqual(parser.options, { parseAs: 'string' })
+
+    const postRoute = findFastifyRoute(app, 'POST', '/api/articles')
+    const reply = new FakeReply()
+
+    await postRoute.preValidation(
+      { headers: { 'content-type': 'text/plain' } },
+      reply
+    )
+
+    assert.equal(reply.statusCode, 415)
+    assert.equal(reply.contentType, 'application/vnd.api+json')
+    assert.deepEqual(reply.payload, {
+      errors: [{
+        status: '415',
+        title: 'Unsupported Media Type',
+        detail: 'Content-Type must be application/vnd.api+json or application/json'
+      }]
+    })
+
+    const multipartReply = new FakeReply()
+    await postRoute.preValidation(
+      { headers: { 'content-type': 'multipart/form-data; boundary=test' } },
+      multipartReply
+    )
+
+    assert.equal(multipartReply.statusCode, 415)
+  })
+
+  it('leaves custom routes unschematized when they do not provide route metadata', async () => {
+    await api.addRoute({
+      method: 'POST',
+      path: '/api/custom-endpoint',
+      handler: async () => ({ ok: true })
+    })
+
+    const customRoute = findFastifyRoute(app, 'POST', '/api/custom-endpoint')
+    assert.ok(customRoute)
+    assert.equal(customRoute.schema, undefined)
+  })
+})

package/tests/field-getters.test.js

@@ -62,14 +62,13 @@ describe('Field Getters', () => {
     it('should handle null and undefined values', async () => {
       const user = await api.resources.users.post({
         email: null,
-        name: undefined,
         phone: null,
         metadata_json: null,
         tags_csv: null
       })
 
       assert.equal(user.email, undefined) // null?.toLowerCase().trim() returns undefined
-      assert.equal(user.name, undefined) // undefined is passed, getter returns undefined
+      assert.equal(user.name, undefined) // omitted nullable field remains unset
       assert.equal(user.phone, null) // getter explicitly returns null for falsy values
       assert.deepEqual(user.metadata_json, {})
       assert.deepEqual(user.tags_csv, [])

package/tests/field-setters.test.js

@@ -132,9 +132,6 @@ describe('Field Setters', () => {
         data: 'sensitive information'
       })
 
-      console.log('**********************************************')
-      console.log(record)
-      // Check if record has id
       assert.ok(record.id, 'Record should have an id')
 
       // Get the record to verify async setters were applied
@@ -222,7 +219,6 @@ describe('Field Setters', () => {
     it('should handle null and undefined values in setters', async () => {
       const data = await api.resources.nullable_data.post({
         field1: null,
-        field2: undefined,
         field3: '',
         field4: 0
       })