json-rest-api 1.0.10 → 1.0.11

package/quickTest.js

@@ -20,10 +20,10 @@ const knex = knexLib({
 });
 
 // Create API instance
-const api = new Api({ name: 'book-catalog-api', version: '1.0.0', logLevel: 'trace' });
+const api = new Api({ name: 'book-catalog-api', logLevel: 'trace' });
 
 // Install plugins
-await api.use(RestApiPlugin, { publicBaseUrl: '/api' });
+await api.use(RestApiPlugin, {returnBasePath: '/api' });
 await api.use(RestApiKnexPlugin, { knex });
 await api.use(ExpressPlugin, {  mountPath: '/api' }); // Added: Express Plugin
 

package/scripts/debug-anyapi-review-filter.mjs

@@ -0,0 +1,63 @@
+import knexLib from 'knex';
+import { createCustomIdPropertyApi } from '../tests/fixtures/api-configs.js';
+import { createJsonApiDocument } from '../tests/helpers/test-utils.js';
+
+async function run() {
+  const knex = knexLib({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  const api = await createCustomIdPropertyApi(knex);
+
+  const country = await api.resources.countries.post({
+    inputRecord: createJsonApiDocument('countries', { name: 'USA', code: 'US' })
+  });
+
+  const book = await api.resources.books.post({
+    inputRecord: createJsonApiDocument('books',
+      { title: 'Test Book' },
+      { country: { data: { type: 'countries', id: country.data.id } } }
+    )
+  });
+
+  const author = await api.resources.authors.post({
+    inputRecord: createJsonApiDocument('authors', { name: 'Author' })
+  });
+
+  await api.resources.reviews.post({
+    inputRecord: createJsonApiDocument('reviews', {
+      rating: 5,
+      title: 'Book review',
+      content: 'Great book',
+      reviewer_name: 'Reader',
+      reviewable_type: 'books',
+      reviewable_id: book.data.id
+    })
+  });
+
+  await api.resources.reviews.post({
+    inputRecord: createJsonApiDocument('reviews', {
+      rating: 4,
+      title: 'Author review',
+      content: 'Great author',
+      reviewer_name: 'Fan',
+      reviewable_type: 'authors',
+      reviewable_id: author.data.id
+    })
+  });
+
+  try {
+    const res = await api.resources.reviews.query({
+      queryParams: { filters: { reviewable_type: 'books' } }
+    });
+    console.log('Query succeeded with rows:', res.data.length);
+  } catch (error) {
+    console.error('Query failed:', error);
+    if (error?.sql) {
+      console.error('SQL:', error.sql);
+    }
+  }
+
+  await knex.destroy();
+}
+
+run().catch((err) => {
+  console.error('Unexpected failure:', err);
+});

package/scripts/inspect-anyapi-descriptor-country.mjs

@@ -0,0 +1,19 @@
+import knexLib from 'knex';
+import { createCustomIdPropertyApi } from '../tests/fixtures/api-configs.js';
+
+async function run() {
+  const knex = knexLib({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  const api = await createCustomIdPropertyApi(knex);
+  const descriptor = await api.anyapi.registry.getDescriptor('default', 'countries');
+  console.log(JSON.stringify({
+    idProperty: descriptor.idProperty,
+    fields: descriptor.fields,
+    canonicalFieldMap: descriptor.canonicalFieldMap,
+    reverseAttributes: descriptor.reverseAttributes,
+  }, null, 2));
+  await knex.destroy();
+}
+
+run().catch((err) => {
+  console.error('Failed to inspect descriptor', err);
+});

package/scripts/inspect-anyapi-descriptor.mjs

@@ -0,0 +1,19 @@
+import knexLib from 'knex';
+import { createCustomIdPropertyApi } from '../tests/fixtures/api-configs.js';
+
+async function run() {
+  const knex = knexLib({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  const api = await createCustomIdPropertyApi(knex);
+  const descriptor = await api.anyapi.registry.getDescriptor('default', 'reviews');
+  console.log(JSON.stringify({
+    idProperty: descriptor.idProperty,
+    fields: descriptor.fields,
+    canonicalFieldMap: descriptor.canonicalFieldMap,
+    reverseAttributes: descriptor.reverseAttributes,
+  }, null, 2));
+  await knex.destroy();
+}
+
+run().catch((err) => {
+  console.error('Failed to inspect descriptor', err);
+});

package/test-debug.js

@@ -0,0 +1,59 @@
+import { createBasicApi } from './tests/fixtures/api-configs.js';
+import { cleanTables, createJsonApiDocument, createRelationship } from './tests/helpers/test-utils.js';
+import knex from 'knex';
+
+const dbConfig = {
+  client: 'better-sqlite3',
+  connection: { filename: ':memory:' },
+  useNullAsDefault: true
+};
+
+const db = knex(dbConfig);
+
+async function test() {
+  const api = await createBasicApi(db);
+  
+  // Create test data
+  await cleanTables(db, ['basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors']);
+  
+  // Create a country first
+  const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' });
+  const country = await api.resources.countries.post({ inputRecord: countryDoc });
+  
+  // Create an author
+  const authorDoc = createJsonApiDocument('authors', { name: 'Test Author' });
+  const author = await api.resources.authors.post({ inputRecord: authorDoc });
+  
+  // Create a book with proper relationships
+  const bookDoc = {
+    data: {
+      type: 'books',
+      attributes: { title: 'Test Book' },
+      relationships: {
+        country: { data: { type: 'countries', id: String(country.data.id) } }
+      }
+    }
+  };
+  const book = await api.resources.books.post({ inputRecord: bookDoc });
+  
+  // Create the many-to-many relationship
+  await db('basic_book_authors').insert({
+    author_id: author.data.id,
+    book_id: book.data.id
+  });
+  
+  // Now try to query authors with books included
+  console.log('Querying authors with books included...');
+  try {
+    const result = await api.resources.authors.query({
+      queryParams: { include: ['books'] }
+    });
+    console.log('Success!', JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+  
+  await db.destroy();
+}
+
+test().catch(console.error);

package/tests/README.md

@@ -163,6 +163,12 @@ const result = await api.resources.books.query({
 # Run all tests
 npm test
 
+# Run all tests against the AnyAPI storage backend
+npm run test:anyapi
+
+# Windows PowerShell (AnyAPI run)
+$Env:JSON_REST_API_STORAGE = 'anyapi'; npm test
+
 # Run specific test file
 npm test -- tests/relationships.test.js
 
@@ -186,4 +192,4 @@ DEBUG=* npm test
 - Tests intentionally generate ERROR logs for validation testing
 - All tests should pass with exit code 0
 - Database connections are properly closed in `after` hooks
-- Pivot table operations use `simplified: true` internally for foreign keys
+- Pivot table operations use `simplified: true` internally for foreign keys

package/tests/anyapi-basic.test.js

@@ -0,0 +1,102 @@
+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';
+
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: { filename: ':memory:' },
+  useNullAsDefault: true,
+});
+
+let api;
+
+describe('AnyAPI Knex Plugin - Basic Attributes', () => {
+  before(async () => {
+    try {
+      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 });
+
+      await api.addResource('countries', {
+        schema: {
+          id: { type: 'id' },
+          name: { type: 'string', required: true },
+          code: { type: 'string', required: true },
+        },
+      });
+
+      if (api.resources.countries?.createKnexTable) {
+        await api.resources.countries.createKnexTable();
+      }
+    } catch (error) {
+      console.error('Setup failed', error);
+      throw error;
+    }
+  });
+
+  after(async () => {
+    await api.release();
+    await knex.destroy();
+  });
+
+  beforeEach(async () => {
+    await knex('any_records').truncate();
+  });
+
+  it('creates and retrieves records', async () => {
+    const result = await api.resources.countries.post({
+      inputRecord: {
+        data: {
+          type: 'countries',
+          attributes: {
+            name: 'Australia',
+            code: 'AU',
+          },
+        },
+      },
+      simplified: false,
+    }).catch((error) => {
+      console.error('POST failed', error);
+      throw error;
+    });
+
+    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 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');
+  });
+
+  it('lists records', async () => {
+    await knex('any_records').insert([{
+      tenant_id: 'default',
+      resource: 'countries',
+      string_1: 'Canada',
+      string_2: 'CA',
+    }, {
+      tenant_id: 'default',
+      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']);
+  });
+});

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

@@ -0,0 +1,144 @@
+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';
+
+const isAnyApi = storageMode.isAnyApi();
+
+const maybeDescribe = isAnyApi ? describe : describe.skip;
+
+maybeDescribe('AnyAPI Cursor Pagination', () => {
+  const knex = knexLib({
+    client: 'better-sqlite3',
+    connection: { filename: ':memory:' },
+    useNullAsDefault: true,
+  });
+
+  let api;
+
+  before(async () => {
+    api = await createPaginationApi(knex);
+  });
+
+  after(async () => {
+    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)) },
+      ),
+      simplified: false,
+    });
+
+    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(
+          'books',
+          { title },
+          {
+            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({
+      queryParams: {
+        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');
+  });
+
+  it('paginates forward using page[after]', async () => {
+    const firstPage = await api.resources.books.query({
+      queryParams: {
+        page: { size: 2 },
+      },
+      simplified: false,
+    });
+
+    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');
+  });
+
+  it('paginates backward using page[before]', async () => {
+    const firstPage = await api.resources.books.query({
+      queryParams: {
+        page: { size: 2 },
+      },
+      simplified: false,
+    });
+
+    const secondPage = await api.resources.books.query({
+      queryParams: {
+        page: {
+          size: 2,
+          after: firstPage.meta.pagination.cursor.next,
+        },
+      },
+      simplified: false,
+    });
+
+    const beforeCursor =
+      secondPage.meta.pagination.cursor?.next
+      || `id:${encodeURIComponent(secondPage.data[0].id)}`;
+
+    const previousPage = await api.resources.books.query({
+      queryParams: {
+        page: {
+          size: 2,
+          before: beforeCursor,
+        },
+      },
+      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');
+  });
+});

package/tests/computed-fields.test.js

@@ -2,6 +2,7 @@ import { describe, it, before, beforeEach, after } from 'node:test';
 import assert from 'node:assert/strict';
 import knexLib from 'knex';
 import { cleanTables } from './helpers/test-utils.js';
+import { storageMode } from './helpers/storage-mode.js';
 import { createComputedFieldsApi } from './fixtures/api-configs.js';
 
 // Create Knex instance for tests
@@ -38,7 +39,7 @@ describe('Computed Fields and Sparse Fieldsets', () => {
     testData.product = product;
 
     const review1 = await api.resources.reviews.post({
-      product_id: product.id,
+      product: product.id,
       reviewer_name: 'Alice',
       rating: 5,
       comment: 'Excellent product!',
@@ -49,7 +50,7 @@ describe('Computed Fields and Sparse Fieldsets', () => {
     testData.review1 = review1;
 
     const review2 = await api.resources.reviews.post({
-      product_id: product.id,
+      product: product.id,
       reviewer_name: 'Bob',
       rating: 4,
       comment: 'Good value',
@@ -88,7 +89,7 @@ describe('Computed Fields and Sparse Fieldsets', () => {
 
     it('should handle null values in computed fields', async () => {
       const review = await api.resources.reviews.post({
-        product_id: testData.product.id,
+        product: testData.product.id,
         reviewer_name: 'Charlie',
         rating: 3,
         comment: 'Average',
@@ -288,8 +289,8 @@ describe('Computed Fields and Sparse Fieldsets', () => {
     });
   });
 
-  describe('Relationship _ids Fields', () => {
-    it('should always include _ids fields regardless of sparse fieldsets', async () => {
+  describe('Relationship Fields', () => {
+    it('should always include minimal relationship objects regardless of sparse fieldsets', async () => {
       const product = await api.resources.products.get({
         id: testData.product.id,
         queryParams: {
@@ -297,12 +298,17 @@ describe('Computed Fields and Sparse Fieldsets', () => {
         }
       });
 
-      // Relationship _ids should still be included
-      assert.ok(Array.isArray(product.reviews_ids));
-      assert.equal(product.reviews_ids.length, 2);
+      // Minimal relationship objects should still be included
+      assert.ok(Array.isArray(product.reviews));
+      assert.equal(product.reviews.length, 2);
+      assert.equal(product.reviews[0].id, testData.review1.id);
+      assert.equal(product.reviews[1].id, testData.review2.id);
+      // Should only have id property (minimal object)
+      assert.equal(Object.keys(product.reviews[0]).length, 1);
+      assert.equal(Object.keys(product.reviews[1]).length, 1);
     });
 
-    it('should include _ids for empty relationships', async () => {
+    it('should include empty arrays for empty relationships', async () => {
       const newProduct = await api.resources.products.post({
         name: 'New Product',
         price: 50,
@@ -316,8 +322,8 @@ describe('Computed Fields and Sparse Fieldsets', () => {
         }
       });
 
-      assert.ok(Array.isArray(fetched.reviews_ids));
-      assert.equal(fetched.reviews_ids.length, 0);
+      assert.ok(Array.isArray(fetched.reviews));
+      assert.equal(fetched.reviews.length, 0);
     });
   });
 
@@ -340,6 +346,9 @@ describe('Computed Fields and Sparse Fieldsets', () => {
         tableName: 'test_faulty_products'
       });
       await api.resources.faulty_products.createKnexTable();
+      if (storageMode.isAnyApi()) {
+        storageMode.registerTable('test_faulty_products', 'faulty_products');
+      }
 
       const faulty = await api.resources.faulty_products.post({ value: 42 });
       const fetched = await api.resources.faulty_products.get({ id: faulty.id });
@@ -405,6 +414,9 @@ describe('Computed Fields and Sparse Fieldsets', () => {
         tableName: 'test_async_products'
       });
       await api.resources.async_products.createKnexTable();
+      if (storageMode.isAnyApi()) {
+        storageMode.registerTable('test_async_products', 'async_products');
+      }
 
       const product = await api.resources.async_products.post({
         name: 'Async Product',
@@ -435,6 +447,9 @@ describe('Computed Fields and Sparse Fieldsets', () => {
         tableName: 'test_failing_async_products'
       });
       await api.resources.failing_async_products.createKnexTable();
+      if (storageMode.isAnyApi()) {
+        storageMode.registerTable('test_failing_async_products', 'failing_async_products');
+      }
 
       const product = await api.resources.failing_async_products.post({ value: 42 });
       const fetched = await api.resources.failing_async_products.get({ id: product.id });
@@ -480,4 +495,4 @@ describe('Computed Fields and Sparse Fieldsets', () => {
       api.resources.products.vars.schemaInfo.computed.profit_amount.compute = originalProfitAmount;
     });
   });
-});
+});

package/tests/cors.test.js

@@ -37,7 +37,6 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
       const Api = (await import('hooked-api')).Api;
       baseUrlApi = new Api({ 
         name: 'cors-baseurl-test-api',
-        version: '1.0.0',
         log: { level: 'info' }
       });
       
@@ -48,7 +47,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
       await baseUrlApi.use((await import('../plugins/core/rest-api-knex-plugin.js')).RestApiKnexPlugin, { knex });
       await baseUrlApi.use((await import('../plugins/core/connectors/express-plugin.js')).ExpressPlugin, {
         app: baseUrlApp,
-        mountPath: '/v1/api'
+        mountPath: '/api'
       });
       
       // Add basic scope
@@ -75,7 +74,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
         console.log('[TEST] CORS installation error:', error.message);
         console.log('[TEST] vars.transport.matchAll:', baseUrlApi.vars.transport?.matchAll);
         console.log('[TEST] mountPath from transport:', baseUrlApi.vars.transport?.mountPath);
-        console.log('[TEST] Full wildcard path would be:', '/v1' + (baseUrlApi.vars.transport?.matchAll || '*'));
+        console.log('[TEST] Full wildcard path would be:', '' + (baseUrlApi.vars.transport?.matchAll || '*'));
         throw error;
       }
       
@@ -85,7 +84,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
     
     it('should handle OPTIONS preflight with baseUrl', async () => {
       const response = await request(baseUrlApp)
-        .options('/v1/api/countries')
+        .options('/api/countries')
         .set('Origin', 'https://example.com')
         .set('Access-Control-Request-Method', 'POST')
         .set('Access-Control-Request-Headers', 'Content-Type');
@@ -105,7 +104,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
       // Just test the GET endpoint without creating data first
       // This tests CORS headers on the response regardless of data
       const response = await request(baseUrlApp)
-        .get('/v1/api/countries')
+        .get('/api/countries')
         .set('Origin', 'https://example.com')
         .set('Accept', 'application/vnd.api+json');
       
@@ -124,7 +123,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
     it('should handle wildcard OPTIONS route with baseUrl', async () => {
       // Test a non-existent endpoint to check if wildcard OPTIONS still works
       const response = await request(baseUrlApp)
-        .options('/v1/api/non-existent-endpoint')
+        .options('/api/non-existent-endpoint')
         .set('Origin', 'https://example.com')
         .set('Access-Control-Request-Method', 'POST');
       

package/tests/curl.test.js

@@ -430,7 +430,7 @@ describe('CURL HTTP Abstraction Layer Tests', () => {
       validateJsonApiStructure(response, true);
       
       assert.equal(response.data.length, 3, 'Should return 3 books per page');
-      // Note: Links are now always included, using relative URLs when publicBaseUrl isn't configured
+      // Note: Links are now always included, using relative URLs whenreturnBasePath isn't configured
     });
 
     it('should handle sorting using CURL', async () => {