json-rest-api 1.0.23 → 1.0.25

package/tests/socketio.test.js

@@ -453,6 +453,68 @@ describe('WebSocket/Socket.IO Plugin', () => {
         socket.close()
       }
     })
+
+    it('should broadcast deferred patch notifications from relationship PATCH', async () => {
+      const token = await createToken({ userId: 'test-user', role: 'user' }, 'test-secret-key')
+
+      const socket = ioClient(`http://localhost:${server.address().port}`, {
+        path: '/api/socket.io',
+        auth: { token }
+      })
+
+      try {
+        await new Promise((resolve, reject) => {
+          socket.on('connect', resolve)
+          socket.on('connect_error', reject)
+          setTimeout(() => reject(new Error('Connection timeout')), 5000)
+        })
+
+        const country = await api.resources.countries.post({
+          inputRecord: createJsonApiDocument('countries', {
+            name: 'Original Country',
+            code: 'OC'
+          }),
+          simplified: false
+        })
+
+        const nextCountry = await api.resources.countries.post({
+          inputRecord: createJsonApiDocument('countries', {
+            name: 'Next Country',
+            code: 'NC'
+          }),
+          simplified: false
+        })
+
+        const book = await api.resources.books.post({
+          inputRecord: createJsonApiDocument(
+            'books',
+            { title: 'Relationship Patch Broadcast' },
+            { country: createRelationship(resourceIdentifier('countries', country.data.id)) }
+          ),
+          simplified: false
+        })
+
+        await new Promise((resolve) => {
+          socket.emit('subscribe', { resource: 'books' }, resolve)
+        })
+
+        const updatePromise = waitForSocketEvent(socket, 'subscription.update', 1000)
+
+        await api.resources.books.patchRelationship({
+          id: book.data.id,
+          relationshipName: 'country',
+          relationshipData: resourceIdentifier('countries', nextCountry.data.id)
+        })
+
+        const notification = await updatePromise
+        assert.equal(notification.type, 'resource.patchd')
+        assert.equal(notification.resource, 'books')
+        assert.equal(String(notification.id), String(book.data.id))
+        assert.equal(notification.action, 'patch')
+      } finally {
+        socket.close()
+      }
+    })
   })
 
   describe('Multiple Subscriptions', () => {

package/tests/storage-mapping.test.js

@@ -42,6 +42,7 @@ describe('Storage mapping', () => {
     await api.use(RestApiPlugin, {
       simplifiedApi: false,
       simplifiedTransport: false,
+      sortableFields: ['id', 'displayName', 'loginCount', 'lastSeenAt', 'countryId', 'externalRef'],
       returnRecordApi: {
         post: 'full',
         put: 'full',
@@ -70,13 +71,12 @@ describe('Storage mapping', () => {
     await api.addResource('profiles', {
       schema: {
         id: { type: 'id' },
-        displayName: { type: 'string', required: true, storage: { column: 'display_name' } },
-        loginCount: { type: 'number', defaultTo: 0, storage: { column: 'login_count' } },
+        displayName: { type: 'string', required: true, search: true },
+        loginCount: { type: 'number', defaultTo: 0 },
         lastSeenAt: {
           type: 'dateTime',
           nullable: true,
           storage: {
-            column: 'last_seen_at',
             serialize: serializeDateTimeForSql
           }
         },
@@ -84,14 +84,25 @@ describe('Storage mapping', () => {
           type: 'id',
           nullable: true,
           belongsTo: 'countries',
-          as: 'country',
-          storage: { column: 'country_id' }
+          as: 'country'
         },
+        externalRef: { type: 'string', nullable: true, search: true, storage: { column: 'legacy_ref' } },
         confirmationToken: { type: 'string', virtual: true }
       },
       tableName: 'mapped_profiles'
     })
     await api.resources.profiles.createKnexTable()
+
+    await api.addResource('verbatim_profiles', {
+      storage: { naming: 'exact' },
+      schema: {
+        id: { type: 'id' },
+        displayName: { type: 'string', required: true },
+        loginCount: { type: 'number', defaultTo: 0 }
+      },
+      tableName: 'verbatim_profiles'
+    })
+    await api.resources.verbatim_profiles.createKnexTable()
   })
 
   after(async () => {
@@ -99,7 +110,7 @@ describe('Storage mapping', () => {
   })
 
   beforeEach(async () => {
-    await cleanTables(knex, ['mapped_profiles', 'mapped_countries'])
+    await cleanTables(knex, ['mapped_profiles', 'mapped_countries', 'verbatim_profiles'])
   })
 
   it('persists mapped columns while exposing logical field names', async () => {
@@ -116,6 +127,7 @@ describe('Storage mapping', () => {
           displayName: 'Mercury',
           loginCount: 7,
           lastSeenAt: '2026-01-02T03:04:05Z',
+          externalRef: 'legacy-001',
           confirmationToken: 'secret-token'
         },
         {
@@ -140,6 +152,7 @@ describe('Storage mapping', () => {
     assert.equal(dbRecord.login_count, 7)
     assert.equal(dbRecord.last_seen_at, '2026-01-02 03:04:05')
     assert.equal(String(dbRecord.country_id), country.data.id)
+    assert.equal(dbRecord.legacy_ref, 'legacy-001')
     assert.ok(!('displayName' in dbRecord))
     assert.ok(!('countryId' in dbRecord))
     assert.ok(!('confirmationToken' in dbRecord))
@@ -164,6 +177,22 @@ describe('Storage mapping', () => {
       'country',
       resourceIdentifier('countries', country.data.id)
     )
+
+    const queryResult = await api.resources.profiles.query({
+      queryParams: {
+        filters: {
+          displayName: 'Mercury',
+          externalRef: 'legacy-001'
+        }
+      }
+    })
+
+    validateJsonApiStructure(queryResult, true)
+    assert.equal(queryResult.data.length, 1)
+    assertResourceAttributes(queryResult.data[0], {
+      displayName: 'Mercury',
+      externalRef: 'legacy-001'
+    })
   })
 
   it('applies storage mapping on PATCH updates and sparse fieldsets', async () => {
@@ -207,4 +236,25 @@ describe('Storage mapping', () => {
     assert.equal(dbRecord.last_seen_at, '2026-02-03 04:05:06')
     assert.ok(!('displayName' in dbRecord))
   })
+
+  it('can opt out of snake_case translation for an entire resource', async () => {
+    const created = await api.resources.verbatim_profiles.post({
+      inputRecord: createJsonApiDocument('verbatim_profiles', {
+        displayName: 'Exact Mode',
+        loginCount: 3
+      })
+    })
+
+    validateJsonApiStructure(created)
+    assertResourceAttributes(created.data, {
+      displayName: 'Exact Mode',
+      loginCount: 3
+    })
+
+    const dbRecord = await knex('verbatim_profiles').where('id', created.data.id).first()
+    assert.equal(dbRecord.displayName, 'Exact Mode')
+    assert.equal(dbRecord.loginCount, 3)
+    assert.equal(Object.hasOwn(dbRecord, 'display_name'), false)
+    assert.equal(Object.hasOwn(dbRecord, 'login_count'), false)
+  })
 })

package/tests/test-development-guide.md

@@ -64,9 +64,9 @@ Control what methods return:
 ```javascript
 // In API configuration
 returnFullRecord: {
-  post: true,   // Return created record (needed to get ID)
-  put: false,   // Don't return after replacement
-  patch: false  // Don't return after update
+  post: 'full', // Return created record (needed to get ID)
+  put: 'no',    // Don't return after replacement
+  patch: 'no'   // Don't return after update
 }
 
 // Override per call if needed
@@ -74,7 +74,7 @@ const result = await api.resources.books.put({
   id: bookId,
   inputRecord: putDoc,
   simplified: false,
-  returnFullRecord: false  // Override to not return
+  returnFullRecord: 'no' // Override to not return
 });
 ```
 
@@ -367,4 +367,4 @@ npm test -- tests/relationships.test.js
 4. **validation.test.js** - Schema validation edge cases
 5. **polymorphic.test.js** - Polymorphic relationship tests
 
-Each should follow the patterns established in existing tests.
+Each should follow the patterns established in existing tests.