json-rest-api 1.0.29 → 2.0.0

package/tests/projected-fields.test.js

@@ -1,319 +0,0 @@
-import { describe, it, before, beforeEach, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { Api } from 'hooked-api'
-import knexLib from 'knex'
-import { LabelPlugin, QueryProjectionsPlugin, RestApiKnexPlugin, RestApiPlugin } from '../index.js'
-import {
-  cleanTables,
-  createJsonApiDocument,
-  createRelationship,
-  resourceIdentifier,
-  validateJsonApiStructure,
-} from './helpers/test-utils.js'
-import { createProjectedFieldsApi } from './fixtures/api-configs.js'
-
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-describe('Query Projections', () => {
-  let api
-  const testData = {}
-
-  before(async () => {
-    api = await createProjectedFieldsApi(knex)
-  })
-
-  after(async () => {
-    await knex.destroy()
-  })
-
-  beforeEach(async () => {
-    await cleanTables(knex, ['projected_books', 'projected_authors'])
-
-    const authorPayloads = [
-      { first_name: 'Alex', last_name: 'Carter' },
-      { first_name: 'Alex', last_name: 'Carter' },
-      { first_name: 'Bella', last_name: 'Stone' },
-      { first_name: 'Aaron', last_name: 'Zephyr' }
-    ]
-
-    testData.authors = []
-    for (const payload of authorPayloads) {
-      const result = await api.resources.authors.post({
-        inputRecord: createJsonApiDocument('authors', payload),
-        simplified: false
-      })
-      testData.authors.push(result.data)
-    }
-
-    testData.expectedAuthorOrder = [
-      testData.authors[3].id,
-      testData.authors[0].id,
-      testData.authors[1].id,
-      testData.authors[2].id
-    ]
-
-    const bookOne = await api.resources.books.post({
-      inputRecord: createJsonApiDocument(
-        'books',
-        { title: 'Derived Fields Handbook' },
-        { author: createRelationship(resourceIdentifier('authors', testData.authors[0].id)) }
-      ),
-      simplified: false
-    })
-
-    const bookTwo = await api.resources.books.post({
-      inputRecord: createJsonApiDocument(
-        'books',
-        { title: 'Cursor Patterns' },
-        { author: createRelationship(resourceIdentifier('authors', testData.authors[2].id)) }
-      ),
-      simplified: false
-    })
-
-    testData.books = [bookOne.data, bookTwo.data]
-  })
-
-  async function createEphemeralProjectionApi (resourceName, resourceOptions) {
-    const api = new Api({
-      name: `${resourceName}-projection-test-api`,
-      log: { level: process.env.LOG_LEVEL || 'info' }
-    })
-
-    await api.use(RestApiPlugin, {
-      simplifiedApi: true,
-      simplifiedTransport: true,
-      returnRecordApi: {
-        post: true,
-        put: true,
-        patch: true
-      }
-    })
-    await api.use(QueryProjectionsPlugin)
-    await api.use(RestApiKnexPlugin, { knex })
-    await api.addResource(resourceName, resourceOptions)
-
-    return api
-  }
-
-  it('should return query projection fields by default and ignore query projection input on writes', async () => {
-    const created = await api.resources.authors.post({
-      inputRecord: createJsonApiDocument('authors', {
-        first_name: 'Nina',
-        last_name: 'Simone',
-        full_name: 'Injected Value'
-      }),
-      simplified: false
-    })
-
-    validateJsonApiStructure(created)
-    assert.equal(created.data.attributes.first_name, 'Nina')
-    assert.equal(created.data.attributes.last_name, 'Simone')
-    assert.equal(created.data.attributes.full_name, 'Nina Simone')
-
-    const fetched = await api.resources.authors.get({
-      id: created.data.id,
-      simplified: false
-    })
-
-    validateJsonApiStructure(fetched)
-    assert.equal(fetched.data.attributes.full_name, 'Nina Simone')
-  })
-
-  it('should allow query projection fields in sparse fieldsets', async () => {
-    const result = await api.resources.authors.get({
-      id: testData.authors[0].id,
-      queryParams: {
-        fields: {
-          authors: 'first_name,full_name'
-        }
-      },
-      simplified: false
-    })
-
-    validateJsonApiStructure(result)
-    assert.equal(result.data.attributes.first_name, 'Alex')
-    assert.equal(result.data.attributes.full_name, 'Alex Carter')
-    assert.equal(result.data.attributes.last_name, undefined)
-  })
-
-  it('should expose query projection fields on included resources', async () => {
-    const result = await api.resources.books.get({
-      id: testData.books[0].id,
-      queryParams: {
-        include: ['author'],
-        fields: {
-          books: 'title',
-          authors: 'full_name'
-        }
-      },
-      simplified: false
-    })
-
-    validateJsonApiStructure(result)
-    assert.ok(Array.isArray(result.included))
-
-    const includedAuthor = result.included.find((resource) => resource.type === 'authors')
-    assert.ok(includedAuthor, 'expected included author resource')
-    assert.equal(includedAuthor.attributes.full_name, 'Alex Carter')
-    assert.equal(includedAuthor.attributes.first_name, undefined)
-    assert.equal(includedAuthor.attributes.last_name, undefined)
-  })
-
-  it('should support stable cursor pagination when sorting by a query projection field', async () => {
-    const seenIds = []
-    const seenFirstNames = []
-    let nextCursor = null
-    let iterations = 0
-    let firstCursor = null
-
-    while (iterations < 10) {
-      const result = await api.resources.authors.query({
-        queryParams: {
-          sort: ['full_name'],
-          fields: {
-            authors: 'first_name'
-          },
-          page: {
-            size: 1,
-            ...(nextCursor ? { after: nextCursor } : {})
-          }
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-      assert.equal(result.data.length, 1)
-
-      const resource = result.data[0]
-      seenIds.push(resource.id)
-      seenFirstNames.push(resource.attributes.first_name)
-      assert.equal(resource.attributes.full_name, undefined)
-
-      if (!firstCursor && result.meta?.pagination?.cursor?.next) {
-        firstCursor = result.meta.pagination.cursor.next
-      }
-
-      if (!result.meta?.pagination?.hasMore) {
-        break
-      }
-
-      nextCursor = result.meta.pagination.cursor.next
-      iterations += 1
-    }
-
-    assert.deepEqual(seenIds, testData.expectedAuthorOrder)
-    assert.equal(new Set(seenIds).size, seenIds.length, 'cursor pagination should not duplicate records')
-    assert.ok(firstCursor?.includes('full_name:'), 'cursor should encode query projection sort field')
-    assert.ok(firstCursor?.includes('id:'), 'cursor should append id as deterministic tie-breaker')
-    assert.deepEqual(seenFirstNames, ['Aaron', 'Alex', 'Alex', 'Bella'])
-  })
-
-  it('should allow sorting by a normallyHidden query projection field without returning it by default', async () => {
-    const result = await api.resources.authors.query({
-      queryParams: {
-        sort: ['sort_name']
-      },
-      simplified: false
-    })
-
-    validateJsonApiStructure(result, true)
-    assert.deepEqual(
-      result.data.map((resource) => resource.id),
-      testData.expectedAuthorOrder
-    )
-    result.data.forEach((resource) => {
-      assert.equal(resource.attributes.sort_name, undefined)
-    })
-  })
-
-  it('should reject query projection expressions that return plain SQL strings', async () => {
-    const stringApi = await createEphemeralProjectionApi('string_projection_authors', {
-      schema: {
-        id: { type: 'id' },
-        first_name: { type: 'string', required: true },
-        last_name: { type: 'string', required: true }
-      },
-      queryFields: {
-        full_name: {
-          type: 'string',
-          select: () => "trim(coalesce(first_name, '') || ' ' || coalesce(last_name, ''))"
-        }
-      },
-      tableName: 'projected_authors_string_expr'
-    })
-
-    await stringApi.resources.string_projection_authors.createKnexTable()
-    await knex('projected_authors_string_expr').insert({
-      first_name: 'Nina',
-      last_name: 'Simone'
-    })
-
-    await assert.rejects(
-      () => stringApi.resources.string_projection_authors.query({
-        queryParams: {},
-        simplified: false
-      }),
-      /Query field expressions must return knex raw, knex ref, or a knex query builder/
-    )
-  })
-
-  it('should reject query projection names that conflict with relationship names', async () => {
-    await assert.rejects(
-      () => createEphemeralProjectionApi('conflicting_projection_authors', {
-        schema: {
-          id: { type: 'id' },
-          name: { type: 'string', required: true }
-        },
-        queryFields: {
-          books: {
-            type: 'string',
-            select: ({ knex }) => knex.raw("'X'")
-          }
-        },
-        relationships: {
-          books: { type: 'hasMany', target: 'books', foreignKey: 'author_id' }
-        },
-        tableName: 'projected_authors_conflict'
-      }),
-      /conflicts with an existing schema/
-    )
-  })
-
-  it('should reject query projection names that conflict with computed fields injected by plugins', async () => {
-    const labeledApi = new Api({
-      name: 'label-projection-conflict-api',
-      log: { level: process.env.LOG_LEVEL || 'info' }
-    })
-
-    await labeledApi.use(RestApiPlugin, {
-      simplifiedApi: true,
-      simplifiedTransport: true
-    })
-    await labeledApi.use(LabelPlugin)
-    await labeledApi.use(QueryProjectionsPlugin)
-    await labeledApi.use(RestApiKnexPlugin, { knex })
-
-    await assert.rejects(
-      () => labeledApi.addResource('labeled_projection_authors', {
-        schema: {
-          id: { type: 'id' },
-          name: { type: 'string', required: true }
-        },
-        queryFields: {
-          label: {
-            type: 'string',
-            select: ({ knex }) => knex.raw("'X'")
-          }
-        },
-        tableName: 'projected_authors_label_conflict'
-      }),
-      /conflicts with an existing schema, computed, or relationship name/
-    )
-  })
-})

package/tests/public-exports.test.js

@@ -1,15 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { RowPolicyPlugin, SocketIOPlugin } from '../index.js'
-
-describe('Public exports', () => {
-  it('exports the documented Socket.IO plugin from the package entrypoint', () => {
-    assert.equal(SocketIOPlugin.name, 'socketio')
-    assert.equal(typeof SocketIOPlugin.install, 'function')
-  })
-
-  it('exports the row-policy plugin from the package entrypoint', () => {
-    assert.equal(RowPolicyPlugin.name, 'row-policy')
-    assert.equal(typeof RowPolicyPlugin.install, 'function')
-  })
-})

package/tests/put-create-parity.test.js

@@ -1,216 +0,0 @@
-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 {
-  RestApiAnyapiKnexPlugin,
-  RestApiKnexPlugin,
-  RestApiPlugin,
-} from '../index.js'
-import { ensureAnyApiSchema } from '../plugins/core/lib/anyapi/schema-utils.js'
-import {
-  cleanTables,
-  validateJsonApiStructure,
-} from './helpers/test-utils.js'
-import { storageMode } from './helpers/storage-mode.js'
-
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-const tenantId = 'put_create_parity_tenant'
-const profilesTable = 'put_create_profiles'
-const accountsTable = 'put_create_accounts'
-
-let api
-
-const registerTable = (tableName, resourceName) => {
-  if (storageMode.isAnyApi()) {
-    storageMode.registerTable(tableName, resourceName, tenantId)
-  }
-}
-
-const findStoredRow = async (tableName, resourceName, idColumn, id) => {
-  if (storageMode.isAnyApi()) {
-    return knex('any_records')
-      .where({
-        tenant_id: tenantId,
-        resource: resourceName,
-        logical_id: String(id),
-      })
-      .first()
-  }
-
-  return knex(tableName)
-    .where(idColumn, id)
-    .first()
-}
-
-const countStoredRows = async (tableName, resourceName, idColumn, id) => {
-  if (storageMode.isAnyApi()) {
-    const row = await knex('any_records')
-      .where({
-        tenant_id: tenantId,
-        resource: resourceName,
-        logical_id: String(id),
-      })
-      .count('* as count')
-      .first()
-    return Number(row?.count || 0)
-  }
-
-  const row = await knex(tableName)
-    .where(idColumn, id)
-    .count('* as count')
-    .first()
-  return Number(row?.count || 0)
-}
-
-describe(`PUT create parity (${storageMode.mode})`, () => {
-  before(async () => {
-    if (storageMode.isAnyApi()) {
-      storageMode.clearRegistry()
-      storageMode.setCurrentTenant(tenantId)
-      await ensureAnyApiSchema(knex)
-    }
-
-    api = new Api({
-      name: 'put-create-parity-test',
-      log: { level: 'warn' }
-    })
-
-    await api.use(RestApiPlugin, {
-      simplifiedApi: false,
-      simplifiedTransport: false,
-      returnRecordApi: {
-        post: 'full',
-        put: 'full',
-        patch: 'full'
-      },
-      returnRecordTransport: {
-        post: 'full',
-        put: 'full',
-        patch: 'full'
-      },
-      sortableFields: ['id', 'account_id', 'name', 'code']
-    })
-
-    if (storageMode.isAnyApi()) {
-      await api.use(RestApiAnyapiKnexPlugin, { knex, tenantId })
-    } else {
-      await api.use(RestApiKnexPlugin, { knex })
-    }
-
-    await api.addResource('profiles', {
-      tableName: profilesTable,
-      schema: {
-        id: { type: 'id' },
-        name: { type: 'string', required: true },
-        code: { type: 'string', required: true },
-      }
-    })
-    await api.resources.profiles.createKnexTable()
-    registerTable(profilesTable, 'profiles')
-
-    await api.addResource('accounts', {
-      tableName: accountsTable,
-      idProperty: 'account_id',
-      schema: {
-        name: { type: 'string', required: true },
-        code: { type: 'string', required: true },
-      }
-    })
-    await api.resources.accounts.createKnexTable()
-    registerTable(accountsTable, 'accounts')
-  })
-
-  after(async () => {
-    await api?.release()
-    await knex.destroy()
-    if (storageMode.isAnyApi()) {
-      storageMode.clearRegistry()
-    }
-  })
-
-  beforeEach(async () => {
-    await cleanTables(knex, [profilesTable, accountsTable])
-  })
-
-  it('creates a missing resource through PUT with the default id property', async () => {
-    const created = await api.resources.profiles.put({
-      id: '101',
-      inputRecord: {
-        data: {
-          type: 'profiles',
-          id: '101',
-          attributes: {
-            name: 'Created Profile',
-            code: 'CP'
-          }
-        }
-      },
-      simplified: false
-    })
-
-    validateJsonApiStructure(created)
-    assert.equal(created.data.id, '101')
-    assert.equal(created.data.attributes.name, 'Created Profile')
-
-    const stored = await findStoredRow(profilesTable, 'profiles', 'id', 101)
-    assert(stored, 'PUT create should persist a row')
-  })
-
-  it('creates and then replaces a missing resource through PUT with a custom id property', async () => {
-    const created = await api.resources.accounts.put({
-      id: '501',
-      inputRecord: {
-        data: {
-          type: 'accounts',
-          id: '501',
-          attributes: {
-            name: 'Created Account',
-            code: 'CA'
-          }
-        }
-      },
-      simplified: false
-    })
-
-    validateJsonApiStructure(created)
-    assert.equal(created.data.id, '501')
-    assert.equal(created.data.attributes.name, 'Created Account')
-    assert.equal(created.data.attributes.account_id, undefined)
-
-    const replaced = await api.resources.accounts.put({
-      id: '501',
-      inputRecord: {
-        data: {
-          type: 'accounts',
-          id: '501',
-          attributes: {
-            name: 'Replaced Account',
-            code: 'RA'
-          }
-        }
-      },
-      simplified: false
-    })
-
-    assert.equal(replaced.data.id, '501')
-    assert.equal(replaced.data.attributes.name, 'Replaced Account')
-    assert.equal(await countStoredRows(accountsTable, 'accounts', 'account_id', 501), 1)
-
-    const fetched = await api.resources.accounts.get({
-      id: '501',
-      simplified: false
-    })
-    assert.equal(fetched.data.attributes.name, 'Replaced Account')
-    assert.equal(fetched.data.attributes.code, 'RA')
-    assert.equal(fetched.data.attributes.account_id, undefined)
-  })
-})