json-rest-api 1.0.14 → 1.0.15

package/tests/TEST_TEMPLATE.test.js

@@ -1,17 +1,17 @@
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import knexLib from 'knex';
-import { 
-  validateJsonApiStructure, 
-  cleanTables, 
+import { describe, it, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import {
+  validateJsonApiStructure,
+  cleanTables,
   createJsonApiDocument,
   assertResourceAttributes
-} from './helpers/test-utils.js';
-import { createBasicApi } from './fixtures/api-configs.js';
+} from './helpers/test-utils.js'
+import { createBasicApi } from './fixtures/api-configs.js'
 
 /**
  * TEST TEMPLATE - BEST PRACTICES LEARNED
- * 
+ *
  * CRITICAL RULES:
  * 1. Create API instance ONLY ONCE in before() - NOT in beforeEach()
  * 2. Use cleanTables() in beforeEach() to reset data between tests
@@ -19,9 +19,9 @@ import { createBasicApi } from './fixtures/api-configs.js';
  * 4. Clean up any intervals/timers in after() hook
  * 5. SQLite returns numeric IDs - JSON:API expects string IDs
  * 6. For auth tests, context.auth must be set via JWT token or passed manually
- * 
+ *
  * NOTICE TO CLAUDE/AI ASSISTANTS:
- * 
+ *
  * API CONFIGURATION RULES - EXTREMELY IMPORTANT:
  * 1. NEVER add resources with api.addResource() in test files!
  * 2. ALL resources MUST be defined in api-configs.js
@@ -38,13 +38,13 @@ import { createBasicApi } from './fixtures/api-configs.js';
  *      }
  * 5. Example structure in api-configs.js:
  *    - createBasicApi() - has countries, publishers, authors, books
- *    - createAuthApi() - might have users, roles, permissions  
+ *    - createAuthApi() - might have users, roles, permissions
  *    - createYourCustomApi() - whatever resources you need
- * 
+ *
  * RESOURCE CREATION RULE (REPEAT FOR EMPHASIS):
  * Resources are ONLY created in api-configs.js, NEVER in test files!
  * If you need new resources, create a new function in api-configs.js!
- * 
+ *
  * DATA ACCESS RULES - EXTREMELY IMPORTANT:
  * 1. NEVER query the database directly with knex('table').select()
  * 2. ALWAYS use API methods to check data:
@@ -57,10 +57,10 @@ import { createBasicApi } from './fixtures/api-configs.js';
  *    - Return data in the expected JSON:API format
  *    - Include computed fields and enriched attributes
  * 4. Direct DB queries will give you raw data that doesn't match what the API returns!
- * 
+ *
  * BAD EXAMPLE:
  *   const record = await knex('basic_countries').where('id', 1).first();  // NO!
- * 
+ *
  * GOOD EXAMPLE:
  *   const result = await api.resources.countries.get({ id: 1 });
  *   const record = result.data;  // YES!
@@ -73,10 +73,10 @@ const knex = knexLib({
     filename: ':memory:'
   },
   useNullAsDefault: true
-});
+})
 
 // API instance that persists across ALL tests
-let api;
+let api
 
 describe('Your Feature Name (Template Example)', () => {
   // IMPORTANT: before() runs ONCE for the entire test suite
@@ -84,18 +84,18 @@ describe('Your Feature Name (Template Example)', () => {
     // Create API instance ONCE - this is reused for all tests
     // NOTE: If you need different resources than what createBasicApi provides,
     // create a new function in api-configs.js!
-    api = await createBasicApi(knex);
-    
+    api = await createBasicApi(knex)
+
     // Install your plugin if testing a specific plugin
     // await api.use(YourPlugin, {
     //   option1: 'value1',
     //   option2: 'value2'
     // });
-    
+
     // NO api.addResource() HERE! Resources are defined in api-configs.js!
     // createBasicApi already created tables for: countries, publishers, authors, books
-  });
-  
+  })
+
   // IMPORTANT: after() cleans up resources
   after(async () => {
     // Clean up any intervals/timers your plugin might have created
@@ -103,76 +103,76 @@ describe('Your Feature Name (Template Example)', () => {
     // if (api.vars.yourPluginCleanupJob) {
     //   clearInterval(api.vars.yourPluginCleanupJob);
     // }
-    
+
     // Always destroy knex connection to allow tests to exit
-    await knex.destroy();
-  });
-  
+    await knex.destroy()
+  })
+
   // IMPORTANT: beforeEach() cleans data but does NOT recreate API
   beforeEach(async () => {
     // Clean all tables - list ALL tables your tests use
     await cleanTables(knex, [
       'basic_countries',      // From createBasicApi
       'basic_publishers',     // From createBasicApi
-      'basic_authors',        // From createBasicApi  
+      'basic_authors',        // From createBasicApi
       'basic_books',          // From createBasicApi
       'basic_book_authors'    // From createBasicApi (junction table)
       // Add any additional tables used by your tests here
-    ]);
-  });
-  
+    ])
+  })
+
   // ONE SIMPLE EXAMPLE TEST
   it('should create and retrieve a country', async () => {
     // Create a country using the API
     const doc = createJsonApiDocument('countries', {
       name: 'Test Country',
       code: 'TC'
-    });
-    
+    })
+
     // Create the country
     // IMPORTANT: Context is SECOND parameter, not inside first parameter!
     const createResult = await api.resources.countries.post({
       inputRecord: doc,
       simplified: false
-    }, { /* optional context goes here */ });
-    
+    }, { /* optional context goes here */ })
+
     // Validate the creation response
-    validateJsonApiStructure(createResult);
-    assert.equal(createResult.data.type, 'countries');
+    validateJsonApiStructure(createResult)
+    assert.equal(createResult.data.type, 'countries')
     assertResourceAttributes(createResult.data, {
       name: 'Test Country',
       code: 'TC'
-    });
-    
+    })
+
     // Retrieve the country we just created
     const getResult = await api.resources.countries.get({
       id: createResult.data.id,
       simplified: false
-    });
-    
+    })
+
     // Validate the retrieved country
-    validateJsonApiStructure(getResult);
-    assert.equal(getResult.data.id, createResult.data.id);
-    assert.equal(getResult.data.attributes.name, 'Test Country');
-    assert.equal(getResult.data.attributes.code, 'TC');
-  });
-});
+    validateJsonApiStructure(getResult)
+    assert.equal(getResult.data.id, createResult.data.id)
+    assert.equal(getResult.data.attributes.name, 'Test Country')
+    assert.equal(getResult.data.attributes.code, 'TC')
+  })
+})
 
 /**
  * COMMON PITFALLS TO AVOID:
- * 
+ *
  * 1. DON'T create API in beforeEach - it's expensive and unnecessary
  * 2. DON'T forget to clean tables between tests
  * 3. DON'T pass context inside params object - it's a separate parameter
  * 4. DON'T assume IDs are strings - SQLite returns numbers
  * 5. DON'T forget to clean up intervals/timers
  * 6. DON'T skip error cases - test both success and failure paths
- * 
+ *
  * DEBUGGING TIPS:
- * 
+ *
  * 1. Use console.log liberally when debugging, but remove before committing
  * 2. Check if your auth context is properly structured
  * 3. Validate that required fields are present in your test data
  * 4. Remember that HTTP routes have /api/ prefix by default
  * 5. Use debugger statements to pause execution and inspect state
- */
+ */

package/tests/anyapi-basic.test.js

@@ -1,27 +1,27 @@
-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 { 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 { RestApiPlugin, RestApiAnyapiKnexPlugin } from '../index.js'
+import { ensureAnyApiSchema } from '../plugins/core/lib/anyapi/schema-utils.js'
 
 const knex = knexLib({
   client: 'better-sqlite3',
   connection: { filename: ':memory:' },
   useNullAsDefault: true,
-});
+})
 
-let api;
+let api
 
 describe('AnyAPI Knex Plugin - Basic Attributes', () => {
   before(async () => {
     try {
-      await ensureAnyApiSchema(knex);
+      await ensureAnyApiSchema(knex)
 
-      api = new Api({ name: 'anyapi-test', log: { level: 'warn' } });
-      await api.use(RestApiPlugin, { simplifiedApi: false, simplifiedTransport: false });
-      await api.use(RestApiAnyapiKnexPlugin, { knex });
+      api = new Api({ name: 'anyapi-test', log: { level: 'warn' } })
+      await api.use(RestApiPlugin, { simplifiedApi: false, simplifiedTransport: false })
+      await api.use(RestApiAnyapiKnexPlugin, { knex })
 
       await api.addResource('countries', {
         schema: {
@@ -29,25 +29,25 @@ describe('AnyAPI Knex Plugin - Basic Attributes', () => {
           name: { type: 'string', required: true },
           code: { type: 'string', required: true },
         },
-      });
+      })
 
       if (api.resources.countries?.createKnexTable) {
-        await api.resources.countries.createKnexTable();
+        await api.resources.countries.createKnexTable()
       }
     } catch (error) {
-      console.error('Setup failed', error);
-      throw error;
+      console.error('Setup failed', error)
+      throw error
     }
-  });
+  })
 
   after(async () => {
-    await api.release();
-    await knex.destroy();
-  });
+    await api.release()
+    await knex.destroy()
+  })
 
   beforeEach(async () => {
-    await knex('any_records').truncate();
-  });
+    await knex('any_records').truncate()
+  })
 
   it('creates and retrieves records', async () => {
     const result = await api.resources.countries.post({
@@ -62,24 +62,24 @@ describe('AnyAPI Knex Plugin - Basic Attributes', () => {
       },
       simplified: false,
     }).catch((error) => {
-      console.error('POST failed', error);
-      throw error;
-    });
+      console.error('POST failed', error)
+      throw error
+    })
 
-    assert.ok(result.data.id, 'should return new id');
-    assert.equal(result.data.attributes.name, 'Australia');
+    assert.ok(result.data.id, 'should return new id')
+    assert.equal(result.data.attributes.name, 'Australia')
 
-    const stored = await knex('any_records').first();
-    assert.equal(stored.string_1, 'Australia');
-    assert.equal(stored.string_2, 'AU');
+    const stored = await knex('any_records').first()
+    assert.equal(stored.string_1, 'Australia')
+    assert.equal(stored.string_2, 'AU')
 
     const fetched = await api.resources.countries.get({ id: result.data.id, simplified: false })
       .catch((error) => {
-        console.error('GET failed', error);
-        throw error;
-      });
-    assert.equal(fetched.data.attributes.name, 'Australia');
-  });
+        console.error('GET failed', error)
+        throw error
+      })
+    assert.equal(fetched.data.attributes.name, 'Australia')
+  })
 
   it('lists records', async () => {
     await knex('any_records').insert([{
@@ -92,11 +92,11 @@ describe('AnyAPI Knex Plugin - Basic Attributes', () => {
       resource: 'countries',
       string_1: 'Brazil',
       string_2: 'BR',
-    }]);
+    }])
 
-    const result = await api.resources.countries.query({ simplified: false });
-    assert.equal(result.data.length, 2);
-    const names = result.data.map((entry) => entry.attributes.name).sort();
-    assert.deepEqual(names, ['Brazil', 'Canada']);
-  });
-});
+    const result = await api.resources.countries.query({ simplified: false })
+    assert.equal(result.data.length, 2)
+    const names = result.data.map((entry) => entry.attributes.name).sort()
+    assert.deepEqual(names, ['Brazil', 'Canada'])
+  })
+})

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

@@ -1,58 +1,58 @@
-import { describe, it, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import knexLib from 'knex';
-import { createPaginationApi } from './fixtures/api-configs.js';
+import { describe, it, before, beforeEach, after } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { createPaginationApi } from './fixtures/api-configs.js'
 import {
   cleanTables,
   createJsonApiDocument,
   createRelationship,
   resourceIdentifier,
-} from './helpers/test-utils.js';
-import { storageMode } from './helpers/storage-mode.js';
+} from './helpers/test-utils.js'
+import { storageMode } from './helpers/storage-mode.js'
 
-const isAnyApi = storageMode.isAnyApi();
+const isAnyApi = storageMode.isAnyApi()
 
-const maybeDescribe = isAnyApi ? describe : describe.skip;
+const maybeDescribe = isAnyApi ? describe : describe.skip
 
 maybeDescribe('AnyAPI Cursor Pagination', () => {
   const knex = knexLib({
     client: 'better-sqlite3',
     connection: { filename: ':memory:' },
     useNullAsDefault: true,
-  });
+  })
 
-  let api;
+  let api
 
   before(async () => {
-    api = await createPaginationApi(knex);
-  });
+    api = await createPaginationApi(knex)
+  })
 
   after(async () => {
-    await knex.destroy();
-  });
+    await knex.destroy()
+  })
 
   beforeEach(async () => {
     await cleanTables(knex, [
       'pagination_countries',
       'pagination_publishers',
       'pagination_books',
-    ]);
+    ])
 
     const country = await api.resources.countries.post({
       inputRecord: createJsonApiDocument('countries', { name: 'Cursorland', code: 'CL' }),
       simplified: false,
-    });
+    })
 
     const publisher = await api.resources.publishers.post({
       inputRecord: createJsonApiDocument(
         'publishers',
         { name: 'Cursor Press' },
-        { country: createRelationship(resourceIdentifier('countries', country.data.id)) },
+        { country: createRelationship(resourceIdentifier('countries', country.data.id)) }
       ),
       simplified: false,
-    });
+    })
 
-    const titles = ['Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F'];
+    const titles = ['Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F']
     for (const title of titles) {
       await api.resources.books.post({
         inputRecord: createJsonApiDocument(
@@ -61,12 +61,12 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
           {
             country: createRelationship(resourceIdentifier('countries', country.data.id)),
             publisher: createRelationship(resourceIdentifier('publishers', publisher.data.id)),
-          },
+          }
         ),
         simplified: false,
-      });
+      })
     }
-  });
+  })
 
   it('returns cursor metadata and links when requesting the first page', async () => {
     const result = await api.resources.books.query({
@@ -74,12 +74,12 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
         page: { size: 2 },
       },
       simplified: false,
-    });
+    })
 
-    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.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')
+  })
 
   it('paginates forward using page[after]', async () => {
     const firstPage = await api.resources.books.query({
@@ -87,21 +87,21 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
         page: { size: 2 },
       },
       simplified: false,
-    });
+    })
 
-    const cursor = firstPage.meta.pagination.cursor.next;
+    const cursor = firstPage.meta.pagination.cursor.next
     const secondPage = await api.resources.books.query({
       queryParams: {
         page: { size: 2, after: cursor },
       },
       simplified: false,
-    });
+    })
 
-    assert.equal(secondPage.data.length, 2);
-    const firstIds = firstPage.data.map((book) => book.id);
-    const secondIds = secondPage.data.map((book) => book.id);
-    assert(!secondIds.some((id) => firstIds.includes(id)), 'Second page should not repeat first page records');
-  });
+    assert.equal(secondPage.data.length, 2)
+    const firstIds = firstPage.data.map((book) => book.id)
+    const secondIds = secondPage.data.map((book) => book.id)
+    assert(!secondIds.some((id) => firstIds.includes(id)), 'Second page should not repeat first page records')
+  })
 
   it('paginates backward using page[before]', async () => {
     const firstPage = await api.resources.books.query({
@@ -109,7 +109,7 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
         page: { size: 2 },
       },
       simplified: false,
-    });
+    })
 
     const secondPage = await api.resources.books.query({
       queryParams: {
@@ -119,11 +119,11 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
         },
       },
       simplified: false,
-    });
+    })
 
     const beforeCursor =
-      secondPage.meta.pagination.cursor?.next
-      || `id:${encodeURIComponent(secondPage.data[0].id)}`;
+      secondPage.meta.pagination.cursor?.next ||
+      `id:${encodeURIComponent(secondPage.data[0].id)}`
 
     const previousPage = await api.resources.books.query({
       queryParams: {
@@ -133,12 +133,12 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
         },
       },
       simplified: false,
-    });
-
-    const secondIds = secondPage.data.map((book) => book.id);
-    const previousIds = previousPage.data.map((book) => book.id);
-    assert(!previousIds.some((id) => secondIds.includes(id)), 'Page[before] should return different records');
-    const firstIds = firstPage.data.map((book) => book.id);
-    assert(previousIds.every((id) => firstIds.includes(id)), 'Page[before] should return earlier records');
-  });
-});
+    })
+
+    const secondIds = secondPage.data.map((book) => book.id)
+    const previousIds = previousPage.data.map((book) => book.id)
+    assert(!previousIds.some((id) => secondIds.includes(id)), 'Page[before] should return different records')
+    const firstIds = firstPage.data.map((book) => book.id)
+    assert(previousIds.every((id) => firstIds.includes(id)), 'Page[before] should return earlier records')
+  })
+})