json-rest-api 1.0.24 → 1.0.25

package/tests/anyapi-cursor-pagination.test.js

@@ -9,11 +9,17 @@ import {
   resourceIdentifier,
 } from './helpers/test-utils.js'
 import { storageMode } from './helpers/storage-mode.js'
+import { parseJsonApiQuery } from '../plugins/core/lib/querying-writing/connectors-query-parser.js'
 
 const isAnyApi = storageMode.isAnyApi()
 
 const maybeDescribe = isAnyApi ? describe : describe.skip
 
+const parseLinkQuery = (link) => {
+  const url = new URL(link, 'https://example.test')
+  return parseJsonApiQuery(url.search.slice(1))
+}
+
 maybeDescribe('AnyAPI Cursor Pagination', () => {
   const knex = knexLib({
     client: 'better-sqlite3',
@@ -78,7 +84,7 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
 
     assert.equal(result.data.length, 2)
     assert(result.meta?.pagination?.cursor?.next, 'Should include next cursor')
-    assert(result.links?.next?.includes('page[after]='), 'Next link should include cursor parameter')
+    assert(parseLinkQuery(result.links?.next).page.after, 'Next link should include cursor parameter')
   })
 
   it('paginates forward using page[after]', async () => {

package/tests/anyapi-custom-idproperty.test.js

@@ -0,0 +1,163 @@
+import { describe, it, before, beforeEach, after } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { Api } from 'hooked-api'
+
+import { RestApiPlugin, RestApiAnyapiKnexPlugin } from '../index.js'
+import { ensureAnyApiSchema } from '../plugins/core/lib/anyapi/schema-utils.js'
+import { storageMode } from './helpers/storage-mode.js'
+import {
+  createJsonApiDocument,
+  createRelationship,
+  resourceIdentifier,
+} from './helpers/test-utils.js'
+
+const maybeDescribe = storageMode.isAnyApi() ? describe : describe.skip
+
+maybeDescribe('AnyAPI custom idProperty', () => {
+  const knex = knexLib({
+    client: 'better-sqlite3',
+    connection: { filename: ':memory:' },
+    useNullAsDefault: true,
+  })
+
+  let api
+
+  before(async () => {
+    await ensureAnyApiSchema(knex)
+
+    api = new Api({ name: 'anyapi-custom-idproperty-test', log: { level: 'warn' } })
+    await api.use(RestApiPlugin, {
+      simplifiedApi: false,
+      simplifiedTransport: false,
+      returnRecordApi: {
+        post: 'full',
+        put: 'full',
+        patch: 'full',
+      },
+      sortableFields: ['id', 'owner_id', 'item_id', 'code', 'name', 'category'],
+      queryDefaultLimit: 20,
+      queryMaxLimit: 100,
+    })
+    await api.use(RestApiAnyapiKnexPlugin, { knex })
+
+    await api.addResource('owners', {
+      schema: {
+        owner_id: { type: 'id' },
+        name: { type: 'string', required: true },
+      },
+      idProperty: 'owner_id',
+      tableName: 'custom_id_owners',
+    })
+    await api.resources.owners.createKnexTable()
+
+    await api.addResource('items', {
+      schema: {
+        item_id: { type: 'id' },
+        code: { type: 'string', required: true, search: true },
+        name: { type: 'string', required: true },
+        category: { type: 'string', required: true },
+        owner_id: { type: 'id', belongsTo: 'owners', as: 'owner' },
+      },
+      idProperty: 'item_id',
+      tableName: 'custom_id_items',
+    })
+    await api.resources.items.createKnexTable()
+  })
+
+  after(async () => {
+    await api?.release()
+    await knex.destroy()
+  })
+
+  beforeEach(async () => {
+    await knex('any_links').delete()
+    await knex('any_records').delete()
+  })
+
+  it('uses logical ids for post, get, query, sparse fields, cursors, and includes', async () => {
+    const owner = await api.resources.owners.post({
+      inputRecord: createJsonApiDocument('owners', { name: 'Owner One' }),
+      simplified: false,
+    })
+
+    const itemInputs = [
+      { code: 'A001', name: 'Apple', category: 'Fruit' },
+      { code: 'A002', name: 'Apricot', category: 'Fruit' },
+      { code: 'B001', name: 'Broccoli', category: 'Vegetable' },
+      { code: 'C001', name: 'Carrot', category: 'Vegetable' },
+    ]
+
+    const createdItems = []
+    for (const item of itemInputs) {
+      const created = await api.resources.items.post({
+        inputRecord: createJsonApiDocument(
+          'items',
+          item,
+          { owner: createRelationship(resourceIdentifier('owners', owner.data.id)) }
+        ),
+        simplified: false,
+      })
+      createdItems.push(created)
+    }
+
+    const fetched = await api.resources.items.get({
+      id: createdItems[0].data.id,
+      queryParams: {
+        include: ['owner'],
+        fields: {
+          items: 'item_id,code,name,category',
+          owners: 'owner_id,name',
+        },
+      },
+      simplified: false,
+    })
+
+    assert.equal(fetched.data.id, createdItems[0].data.id)
+    assert.equal(fetched.data.attributes.code, 'A001')
+    assert.equal(fetched.data.attributes.name, 'Apple')
+    assert.equal(fetched.data.attributes.item_id, undefined)
+    assert.equal(fetched.included?.[0]?.type, 'owners')
+    assert.equal(fetched.included?.[0]?.id, owner.data.id)
+    assert.equal(fetched.included?.[0]?.attributes.owner_id, undefined)
+
+    const firstPage = await api.resources.items.query({
+      queryParams: {
+        include: ['owner'],
+        fields: {
+          items: 'item_id,code,name,category',
+          owners: 'owner_id,name',
+        },
+        sort: ['category', 'name'],
+        page: { size: 2 },
+      },
+      simplified: false,
+    })
+
+    assert.equal(firstPage.data.length, 2)
+    assert(firstPage.meta.pagination.cursor.next, 'first page should include a next cursor')
+    assert(firstPage.data.every((item) => item.attributes.item_id === undefined))
+    assert(firstPage.included?.some((entry) => entry.type === 'owners' && entry.id === owner.data.id))
+
+    const secondPage = await api.resources.items.query({
+      queryParams: {
+        include: ['owner'],
+        fields: {
+          items: 'item_id,code,name,category',
+          owners: 'owner_id,name',
+        },
+        sort: ['category', 'name'],
+        page: {
+          size: 2,
+          after: firstPage.meta.pagination.cursor.next,
+        },
+      },
+      simplified: false,
+    })
+
+    const firstIds = firstPage.data.map((item) => item.id)
+    const secondIds = secondPage.data.map((item) => item.id)
+    assert.equal(secondPage.data.length, 2)
+    assert(!secondIds.some((id) => firstIds.includes(id)), 'cursor page should not repeat records')
+  })
+})

package/tests/fastify-plugin.test.js

@@ -2,6 +2,7 @@ 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,
@@ -75,6 +76,12 @@ describe('Fastify Plugin', () => {
     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')
@@ -108,6 +115,27 @@ describe('Fastify Plugin', () => {
     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 () => {

package/tests/field-setters.test.js

@@ -176,7 +176,7 @@ describe('Field Setters', () => {
       await cleanTables(knex, ['setter_users'])
     })
 
-    it('should handle setter errors gracefully', async () => {
+    it('should reject setter errors and roll back the write', async () => {
       // Create a resource with a failing setter
       await api.addResource('error_test', {
         schema: {
@@ -196,16 +196,16 @@ describe('Field Setters', () => {
       })
       await api.resources.error_test.createKnexTable()
 
-      const record = await api.resources.error_test.post({
-        good_field: 'HELLO',
-        bad_field: 'world'
-      })
+      await assert.rejects(
+        api.resources.error_test.post({
+          good_field: 'HELLO',
+          bad_field: 'world'
+        }),
+        /Setter for field 'bad_field' failed: Setter failed!/
+      )
 
-      const fetchedRecord = await api.resources.error_test.get({ id: record.id })
-      // Good field should be transformed
-      assert.equal(fetchedRecord.good_field, 'hello')
-      // Bad field should keep validated value (error logged but not thrown)
-      assert.equal(fetchedRecord.bad_field, 'world')
+      const records = await api.resources.error_test.query()
+      assert.equal(records?.length || 0, 0)
 
       await cleanTables(knex, ['setter_errors'])
     })

package/tests/file-handling.test.js

@@ -0,0 +1,118 @@
+import { describe, it, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { cleanTables } from './helpers/test-utils.js'
+import { createFileUploadApi } from './fixtures/api-configs.js'
+
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+})
+
+let api
+let detectorState
+let storage
+
+function createTrackingStorage () {
+  return {
+    uploaded: [],
+    deleted: [],
+
+    async upload (file) {
+      const url = `/uploads/${file.filename}`
+      this.uploaded.push(url)
+      return url
+    },
+
+    async delete (url) {
+      this.deleted.push(url)
+    }
+  }
+}
+
+function createTestFile ({ filename = 'upload.png', mimetype = 'image/png', cleanup } = {}) {
+  return {
+    filename,
+    mimetype,
+    size: 1,
+    data: Buffer.from('x'),
+    cleanup
+  }
+}
+
+describe('File handling cleanup', () => {
+  before(async () => {
+    detectorState = { payload: null }
+    storage = createTrackingStorage()
+    api = await createFileUploadApi(knex, { detectorState, storage })
+  })
+
+  after(async () => {
+    await knex.destroy()
+  })
+
+  beforeEach(async () => {
+    await cleanTables(knex, ['file_documents'])
+    detectorState.payload = null
+    storage.uploaded = []
+    storage.deleted = []
+  })
+
+  it('cleans detector temp files when MIME validation rejects an upload', async () => {
+    let cleanupCalls = 0
+    detectorState.payload = {
+      fields: { title: 'Invalid MIME' },
+      files: {
+        attachment: createTestFile({
+          filename: 'invalid.txt',
+          mimetype: 'text/plain',
+          cleanup: async () => {
+            cleanupCalls++
+          }
+        })
+      }
+    }
+
+    await assert.rejects(
+      api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: {} } },
+        simplified: false
+      }),
+      /Invalid file type for field 'attachment'/
+    )
+
+    assert.equal(cleanupCalls, 1)
+    assert.deepEqual(storage.uploaded, [])
+    assert.deepEqual(storage.deleted, [])
+  })
+
+  it('deletes uploaded files when a later write validation error rolls back', async () => {
+    let cleanupCalls = 0
+    detectorState.payload = {
+      fields: {},
+      files: {
+        attachment: createTestFile({
+          filename: 'valid.png',
+          cleanup: async () => {
+            cleanupCalls++
+          }
+        })
+      }
+    }
+
+    await assert.rejects(
+      api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: {} } },
+        simplified: false
+      }),
+      /Schema validation failed for resource attributes/
+    )
+
+    assert.equal(cleanupCalls, 1)
+    assert.deepEqual(storage.uploaded, ['/uploads/valid.png'])
+    assert.deepEqual(storage.deleted, ['/uploads/valid.png'])
+  })
+})