json-rest-api 1.0.29 → 2.1.0

package/tests/full-jsonapi-belongsto-linkage.test.js

@@ -1,150 +0,0 @@
-import { after, before, beforeEach, describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import { createCamelCaseBelongsToApi } from './fixtures/api-configs.js'
-import {
-  createJsonApiDocument,
-  createRelationship,
-  resourceIdentifier,
-  assertResourceRelationship
-} from './helpers/test-utils.js'
-
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-let api
-
-describe('Full JSON:API belongsTo linkage', () => {
-  before(async () => {
-    api = await createCamelCaseBelongsToApi(knex)
-  })
-
-  after(async () => {
-    await knex.destroy()
-  })
-
-  beforeEach(async () => {
-    await knex('camel_fk_publishers').delete()
-    await knex('camel_fk_countries').delete()
-  })
-
-  const createCountry = async () => {
-    return api.resources.countries.post({
-      inputRecord: createJsonApiDocument('countries', {
-        name: 'United States'
-      }),
-      simplified: false
-    })
-  }
-
-  const createPublisher = async (countryId = null) => {
-    return api.resources.publishers.post({
-      inputRecord: createJsonApiDocument(
-        'publishers',
-        { name: 'Mapped Publisher' },
-        {
-          country: createRelationship(
-            countryId == null ? null : resourceIdentifier('countries', countryId)
-          )
-        }
-      ),
-      simplified: false
-    })
-  }
-
-  it('emits belongsTo linkage on primary resources without include for single and collection responses', async () => {
-    const country = await createCountry()
-    const publisher = await createPublisher(country.data.id)
-
-    assertResourceRelationship(
-      publisher.data,
-      'country',
-      resourceIdentifier('countries', country.data.id)
-    )
-    assert.equal(Object.hasOwn(publisher.data.attributes, 'countryId'), false)
-
-    const single = await api.resources.publishers.get({
-      id: publisher.data.id,
-      simplified: false
-    })
-
-    assertResourceRelationship(
-      single.data,
-      'country',
-      resourceIdentifier('countries', country.data.id)
-    )
-    assert.equal(Object.hasOwn(single.data.attributes, 'countryId'), false)
-
-    const collection = await api.resources.publishers.query({
-      simplified: false
-    })
-
-    assert.equal(collection.data.length, 1)
-    assertResourceRelationship(
-      collection.data[0],
-      'country',
-      resourceIdentifier('countries', country.data.id)
-    )
-    assert.equal(Object.hasOwn(collection.data[0].attributes, 'countryId'), false)
-  })
-
-  it('keeps primary belongsTo linkage when include is requested and adds included resources', async () => {
-    const country = await createCountry()
-    const publisher = await createPublisher(country.data.id)
-
-    const result = await api.resources.publishers.get({
-      id: publisher.data.id,
-      queryParams: {
-        include: ['country']
-      },
-      simplified: false,
-      returnFullRecord: 'full'
-    })
-
-    assertResourceRelationship(
-      result.data,
-      'country',
-      resourceIdentifier('countries', country.data.id)
-    )
-    assert.equal(Object.hasOwn(result.data.attributes, 'countryId'), false)
-    assert.equal(result.included?.length, 1)
-    assert.equal(result.included?.[0]?.type, 'countries')
-    assert.equal(result.included?.[0]?.id, country.data.id)
-  })
-
-  it('emits explicit null belongsTo linkage without exposing the foreign key attribute', async () => {
-    const country = await createCountry()
-    const publisher = await createPublisher(country.data.id)
-
-    const patched = await api.resources.publishers.patch({
-      id: publisher.data.id,
-      inputRecord: {
-        data: {
-          type: 'publishers',
-          id: publisher.data.id,
-          relationships: {
-            country: { data: null }
-          }
-        }
-      },
-      simplified: false,
-      returnFullRecord: 'full'
-    })
-
-    assert.equal(patched.data.relationships?.country?.data, null)
-    assert.equal(Object.hasOwn(patched.data.attributes, 'countryId'), false)
-
-    const single = await api.resources.publishers.get({
-      id: publisher.data.id,
-      simplified: false
-    })
-
-    assert.equal(single.data.relationships?.country?.data, null)
-    assert.equal(Object.hasOwn(single.data.attributes, 'countryId'), false)
-  })
-})

package/tests/helpers/fake-fastify.js

@@ -1,99 +0,0 @@
-export class FakeFastifyApp {
-  constructor () {
-    this.routes = []
-    this.parsers = []
-  }
-
-  route (definition) {
-    this.routes.push(definition)
-  }
-
-  addContentTypeParser (contentType, options, parser) {
-    this.parsers.push({ contentType, options, parser })
-  }
-
-  hasContentTypeParser (contentType) {
-    return this.parsers.some((entry) => entry.contentType === contentType)
-  }
-}
-
-export class FakeReply {
-  constructor () {
-    this.statusCode = null
-    this.contentType = null
-    this.headers = {}
-    this.payload = undefined
-  }
-
-  code (statusCode) {
-    this.statusCode = statusCode
-    return this
-  }
-
-  type (contentType) {
-    this.contentType = contentType
-    return this
-  }
-
-  header (name, value) {
-    this.headers[name] = value
-    return this
-  }
-
-  send (payload) {
-    this.payload = payload
-    return this
-  }
-}
-
-export function findFastifyRoute (app, method, url) {
-  return app.routes.find((route) => route.method === method && route.url === url)
-}
-
-export async function invokeFastifyRoute (
-  app,
-  {
-    method,
-    routeUrl,
-    requestUrl = routeUrl,
-    headers = {},
-    body,
-    params = {},
-    query = {}
-  }
-) {
-  const route = findFastifyRoute(app, method, routeUrl)
-  if (!route) {
-    throw new Error(`Fastify route not found: ${method} ${routeUrl}`)
-  }
-
-  const reply = new FakeReply()
-  const request = {
-    method,
-    url: requestUrl,
-    raw: { url: requestUrl },
-    headers,
-    body,
-    params,
-    query
-  }
-
-  if (typeof route.preValidation === 'function') {
-    await route.preValidation(request, reply)
-    if (reply.statusCode !== null || reply.payload !== undefined) {
-      return { route, request, reply }
-    }
-  }
-
-  try {
-    await route.handler(request, reply)
-  } catch (error) {
-    if (typeof route.errorHandler === 'function') {
-      await route.errorHandler(error, request, reply)
-    } else {
-      throw error
-    }
-  }
-
-  return { route, request, reply }
-}

package/tests/helpers/storage-mode.js

@@ -1,65 +0,0 @@
-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,203 +0,0 @@
-import assert from 'node:assert/strict'
-import { storageMode } from './storage-mode.js'
-
-/**
- * Validates that a response follows JSON:API structure
- */
-export function validateJsonApiStructure (response, isCollection = false) {
-  assert(response, 'Response should exist')
-
-  if (isCollection) {
-    assert(Array.isArray(response.data), 'Response data should be an array for collections')
-  } else {
-    assert(response.data && typeof response.data === 'object', 'Response data should be an object')
-    assert(!Array.isArray(response.data), 'Response data should not be an array for single resources')
-  }
-
-  // Validate each resource object
-  const resources = isCollection ? response.data : [response.data]
-  resources.forEach(resource => {
-    assert(resource.type, 'Resource should have a type')
-    assert(resource.id, 'Resource should have an id')
-    assert(resource.attributes && typeof resource.attributes === 'object', 'Resource should have attributes object')
-
-    if (resource.relationships) {
-      assert(typeof resource.relationships === 'object', 'Relationships should be an object')
-      Object.values(resource.relationships).forEach(rel => {
-        assert(rel.data !== undefined || rel.links !== undefined || rel.meta !== undefined,
-          'Relationship should have data, links, or meta')
-      })
-    }
-  })
-
-  if (response.included) {
-    assert(Array.isArray(response.included), 'Included should be an array')
-    response.included.forEach(resource => {
-      assert(resource.type && resource.id, 'Included resources should have type and id')
-    })
-  }
-}
-
-/**
- * Creates a resource identifier for JSON:API relationships
- */
-export function resourceIdentifier (type, id) {
-  return { type, id: String(id) }
-}
-
-/**
- * Cleans all records from the given tables
- */
-export async function cleanTables (knex, tableNames) {
-  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()
-    }
-  }
-}
-
-/**
- * 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)
-}
-
-/**
- * Helper to create a JSON:API document for POST/PUT/PATCH
- */
-export function createJsonApiDocument (type, attributes, relationships = {}) {
-  const doc = {
-    data: {
-      type,
-      attributes
-    }
-  }
-
-  if (Object.keys(relationships).length > 0) {
-    doc.data.relationships = relationships
-  }
-
-  return doc
-}
-
-/**
- * Helper to create a relationship object
- */
-export function createRelationship (resourceIdentifier) {
-  return {
-    data: resourceIdentifier
-  }
-}
-
-/**
- * Helper to create a to-many relationship object
- */
-export function createToManyRelationship (resourceIdentifiers) {
-  return {
-    data: resourceIdentifiers
-  }
-}
-
-/**
- * Asserts that a resource has specific attributes
- */
-export function assertResourceAttributes (resource, expectedAttributes) {
-  Object.entries(expectedAttributes).forEach(([key, value]) => {
-    assert.deepEqual(resource.attributes[key], value,
-      `Attribute ${key} should equal ${JSON.stringify(value)}`)
-  })
-}
-
-/**
- * Asserts that a resource has a specific relationship
- */
-export function assertResourceRelationship (resource, relationshipName, expectedIdentifier) {
-  assert(resource.relationships, 'Resource should have relationships')
-  assert(resource.relationships[relationshipName], `Resource should have ${relationshipName} relationship`)
-  assert.deepEqual(
-    resource.relationships[relationshipName].data,
-    expectedIdentifier,
-    `Relationship ${relationshipName} should match expected identifier`
-  )
-}