json-rest-api 1.0.28 → 2.0.0

package/tests/polymorphic-relationships.test.js

@@ -1,347 +0,0 @@
-import { describe, it, before, after, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import { createExtendedApi } from './fixtures/api-configs.js'
-import {
-  validateJsonApiStructure,
-  cleanTables,
-  createJsonApiDocument,
-  createRelationship
-} from './helpers/test-utils.js'
-
-// Create Knex instance for tests
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-// API instance
-let api
-
-describe('Polymorphic Relationship Operations', () => {
-  before(async () => {
-    // Initialize API
-    api = await createExtendedApi(knex)
-  })
-
-  after(async () => {
-    // Close database connection
-    await knex.destroy()
-  })
-
-  describe('Creating Reviews with Polymorphic Relationships', () => {
-    beforeEach(async () => {
-      // Clean all tables before each test
-      await cleanTables(knex, [
-        'ext_countries', 'ext_publishers', 'ext_authors', 'ext_books',
-        'ext_book_authors', 'ext_reviews'
-      ])
-    })
-
-    it('should create a review for a book', async () => {
-      // Create a country first
-      const country = await api.resources.countries.post({
-        inputRecord: createJsonApiDocument('countries', {
-          name: 'USA',
-          code: 'US'
-        })
-      })
-
-      // Create a book
-      const book = await api.resources.books.post({
-        inputRecord: createJsonApiDocument('books', {
-          title: 'Test Book'
-        }, {
-          country: createRelationship({ type: 'countries', id: country.data.id })
-        })
-      })
-
-      // Create a review for the book
-      const review = await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 5,
-          title: 'Great book!',
-          content: 'This is an excellent book about testing.',
-          reviewer_name: 'John Doe',
-          reviewable_type: 'books',
-          reviewable_id: book.data.id
-        })
-      })
-
-      validateJsonApiStructure(review)
-      assert.equal(review.data.type, 'reviews')
-      assert.equal(review.data.attributes.rating, 5)
-      // Since polymorphic fields are filtered out from POST responses,
-      // we need to GET the record to verify the relationship was saved correctly
-    })
-
-    it('should create a review for an author', async () => {
-      // Create an author
-      const author = await api.resources.authors.post({
-        inputRecord: createJsonApiDocument('authors', {
-          name: 'Jane Doe'
-        })
-      })
-
-      // Create a review for the author
-      const review = await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 4,
-          title: 'Talented author',
-          content: 'Love this author\'s writing style!',
-          reviewer_name: 'Book Lover',
-          reviewable_type: 'authors',
-          reviewable_id: author.data.id
-        })
-      })
-
-      validateJsonApiStructure(review)
-      // Polymorphic fields are no longer in attributes, they're in relationships
-      assert.equal(review.data.relationships.reviewable.data.type, 'authors')
-      assert.equal(review.data.relationships.reviewable.data.id, String(author.data.id))
-    })
-
-    it('should create a review for a publisher', async () => {
-      // Create a country
-      const country = await api.resources.countries.post({
-        inputRecord: createJsonApiDocument('countries', {
-          name: 'UK',
-          code: 'GB'
-        })
-      })
-
-      // Create a publisher
-      const publisher = await api.resources.publishers.post({
-        inputRecord: createJsonApiDocument('publishers', {
-          name: 'Test Publisher'
-        }, {
-          country: createRelationship({ type: 'countries', id: country.data.id })
-        })
-      })
-
-      // Create a review for the publisher
-      const review = await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 3,
-          title: 'Good publisher',
-          content: 'They publish quality books.',
-          reviewer_name: 'Industry Expert',
-          reviewable_type: 'publishers',
-          reviewable_id: publisher.data.id
-        })
-      })
-
-      validateJsonApiStructure(review)
-      // Polymorphic fields are no longer in attributes, they're in relationships
-      assert.equal(review.data.relationships.reviewable.data.type, 'publishers')
-      assert.equal(review.data.relationships.reviewable.data.id, String(publisher.data.id))
-    })
-
-    it('should fail to create review with invalid reviewable_type', async () => {
-      // Skip this test for now - polymorphic validation happens at relationship level
-      // not at the attribute level, so we need to create a proper relationship
-      // This would require more complex validation implementation
-    })
-  })
-
-  describe('Querying Reviews with Polymorphic Relationships', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'ext_countries', 'ext_publishers', 'ext_authors', 'ext_books',
-        'ext_book_authors', 'ext_reviews'
-      ])
-    })
-
-    it('should query reviews and include polymorphic reviewable resource', async () => {
-      // Create test data
-      const country = await api.resources.countries.post({
-        inputRecord: createJsonApiDocument('countries', {
-          name: 'France',
-          code: 'FR'
-        })
-      })
-
-      const book = await api.resources.books.post({
-        inputRecord: createJsonApiDocument('books', {
-          title: 'Test Book for Review'
-        }, {
-          country: createRelationship({ type: 'countries', id: country.data.id })
-        })
-      })
-
-      await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 5,
-          title: 'Excellent!',
-          content: 'Must read!',
-          reviewer_name: 'Reader',
-          reviewable_type: 'books',
-          reviewable_id: book.data.id
-        })
-      })
-
-      // Query reviews with include
-      const result = await api.resources.reviews.query({
-        queryParams: {
-          include: ['reviewable']
-        }
-      })
-
-      validateJsonApiStructure(result, true) // It's a collection
-      assert.equal(result.data.length, 1)
-      assert.equal(result.data[0].type, 'reviews')
-
-      // Check included resources
-      assert(result.included)
-      assert.equal(result.included.length, 1)
-      assert.equal(result.included[0].type, 'books')
-      assert.equal(result.included[0].id, book.data.id)
-      assert.equal(result.included[0].attributes.title, 'Test Book for Review')
-    })
-
-    it('should handle mixed polymorphic types in a single query', async () => {
-      // Create test data
-      const country = await api.resources.countries.post({
-        inputRecord: createJsonApiDocument('countries', {
-          name: 'Germany',
-          code: 'DE'
-        })
-      })
-
-      const book = await api.resources.books.post({
-        inputRecord: createJsonApiDocument('books', {
-          title: 'German Book'
-        }, {
-          country: createRelationship({ type: 'countries', id: country.data.id })
-        })
-      })
-
-      const author = await api.resources.authors.post({
-        inputRecord: createJsonApiDocument('authors', {
-          name: 'German Author'
-        })
-      })
-
-      // Create reviews for different types
-      await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 5,
-          title: 'Great book',
-          content: 'Love it',
-          reviewer_name: 'Reader 1',
-          reviewable_type: 'books',
-          reviewable_id: book.data.id
-        })
-      })
-
-      await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 4,
-          title: 'Great author',
-          content: 'Talented writer',
-          reviewer_name: 'Reader 2',
-          reviewable_type: 'authors',
-          reviewable_id: author.data.id
-        })
-      })
-
-      // Query all reviews with includes
-      const result = await api.resources.reviews.query({
-        queryParams: {
-          include: ['reviewable']
-        }
-      })
-
-      validateJsonApiStructure(result, true) // It's a collection
-      assert.equal(result.data.length, 2)
-
-      // Check included resources
-      assert(result.included)
-      assert.equal(result.included.length, 2)
-
-      // Find each type in included
-      const includedBook = result.included.find(r => r.type === 'books')
-      const includedAuthor = result.included.find(r => r.type === 'authors')
-
-      assert(includedBook)
-      assert.equal(includedBook.attributes.title, 'German Book')
-
-      assert(includedAuthor)
-      assert.equal(includedAuthor.attributes.name, 'German Author')
-    })
-  })
-
-  describe('Reverse Polymorphic Queries', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'ext_countries', 'ext_publishers', 'ext_authors', 'ext_books',
-        'ext_book_authors', 'ext_reviews'
-      ])
-    })
-
-    it('should query books and include their reviews', async () => {
-      // Create test data
-      const country = await api.resources.countries.post({
-        inputRecord: createJsonApiDocument('countries', {
-          name: 'Spain',
-          code: 'ES'
-        })
-      })
-
-      const book = await api.resources.books.post({
-        inputRecord: createJsonApiDocument('books', {
-          title: 'Spanish Book'
-        }, {
-          country: createRelationship({ type: 'countries', id: country.data.id })
-        })
-      })
-
-      // Create multiple reviews for the book
-      await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 5,
-          title: 'Amazing!',
-          content: 'Best book ever',
-          reviewer_name: 'Fan 1',
-          reviewable_type: 'books',
-          reviewable_id: book.data.id
-        })
-      })
-
-      await api.resources.reviews.post({
-        inputRecord: createJsonApiDocument('reviews', {
-          rating: 4,
-          title: 'Very good',
-          content: 'Enjoyed reading it',
-          reviewer_name: 'Fan 2',
-          reviewable_type: 'books',
-          reviewable_id: book.data.id
-        })
-      })
-
-      // Query book with reviews
-      const result = await api.resources.books.get({
-        id: book.data.id,
-        queryParams: {
-          include: ['reviews']
-        }
-      })
-
-      validateJsonApiStructure(result)
-      assert.equal(result.data.type, 'books')
-
-      // Check included reviews
-      console.log('Result included:', JSON.stringify(result.included, null, 2))
-      assert(result.included)
-      assert.equal(result.included.length, 2)
-      assert(result.included.every(r => r.type === 'reviews'))
-      assert(result.included.every(r =>
-        r.relationships.reviewable.data.type === 'books' &&
-        String(r.relationships.reviewable.data.id) === String(book.data.id)
-      ))
-    })
-  })
-})

package/tests/polymorphic-simple.test.js

@@ -1,148 +0,0 @@
-import { describe, it, before, after, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import { createExtendedApi } from './fixtures/api-configs.js'
-import {
-  validateJsonApiStructure,
-  cleanTables,
-  createJsonApiDocument,
-  createRelationship
-} from './helpers/test-utils.js'
-
-// Create Knex instance for tests
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-// API instance
-let api
-
-describe('Polymorphic Relationships - Basic Tests', () => {
-  before(async () => {
-    // Initialize API
-    api = await createExtendedApi(knex)
-  })
-
-  after(async () => {
-    // Close database connection
-    await knex.destroy()
-  })
-
-  beforeEach(async () => {
-    // Clean all tables before each test
-    await cleanTables(knex, [
-      'ext_countries', 'ext_publishers', 'ext_authors', 'ext_books',
-      'ext_book_authors', 'ext_reviews'
-    ])
-  })
-
-  it('should create and retrieve a review for a book', async () => {
-    // Create a country first
-    const country = await api.resources.countries.post({
-      inputRecord: createJsonApiDocument('countries', {
-        name: 'USA',
-        code: 'US'
-      })
-    })
-
-    // Create a book
-    const book = await api.resources.books.post({
-      inputRecord: createJsonApiDocument('books', {
-        title: 'Test Book'
-      }, {
-        country: createRelationship({ type: 'countries', id: country.data.id })
-      })
-    })
-
-    // Create a review for the book
-    const review = await api.resources.reviews.post({
-      inputRecord: createJsonApiDocument('reviews', {
-        rating: 5,
-        title: 'Great book!',
-        content: 'This is an excellent book about testing.',
-        reviewer_name: 'John Doe'
-      }, {
-        reviewable: { data: { type: 'books', id: book.data.id } }
-      })
-    })
-
-    validateJsonApiStructure(review)
-    assert.equal(review.data.type, 'reviews')
-    assert.equal(review.data.attributes.rating, 5)
-
-    // Get the review back
-    const retrievedReview = await api.resources.reviews.get({
-      id: review.data.id
-    })
-
-    validateJsonApiStructure(retrievedReview)
-    // Polymorphic fields are no longer in attributes, they're in relationships
-    assert.equal(retrievedReview.data.relationships.reviewable.data.type, 'books')
-    assert.equal(retrievedReview.data.relationships.reviewable.data.id, String(book.data.id))
-  })
-
-  it('should query all reviews', async () => {
-    // Create test data
-    const country = await api.resources.countries.post({
-      inputRecord: createJsonApiDocument('countries', {
-        name: 'UK',
-        code: 'GB'
-      })
-    })
-
-    const book = await api.resources.books.post({
-      inputRecord: createJsonApiDocument('books', {
-        title: 'Book 1'
-      }, {
-        country: createRelationship({ type: 'countries', id: country.data.id })
-      })
-    })
-
-    const author = await api.resources.authors.post({
-      inputRecord: createJsonApiDocument('authors', {
-        name: 'Author 1'
-      })
-    })
-
-    // Create reviews
-    await api.resources.reviews.post({
-      inputRecord: createJsonApiDocument('reviews', {
-        rating: 5,
-        title: 'Great book',
-        content: 'Love it',
-        reviewer_name: 'Reader 1'
-      }, {
-        reviewable: { data: { type: 'books', id: book.data.id } }
-      })
-    })
-
-    await api.resources.reviews.post({
-      inputRecord: createJsonApiDocument('reviews', {
-        rating: 4,
-        title: 'Good author',
-        content: 'Nice writing',
-        reviewer_name: 'Reader 2'
-      }, {
-        reviewable: { data: { type: 'authors', id: author.data.id } }
-      })
-    })
-
-    // Query all reviews
-    const result = await api.resources.reviews.query({})
-
-    validateJsonApiStructure(result, true)
-    assert.equal(result.data.length, 2)
-
-    // Check we have one of each type
-    // Polymorphic fields are no longer in attributes, they're in relationships
-    const bookReview = result.data.find(r => r.relationships.reviewable.data.type === 'books')
-    const authorReview = result.data.find(r => r.relationships.reviewable.data.type === 'authors')
-
-    assert(bookReview, 'Should have a book review')
-    assert(authorReview, 'Should have an author review')
-  })
-})