json-rest-api 1.0.10 → 1.0.13

package/tests/helpers/storage-mode.js

@@ -0,0 +1,65 @@
+const STORAGE_MODE = process.env.JSON_REST_API_STORAGE === 'anyapi' ? 'anyapi' : 'knex';
+const DEFAULT_TENANT = 'default';
+
+const tableMetadata = new Map();
+let resetMetadataFn = null;
+const linkMappings = new Map();
+let currentTenant = DEFAULT_TENANT;
+
+export const storageMode = {
+  mode: STORAGE_MODE,
+  isAnyApi() {
+    return STORAGE_MODE === 'anyapi';
+  },
+  defaultTenant: DEFAULT_TENANT,
+  get currentTenant() {
+    return currentTenant;
+  },
+  registerReset(fn) {
+    resetMetadataFn = fn;
+  },
+  setCurrentTenant(tenantId) {
+    currentTenant = tenantId || DEFAULT_TENANT;
+  },
+  registerTable(tableName, resourceName, tenantId = currentTenant || DEFAULT_TENANT) {
+    if (!tableName || !resourceName) return;
+    tableMetadata.set(tableName, {
+      resource: resourceName,
+      tenantId: tenantId || DEFAULT_TENANT,
+    });
+  },
+  registerLink(
+    tableName,
+    ownerResource,
+    relationshipName,
+    relationshipKey,
+    inverseRelationshipKey,
+    tenantId = currentTenant || DEFAULT_TENANT
+  ) {
+    if (!tableName || !ownerResource || !relationshipName) return;
+    linkMappings.set(tableName, {
+      ownerResource,
+      relationshipName,
+      relationshipKey,
+      inverseRelationshipKey,
+      tenantId: tenantId || DEFAULT_TENANT,
+    });
+  },
+  getResourceForTable(tableName) {
+    return tableMetadata.get(tableName)?.resource;
+  },
+  getTenantForTable(tableName) {
+    return tableMetadata.get(tableName)?.tenantId || DEFAULT_TENANT;
+  },
+  getLinkInfo(tableName) {
+    return linkMappings.get(tableName);
+  },
+  clearRegistry() {
+    tableMetadata.clear();
+    linkMappings.clear();
+    currentTenant = DEFAULT_TENANT;
+    if (resetMetadataFn) {
+      resetMetadataFn();
+    }
+  },
+};

package/tests/helpers/test-utils.js

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { storageMode } from './storage-mode.js';
 
 /**
  * Validates that a response follows JSON:API structure
@@ -48,8 +49,54 @@ export function resourceIdentifier(type, id) {
  * Cleans all records from the given tables
  */
 export async function cleanTables(knex, tableNames) {
-  for (const table of tableNames) {
-    await knex(table).delete();
+  if (storageMode.isAnyApi()) {
+    const resourceGroups = new Map();
+
+    for (const table of tableNames) {
+      const resource = storageMode.getResourceForTable(table);
+      if (!resource) continue;
+      const tenantId = storageMode.getTenantForTable(table);
+      const key = `${tenantId}::${resource}`;
+      if (!resourceGroups.has(key)) {
+        resourceGroups.set(key, { resource, tenantId });
+      }
+    }
+
+    for (const { resource, tenantId } of resourceGroups.values()) {
+      await knex('any_records')
+        .where({ tenant_id: tenantId, resource })
+        .delete();
+    }
+
+    for (const table of tableNames) {
+      const linkInfo = storageMode.getLinkInfo(table);
+      if (linkInfo) {
+        const tenantId = linkInfo.tenantId || storageMode.defaultTenant;
+        const relationshipKey = linkInfo.relationshipKey
+          || `${tenantId}:${linkInfo.ownerResource}:${linkInfo.relationshipName}`;
+        await knex('any_links')
+          .where({ tenant_id: tenantId })
+          .andWhere((builder) => {
+            builder.where('relationship', relationshipKey)
+              .orWhere('inverse_relationship', relationshipKey);
+            if (linkInfo.inverseRelationshipKey) {
+              builder.orWhere('relationship', linkInfo.inverseRelationshipKey)
+                .orWhere('inverse_relationship', linkInfo.inverseRelationshipKey);
+            }
+          })
+          .delete()
+          .catch(() => {});
+      }
+      try {
+        await knex(table).delete();
+      } catch (error) {
+        // Ignore missing tables in anyapi mode
+      }
+    }
+  } else {
+    for (const table of tableNames) {
+      await knex(table).delete();
+    }
   }
 }
 
@@ -57,6 +104,41 @@ export async function cleanTables(knex, tableNames) {
  * Counts records in a table
  */
 export async function countRecords(knex, tableName) {
+  if (storageMode.isAnyApi()) {
+    const resource = storageMode.getResourceForTable(tableName);
+    const linkInfo = storageMode.getLinkInfo(tableName);
+    const tenantId = storageMode.getTenantForTable(tableName);
+    if (linkInfo) {
+      const relationshipKey = linkInfo.relationshipKey
+        || `${tenantId}:${linkInfo.ownerResource}:${linkInfo.relationshipName}`;
+      const result = await knex('any_links')
+        .where({ tenant_id: tenantId })
+        .andWhere((builder) => {
+          builder.where('relationship', relationshipKey)
+            .orWhere('inverse_relationship', relationshipKey);
+        })
+        .count('* as count')
+        .first();
+      return parseInt(result?.count ?? 0, 10);
+    }
+    if (resource) {
+      const result = await knex('any_records')
+        .where({
+          tenant_id: tenantId,
+          resource,
+        })
+        .count('* as count')
+        .first();
+      return parseInt(result.count);
+    }
+    try {
+      const result = await knex(tableName).count('* as count').first();
+      return parseInt(result?.count || 0);
+    } catch (error) {
+      return 0;
+    }
+  }
+
   const result = await knex(tableName).count('* as count').first();
   return parseInt(result.count);
 }
@@ -118,4 +200,4 @@ export function assertResourceRelationship(resource, relationshipName, expectedI
     expectedIdentifier,
     `Relationship ${relationshipName} should match expected identifier`
   );
-}
+}

package/tests/include-depth-validation.test.js

@@ -271,6 +271,40 @@ describe('Include Depth Validation', () => {
     });
 
     it('should handle single-level paths correctly', async () => {
+      const country = await api.resources.countries.post({
+        inputRecord: {
+          data: {
+            type: 'countries',
+            attributes: { name: 'Single Level Country', code: `S${Date.now().toString().slice(-2)}` }
+          }
+        }
+      });
+
+      const publisher = await api.resources.publishers.post({
+        inputRecord: {
+          data: {
+            type: 'publishers',
+            attributes: { name: 'Single Level Publisher' },
+            relationships: {
+              country: { data: { type: 'countries', id: country.data.id } }
+            }
+          }
+        }
+      });
+
+      await api.resources.books.post({
+        inputRecord: {
+          data: {
+            type: 'books',
+            attributes: { title: 'Single Level Book' },
+            relationships: {
+              country: { data: { type: 'countries', id: country.data.id } },
+              publisher: { data: { type: 'publishers', id: publisher.data.id } }
+            }
+          }
+        }
+      });
+
       const result = await api.resources.books.query({
         queryParams: { include: ['publisher'] }
       });
@@ -294,4 +328,4 @@ describe('Include Depth Validation', () => {
       );
     });
   });
-});
+});

package/tests/nested-includes.test.js

@@ -7,6 +7,7 @@ import { RestApiKnexPlugin } from '../plugins/core/rest-api-knex-plugin.js';
 import {
   cleanTables,
   createJsonApiDocument,
+  createRelationship,
   validateJsonApiStructure
 } from './helpers/test-utils.js';
 
@@ -57,8 +58,9 @@ describe('Nested Include Operations', () => {
       },
       relationships: {
         books: { 
-          hasMany: 'books', 
-          foreignKey: 'publisher_id',
+          type: 'hasMany',
+          target: 'books', 
+          foreignKey: 'publisher_id'
           // Relationships are always includable via ?include=
         }
       }
@@ -74,7 +76,7 @@ describe('Nested Include Operations', () => {
       },
       relationships: {
         books: { 
-          hasMany: 'books', 
+          type: 'manyToMany',
           through: 'book_authors', 
           foreignKey: 'author_id', 
           otherKey: 'book_id',
@@ -97,15 +99,16 @@ describe('Nested Include Operations', () => {
       },
       relationships: {
         authors: { 
-          hasMany: 'authors', 
+          type: 'manyToMany',
           through: 'book_authors', 
           foreignKey: 'book_id', 
-          otherKey: 'author_id',
+          otherKey: 'author_id'
           // Relationships are always includable via ?include=
         },
         reviews: { 
-          hasMany: 'reviews', 
-          foreignKey: 'book_id',
+          type: 'hasMany',
+          target: 'reviews', 
+          foreignKey: 'book_id'
           // Relationships are always includable via ?include=
         }
       }
@@ -156,77 +159,83 @@ describe('Nested Include Operations', () => {
 
       const publisher = await api.resources.publishers.post({
         inputRecord: createJsonApiDocument('publishers', {
-          name: 'Test Publisher',
-          country_id: parseInt(country.id)
-        })
+          name: 'Test Publisher'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       // Create authors
       const author1 = await api.resources.authors.post({
         inputRecord: createJsonApiDocument('authors', {
-          name: 'Author 1',
-          country_id: parseInt(country.id)
-        })
+          name: 'Author 1'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       const author2 = await api.resources.authors.post({
         inputRecord: createJsonApiDocument('authors', {
-          name: 'Author 2',
-          country_id: parseInt(country.id)
-        })
+          name: 'Author 2'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       // Create books
       const book1 = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'Book 1',
-          publisher_id: parseInt(publisher.id)
-        })
+          title: 'Book 1'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher.id) })
+          })
       });
 
       const book2 = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'Book 2',
-          publisher_id: parseInt(publisher.id)
-        })
+          title: 'Book 2'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher.id) })
+          })
       });
 
       const book3 = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'Book 3',
-          publisher_id: parseInt(publisher.id)
-        })
+          title: 'Book 3'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher.id) })
+          })
       });
 
       // Create relationships
       // Book 1 - Author 1 only
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book1.id),
-          author_id: parseInt(author1.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book1.id) }),
+            author: createRelationship({ type: 'authors', id: String(author1.id) })
+          })
       });
 
       // Book 2 - Both authors
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book2.id),
-          author_id: parseInt(author1.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book2.id) }),
+            author: createRelationship({ type: 'authors', id: String(author1.id) })
+          })
       });
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book2.id),
-          author_id: parseInt(author2.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book2.id) }),
+            author: createRelationship({ type: 'authors', id: String(author2.id) })
+          })
       });
 
       // Book 3 - Author 2 only
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book3.id),
-          author_id: parseInt(author2.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book3.id) }),
+            author: createRelationship({ type: 'authors', id: String(author2.id) })
+          })
       });
     });
 
@@ -272,20 +281,25 @@ describe('Nested Include Operations', () => {
       const publisher = await api.resources.publishers.query({ simplified: false });
       const publisherId = publisher.data[0].id;
       
+      // Get the first author
+      const authorsResult = await api.resources.authors.query({ simplified: false });
+      const authorId = authorsResult.data[0].id;
+      
       for (let i = 4; i <= 10; i++) {
         const book = await api.resources.books.post({
           inputRecord: createJsonApiDocument('books', {
-            title: `Book ${i}`,
-            publisher_id: parseInt(publisherId)
-          })
+            title: `Book ${i}`
+          }, {
+              publisher: createRelationship({ type: 'publishers', id: publisherId })
+            })
         });
         
         // Associate all new books with Author 1
         await api.resources.book_authors.post({
-          inputRecord: createJsonApiDocument('book_authors', {
-            book_id: parseInt(book.id),
-            author_id: 1
-          })
+          inputRecord: createJsonApiDocument('book_authors', {}, {
+              book: createRelationship({ type: 'books', id: String(book.id) }),
+              author: createRelationship({ type: 'authors', id: String(authorId) })
+            })
         });
       }
 
@@ -334,52 +348,57 @@ describe('Nested Include Operations', () => {
 
       const publisher1 = await api.resources.publishers.post({
         inputRecord: createJsonApiDocument('publishers', {
-          name: 'US Publisher',
-          country_id: parseInt(usa.id)
-        })
+          name: 'US Publisher'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(usa.id) })
+          })
       });
 
       const publisher2 = await api.resources.publishers.post({
         inputRecord: createJsonApiDocument('publishers', {
-          name: 'UK Publisher',
-          country_id: parseInt(uk.id)
-        })
+          name: 'UK Publisher'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(uk.id) })
+          })
       });
 
       const author = await api.resources.authors.post({
         inputRecord: createJsonApiDocument('authors', {
-          name: 'International Author',
-          country_id: parseInt(usa.id)
-        })
+          name: 'International Author'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(usa.id) })
+          })
       });
 
       const book1 = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'US Book',
-          publisher_id: parseInt(publisher1.id)
-        })
+          title: 'US Book'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher1.id) })
+          })
       });
 
       const book2 = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'UK Book',
-          publisher_id: parseInt(publisher2.id)
-        })
+          title: 'UK Book'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher2.id) })
+          })
       });
 
       // Associate both books with the author
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book1.id),
-          author_id: parseInt(author.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book1.id) }),
+            author: createRelationship({ type: 'authors', id: String(author.id) })
+          })
       });
 
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book2.id),
-          author_id: parseInt(author.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book2.id) }),
+            author: createRelationship({ type: 'authors', id: String(author.id) })
+          })
       });
     });
 
@@ -445,47 +464,52 @@ describe('Nested Include Operations', () => {
 
       const publisher = await api.resources.publishers.post({
         inputRecord: createJsonApiDocument('publishers', {
-          name: 'Publisher',
-          country_id: parseInt(country.id)
-        })
+          name: 'Publisher'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       const author = await api.resources.authors.post({
         inputRecord: createJsonApiDocument('authors', {
-          name: 'Author',
-          country_id: parseInt(country.id)
-        })
+          name: 'Author'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       const book = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'Book with Reviews',
-          publisher_id: parseInt(publisher.id)
-        })
+          title: 'Book with Reviews'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher.id) })
+          })
       });
 
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book.id),
-          author_id: parseInt(author.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book.id) }),
+            author: createRelationship({ type: 'authors', id: String(author.id) })
+          })
       });
 
       // Create reviews
       await api.resources.reviews.post({
         inputRecord: createJsonApiDocument('reviews', {
           content: 'Great book!',
-          rating: 5,
-          book_id: parseInt(book.id)
-        })
+          rating: 5
+        }, {
+            book: createRelationship({ type: 'books', id: String(book.id) })
+          })
       });
 
       await api.resources.reviews.post({
         inputRecord: createJsonApiDocument('reviews', {
           content: 'Good read',
-          rating: 4,
-          book_id: parseInt(book.id)
-        })
+          rating: 4
+        }, {
+            book: createRelationship({ type: 'books', id: String(book.id) })
+          })
       });
     });
 
@@ -533,30 +557,33 @@ describe('Nested Include Operations', () => {
 
       const publisher = await api.resources.publishers.post({
         inputRecord: createJsonApiDocument('publishers', {
-          name: 'Publisher',
-          country_id: parseInt(country.id)
-        })
+          name: 'Publisher'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       const author = await api.resources.authors.post({
         inputRecord: createJsonApiDocument('authors', {
-          name: 'Author',
-          country_id: parseInt(country.id)
-        })
+          name: 'Author'
+        }, {
+            country: createRelationship({ type: 'countries', id: String(country.id) })
+          })
       });
 
       const book = await api.resources.books.post({
         inputRecord: createJsonApiDocument('books', {
-          title: 'Book',
-          publisher_id: parseInt(publisher.id)
-        })
+          title: 'Book'
+        }, {
+            publisher: createRelationship({ type: 'publishers', id: String(publisher.id) })
+          })
       });
 
       await api.resources.book_authors.post({
-        inputRecord: createJsonApiDocument('book_authors', {
-          book_id: parseInt(book.id),
-          author_id: parseInt(author.id)
-        })
+        inputRecord: createJsonApiDocument('book_authors', {}, {
+            book: createRelationship({ type: 'books', id: String(book.id) }),
+            author: createRelationship({ type: 'authors', id: String(author.id) })
+          })
       });
     });