json-rest-api 1.0.28 → 2.0.0

package/tests/fastify-plugin.test.js

@@ -1,184 +0,0 @@
-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 { getRequestContracts } from '../plugins/core/lib/querying-writing/request-contracts.js'
-import {
-  FakeFastifyApp,
-  FakeReply,
-  findFastifyRoute
-} from './helpers/fake-fastify.js'
-
-function resolveSchemaNode (rootSchema, schemaNode) {
-  if (!schemaNode || !Array.isArray(schemaNode.allOf) || schemaNode.allOf.length !== 1) {
-    return schemaNode
-  }
-
-  const ref = schemaNode.allOf[0]?.$ref || ''
-  if (!ref.startsWith('#/definitions/')) {
-    return schemaNode
-  }
-
-  const definitionName = ref.slice('#/definitions/'.length)
-  return rootSchema?.definitions?.[definitionName] || schemaNode
-}
-
-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')
-    const relationshipContracts = getRequestContracts({
-      scopeName: 'articles',
-      schemaInfo: api.resources.articles.vars.schemaInfo,
-      includeDepthLimit: api.resources.articles.vars.includeDepthLimit,
-      sortableFields: api.resources.articles.vars.sortableFields
-    })
-
-    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 = resolveSchemaNode(postRoute.schema.body, 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')
-    const postRelationships = resolveSchemaNode(postRoute.schema.body, postDataSchema.properties.relationships)
-    assert.ok(postRelationships.properties.author, 'declared belongsTo relationships should be represented in the transport schema')
-
-    const putDataSchema = resolveSchemaNode(putRoute.schema.body, putRoute.schema.body.properties.data)
-    assert.ok(putDataSchema.required.includes('id'), 'PUT body schema should require data.id')
-
-    const patchDataSchemaNode = patchRoute.schema.body.properties.data
-    assert.ok(Array.isArray(patchDataSchemaNode.anyOf), 'PATCH body schema should require at least one writable section')
-    assert.deepEqual(patchDataSchemaNode.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')
-    assert.deepEqual(
-      postRelationshipRoute.schema.body,
-      relationshipContracts.postRelationship.schema.toJsonSchema({
-        mode: relationshipContracts.postRelationship.mode,
-        additionalProperties: false
-      })
-    )
-    assert.deepEqual(
-      patchRelationshipRoute.schema.body,
-      relationshipContracts.patchRelationship.schema.toJsonSchema({
-        mode: relationshipContracts.patchRelationship.mode,
-        additionalProperties: false
-      })
-    )
-    assert.deepEqual(
-      deleteRelationshipRoute.schema.body,
-      relationshipContracts.deleteRelationship.schema.toJsonSchema({
-        mode: relationshipContracts.deleteRelationship.mode,
-        additionalProperties: false
-      })
-    )
-  })
-
-  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

@@ -1,370 +0,0 @@
-import { describe, it, before, beforeEach, after } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import { createFieldGettersApi } from './fixtures/api-configs.js'
-import { cleanTables } from './helpers/test-utils.js'
-import { storageMode } from './helpers/storage-mode.js'
-
-// Create Knex instance for tests
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-// API instance that persists across tests
-let api
-
-describe('Field Getters', () => {
-  before(async () => {
-    // Initialize API once
-    api = await createFieldGettersApi(knex)
-  })
-
-  after(async () => {
-    // Close database connection to allow tests to exit
-    await knex.destroy()
-  })
-
-  describe('Basic Field Transformations', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, ['getter_users'])
-    })
-
-    it('should apply simple getter transformations', async () => {
-      // Create user with data that needs transformation
-      const user = await api.resources.users.post({
-        email: '  USER@EXAMPLE.COM  ',
-        name: '  John Doe  ',
-        phone: '1234567890',
-        metadata_json: '{"key": "value", "num": 123}',
-        tags_csv: 'tag1, tag2, tag3'
-      })
-
-      // Check transformations applied on create
-      assert.equal(user.email, 'user@example.com')
-      assert.equal(user.name, 'John Doe')
-      assert.equal(user.phone, '(123) 456-7890')
-      assert.deepEqual(user.metadata_json, { key: 'value', num: 123 })
-      assert.deepEqual(user.tags_csv, ['tag1', 'tag2', 'tag3'])
-
-      // Verify getters apply on fetch too
-      const fetched = await api.resources.users.get({ id: user.id })
-      assert.equal(fetched.email, 'user@example.com')
-      assert.equal(fetched.name, 'John Doe')
-      assert.equal(fetched.phone, '(123) 456-7890')
-      assert.deepEqual(fetched.metadata_json, { key: 'value', num: 123 })
-      assert.deepEqual(fetched.tags_csv, ['tag1', 'tag2', 'tag3'])
-    })
-
-    it('should handle null and undefined values', async () => {
-      const user = await api.resources.users.post({
-        email: null,
-        phone: null,
-        metadata_json: null,
-        tags_csv: null
-      })
-
-      assert.equal(user.email, undefined) // null?.toLowerCase().trim() 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, [])
-    })
-
-    it('should handle invalid data gracefully', async () => {
-      const user = await api.resources.users.post({
-        email: '  mixed@CASE.com  ',
-        name: '   ',
-        phone: '123', // Too short
-        metadata_json: 'invalid json',
-        tags_csv: ', , empty, , values, '
-      })
-
-      assert.equal(user.email, 'mixed@case.com')
-      assert.equal(user.name, '')
-      assert.equal(user.phone, '123') // Unchanged when can't format
-      assert.deepEqual(user.metadata_json, {}) // Empty object on parse error
-      assert.deepEqual(user.tags_csv, ['empty', 'values']) // Filters empty values
-    })
-  })
-
-  describe('Getters with Computed Fields', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, ['getter_products'])
-    })
-
-    it('should apply getters before computed fields', async () => {
-      const product = await api.resources.products.post({
-        name: 'widget',
-        description: 'This is a very long product description that should be truncated',
-        price_str: '100.00',
-        tax_rate_str: '0.20'
-      })
-
-      // Getters should transform values
-      assert.equal(product.name, 'WIDGET')
-      assert.equal(product.description, 'This is a very long product description that sh...')
-      assert.equal(typeof product.price_str, 'number')
-      assert.equal(product.price_str, 100)
-      assert.equal(product.tax_rate_str, 0.20)
-
-      // Computed field should see getter-transformed values
-      assert.equal(product.total_price, 120)
-    })
-
-    it('should work with sparse fieldsets', async () => {
-      const product = await api.resources.products.post({
-        name: 'another widget',
-        description: 'Short desc',
-        price_str: '50.00',
-        tax_rate_str: '0.10'
-      })
-
-      // Fetch with sparse fieldsets
-      const sparse = await api.resources.products.get({
-        id: product.id,
-        queryParams: {
-          fields: { products: 'name,total_price' }
-        }
-      })
-
-      assert.equal(sparse.name, 'ANOTHER WIDGET')
-      assert.ok(Math.abs(sparse.total_price - 55) < 0.0001, `Expected total_price to be ~55, got ${sparse.total_price}`)
-      assert.equal(sparse.description, undefined)
-      assert.equal(sparse.price_str, undefined)
-    })
-  })
-
-  describe('Getter Dependencies', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, ['getter_formatted'])
-    })
-
-    it('should apply getters in dependency order', async () => {
-      const data = await api.resources.formatted_data.post({
-        step1: '  hello  ',
-        step2: 'world',
-        step3: 'end'
-      })
-
-      // Check that getters ran in order
-      assert.equal(data.step1, 'hello') // Trimmed
-      assert.equal(data.step2, 'world [step1: hello]') // Sees trimmed step1
-      assert.equal(data.step3, 'end [step2: world [step1: hello]]') // Sees processed step2
-    })
-
-    it('should handle missing dependencies gracefully', async () => {
-      const data = await api.resources.formatted_data.post({
-        step3: 'only step3'
-        // step1 and step2 are missing
-      })
-
-      assert.equal(data.step1, undefined)
-      assert.equal(data.step2, null)
-      assert.equal(data.step3, 'only step3 [step2: null]')
-    })
-  })
-
-  describe('Async Getters', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, ['getter_encrypted'])
-    })
-
-    it('should support async getter functions', async () => {
-      // Helper to simulate encryption
-      const encrypt = (value) => Buffer.from(value).toString('base64')
-
-      const payload = {
-        secret: encrypt('my-secret-value'),
-        data: encrypt('sensitive-info')
-      }
-
-      let id
-      if (storageMode.isAnyApi()) {
-        // AnyAPI mode stores records in canonical slots, so use the API to ensure persistence
-        const created = await api.resources.encrypted_data.post(payload)
-        id = created.id
-      } else {
-        // Legacy mode can insert directly into the backing table for the same effect
-        const inserted = await knex('getter_encrypted')
-          .insert(payload)
-          .returning('id')
-          .then((rows) => rows)
-        const first = Array.isArray(inserted) ? inserted[0] : inserted
-        id = typeof first === 'object' && first !== null ? first.id : first
-      }
-
-      // Fetch should decrypt via async getters
-      const record = await api.resources.encrypted_data.get({ id })
-      assert.equal(record.secret, 'my-secret-value')
-      assert.equal(record.data, '[encrypted_data] sensitive-info')
-    })
-
-    it('should handle null values in async getters', async () => {
-      const record = await api.resources.encrypted_data.post({
-        secret: null,
-        data: null
-      })
-
-      assert.equal(record.secret, null)
-      assert.equal(record.data, null)
-    })
-  })
-
-  describe('Getters in Included Resources', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, ['getter_products', 'getter_reviews'])
-    })
-
-    it('should apply getters to included resources', async () => {
-      const product = await api.resources.products.post({
-        name: 'test product',
-        description: 'A product',
-        price_str: '99.99',
-        tax_rate_str: '0'
-      })
-
-      // Add reviews
-      await api.resources.reviews.post({
-        product: product.id,
-        content: 'Great product!',
-        rating: 5
-      })
-
-      await api.resources.reviews.post({
-        product: product.id,
-        content: 'Not bad',
-        rating: 3
-      })
-
-      // Fetch with includes
-      const result = await api.resources.products.get({
-        id: product.id,
-        queryParams: {
-          include: ['reviews']
-        }
-      })
-
-      // Product getters should apply
-      assert.equal(result.name, 'TEST PRODUCT')
-
-      // Review getters should apply to included resources
-      assert.equal(result.reviews.length, 2)
-      assert.equal(result.reviews[0].content, '[REVIEW] Great product!')
-      assert.equal(result.reviews[1].content, '[REVIEW] Not bad')
-    })
-
-    it('should work with sparse fieldsets on included resources', async () => {
-      const product = await api.resources.products.post({
-        name: 'another product',
-        description: 'Description',
-        price_str: '10',
-        tax_rate_str: '0'
-      })
-
-      await api.resources.reviews.post({
-        product: product.id,
-        content: 'Review text',
-        rating: 4
-      })
-
-      const result = await api.resources.products.get({
-        id: product.id,
-        queryParams: {
-          include: ['reviews'],
-          fields: {
-            products: 'name',
-            reviews: 'content' // Only content, not rating
-          }
-        }
-      })
-
-      assert.equal(result.name, 'ANOTHER PRODUCT')
-      assert.equal(result.description, undefined)
-
-      assert.equal(result.reviews.length, 1)
-      assert.equal(result.reviews[0].content, '[REVIEW] Review text')
-      assert.equal(result.reviews[0].rating, undefined)
-    })
-  })
-
-  describe('Getter Error Handling', () => {
-    it('should handle getter errors gracefully', async () => {
-      // Add a resource with a failing getter
-      await api.addResource('error_test', {
-        schema: {
-          id: { type: 'id' },
-          good_field: {
-            type: 'string',
-            getter: (value) => value?.toUpperCase()
-          },
-          bad_field: {
-            type: 'string',
-            getter: (value) => {
-              throw new Error('Getter failed!')
-            }
-          }
-        },
-        tableName: 'getter_errors'
-      })
-      await api.resources.error_test.createKnexTable()
-      if (storageMode.isAnyApi()) {
-        storageMode.registerTable('getter_errors', 'error_test')
-      }
-
-      const record = await api.resources.error_test.post({
-        good_field: 'hello',
-        bad_field: 'world'
-      })
-
-      // Good field should be transformed
-      assert.equal(record.good_field, 'HELLO')
-      // Bad field should keep original value (error logged but not thrown)
-      assert.equal(record.bad_field, 'world')
-
-      await cleanTables(knex, ['getter_errors'])
-    })
-  })
-
-  describe('Circular Dependencies', () => {
-    it('should detect circular getter dependencies', async () => {
-      await assert.rejects(
-        api.addResource('circular_test', {
-          schema: {
-            fieldA: {
-              type: 'string',
-              getter: (v) => v,
-              runGetterAfter: ['fieldB']
-            },
-            fieldB: {
-              type: 'string',
-              getter: (v) => v,
-              runGetterAfter: ['fieldA']
-            }
-          },
-          tableName: 'circular_test'
-        }),
-        /Circular dependency detected/
-      )
-    })
-
-    it('should detect unknown getter dependencies', async () => {
-      await assert.rejects(
-        api.addResource('unknown_test', {
-          schema: {
-            field1: {
-              type: 'string',
-              getter: (v) => v,
-              runGetterAfter: ['nonexistent']
-            }
-          },
-          tableName: 'unknown_test'
-        }),
-        /getter dependency 'nonexistent' that does not exist/
-      )
-    })
-  })
-})