@api-client/core 0.19.19 → 0.19.21

package/tests/unit/modeling/actions/ListAction.spec.ts

@@ -1,105 +1,45 @@
 import { test } from '@japa/runner'
 import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
-import { PaginationStrategy } from '../../../../src/modeling/types.js'
 
 test.group('ListAction', () => {
   test('initializes with default values', ({ assert }) => {
     const action = new ListAction({} as any)
     assert.equal(action.kind, 'list')
-    assert.deepEqual(action.pagination, { kind: 'offset' })
-    assert.deepEqual(action.filterableFields, [])
-    assert.deepEqual(action.sortableFields, [])
+    assert.isUndefined(action.cacheTtl)
     assert.isEmpty(action.accessRule) // Inherited from Action
   }).tags(['@modeling', '@action', '@list-action'])
 
   test('initializes with provided values', ({ assert }) => {
-    const pagination: PaginationStrategy = { kind: 'cursor' }
-    const filterableFields = ['name', 'status']
-    const sortableFields = ['createdAt']
+    const cacheTtl = 100
 
     const action = new ListAction({} as any, {
-      pagination,
-      filterableFields,
-      sortableFields,
+      cacheTtl,
     })
 
-    assert.deepEqual(action.pagination, pagination)
-    assert.deepEqual(action.filterableFields, filterableFields)
-    assert.deepEqual(action.sortableFields, sortableFields)
+    assert.equal(action.cacheTtl, cacheTtl)
   }).tags(['@modeling', '@action', '@list-action'])
 
-  test('constructor copies arrays and objects (immutability)', ({ assert }) => {
-    const pagination: PaginationStrategy = { kind: 'offset' }
-    const filterableFields = ['name']
-    const sortableFields = ['name']
-
-    const action = new ListAction({} as any, {
-      pagination,
-      filterableFields,
-      sortableFields,
-    })
-
-    // Modify original sources
-    pagination.kind = 'cursor'
-    filterableFields.push('age')
-    sortableFields.push('age')
-
-    assert.deepEqual(action.pagination, { kind: 'offset' })
-    assert.deepEqual(action.filterableFields, ['name'])
-    assert.deepEqual(action.sortableFields, ['name'])
-  }).tags(['@modeling', '@action', '@list-action', '@immutability'])
-
   test('toJSON returns safe copy', ({ assert }) => {
     const action = new ListAction({} as any, {
-      pagination: { kind: 'offset' },
-      filterableFields: ['name'],
-      sortableFields: ['name'],
+      cacheTtl: 100,
     })
 
     const json = action.toJSON()
 
     // Modify JSON
-    json.pagination.kind = 'cursor'
-    json.filterableFields.push('new')
-    json.sortableFields.push('new')
+    json.cacheTtl = 200
 
-    assert.deepEqual(action.pagination, { kind: 'offset' })
-    assert.deepEqual(action.filterableFields, ['name'])
-    assert.deepEqual(action.sortableFields, ['name'])
+    assert.equal(action.cacheTtl, 100)
   }).tags(['@modeling', '@action', '@list-action', '@immutability'])
 
-  test('notifies change when pagination changes', async ({ assert }) => {
-    const action = new ListAction({} as any)
-    let notified = false
-    action.addEventListener('change', () => {
-      notified = true
-    })
-
-    action.pagination = { kind: 'cursor' }
-    await Promise.resolve()
-    assert.isTrue(notified)
-  }).tags(['@modeling', '@action', '@list-action', '@observed'])
-
-  test('notifies change when filterableFields changes', async ({ assert }) => {
-    const action = new ListAction({} as any)
-    let notified = false
-    action.addEventListener('change', () => {
-      notified = true
-    })
-
-    action.filterableFields = ['name']
-    await Promise.resolve()
-    assert.isTrue(notified)
-  }).tags(['@modeling', '@action', '@list-action', '@observed'])
-
-  test('notifies change when sortableFields changes', async ({ assert }) => {
+  test('notifies change when cacheTtl changes', async ({ assert }) => {
     const action = new ListAction({} as any)
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
-    action.sortableFields = ['name']
+    action.cacheTtl = 100
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@list-action', '@observed'])

package/tests/unit/modeling/actions/SearchAction.spec.ts

@@ -5,68 +5,42 @@ test.group('SearchAction', () => {
   test('initializes with default values', ({ assert }) => {
     const action = new SearchAction({} as any)
     assert.equal(action.kind, 'search')
-    assert.deepEqual(action.fields, [])
+    assert.isUndefined(action.maxAstDepth)
     assert.isEmpty(action.accessRule)
   }).tags(['@modeling', '@action', '@search-action'])
 
   test('initializes with provided values', ({ assert }) => {
-    const fields = ['name', 'description']
+    const maxAstDepth = 10
     const action = new SearchAction({} as any, {
-      fields,
+      maxAstDepth,
     })
 
     assert.equal(action.kind, 'search')
-    assert.deepEqual(action.fields, fields)
+    assert.equal(action.maxAstDepth, maxAstDepth)
   }).tags(['@modeling', '@action', '@search-action'])
 
-  test('constructor copies arrays (immutability)', ({ assert }) => {
-    const fields = ['name']
-
-    const action = new SearchAction({} as any, {
-      fields,
-    })
-
-    // Modify original source
-    fields.push('age')
-
-    assert.deepEqual(action.fields, ['name'])
-  }).tags(['@modeling', '@action', '@search-action', '@immutability'])
-
   test('toJSON returns valid schema', ({ assert }) => {
     const action = new SearchAction({} as any, {
-      fields: ['name'],
+      maxAstDepth: 10,
     })
 
     const json = action.toJSON()
 
     // Modify JSON
-    json.fields.push('new')
+    json.maxAstDepth = 20
 
     assert.equal(json.kind, 'search')
-    assert.lengthOf(action.fields, 1) // Ensure immutability
-    assert.equal(action.fields[0], 'name')
+    assert.equal(action.maxAstDepth, 10)
   }).tags(['@modeling', '@action', '@search-action', '@serialization', '@immutability'])
 
-  test('notifies change when fields changes', async ({ assert }) => {
-    const action = new SearchAction({} as any)
-    let notified = false
-    action.addEventListener('change', () => {
-      notified = true
-    })
-
-    action.fields = ['name']
-    await Promise.resolve()
-    assert.isTrue(notified)
-  }).tags(['@modeling', '@action', '@search-action', '@observed'])
-
-  test('notifies change when fields value change', async ({ assert }) => {
+  test('notifies change when maxAstDepth changes', async ({ assert }) => {
     const action = new SearchAction({} as any)
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
-    action.fields.push('name')
+    action.maxAstDepth = 10
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@search-action', '@observed'])

package/tests/unit/modeling/api_model.spec.ts

@@ -33,6 +33,7 @@ test.group('ApiModel.createSchema()', () => {
     assert.isUndefined(schema.termsOfService)
     assert.isUndefined(schema.contact)
     assert.isUndefined(schema.license)
+    assert.deepEqual(schema.pagination, { kind: 'cursor' })
   }).tags(['@modeling', '@api', '@schema'])
 
   test('creates a schema with provided values', ({ assert }) => {
@@ -59,6 +60,7 @@ test.group('ApiModel.createSchema()', () => {
       termsOfService: 'https://example.com/terms',
       contact: { name: 'John Doe', email: 'john.doe@example.com' } as ApiContact,
       license: { name: 'MIT', url: 'https://opensource.org/licenses/MIT' } as ApiLicense,
+      pagination: { kind: 'offset', defaultLimit: 10 },
     }
     const schema = ApiModel.createSchema(input)
 
@@ -77,6 +79,7 @@ test.group('ApiModel.createSchema()', () => {
     assert.equal(schema.termsOfService, 'https://example.com/terms')
     assert.deepEqual(schema.contact, { name: 'John Doe', email: 'john.doe@example.com' })
     assert.deepEqual(schema.license, { name: 'MIT', url: 'https://opensource.org/licenses/MIT' })
+    assert.deepEqual(schema.pagination, { kind: 'offset', defaultLimit: 10 })
   }).tags(['@modeling', '@api', '@schema'])
 
   test('creates a schema with partial info', ({ assert }) => {
@@ -108,6 +111,7 @@ test.group('ApiModel.constructor()', () => {
     assert.isUndefined(model.contact)
     assert.isUndefined(model.license)
     assert.deepEqual(model.dependencyList, [])
+    assert.deepEqual(model.pagination, { kind: 'cursor' })
   }).tags(['@modeling', '@api', '@creation'])
 
   test('creates an instance with provided schema values', ({ assert }) => {
@@ -135,6 +139,7 @@ test.group('ApiModel.constructor()', () => {
       termsOfService: 'https://example.com/terms',
       contact: { name: 'John Doe', email: 'john.doe@example.com' },
       license: { name: 'MIT', url: 'https://opensource.org/licenses/MIT' },
+      pagination: { kind: 'offset', maxLimit: 50 },
     }
     const model = new ApiModel(schema)
 
@@ -152,6 +157,7 @@ test.group('ApiModel.constructor()', () => {
     assert.equal(model.termsOfService, 'https://example.com/terms')
     assert.deepEqual(model.contact, { name: 'John Doe', email: 'john.doe@example.com' })
     assert.deepEqual(model.license, { name: 'MIT', url: 'https://opensource.org/licenses/MIT' })
+    assert.deepEqual(model.pagination, { kind: 'offset', maxLimit: 50 })
   }).tags(['@modeling', '@api', '@creation'])
 
   test('creates an instance with a DataDomain', ({ assert }) => {
@@ -220,6 +226,25 @@ test.group('ApiModel.constructor()', () => {
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@api', '@observed'])
+
+  test('notifies change when pagination changes', async ({ assert }) => {
+    const model = new ApiModel()
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+
+    // Test mutability notifications
+    model.pagination.defaultLimit = 100
+    await Promise.resolve()
+    assert.isTrue(notified)
+    notified = false
+
+    // Test object reassignment
+    model.pagination = { kind: 'offset', maxLimit: 50 }
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@api', '@observed'])
 })
 
 test.group('ApiModel.toJSON()', () => {
@@ -241,6 +266,7 @@ test.group('ApiModel.toJSON()', () => {
     assert.isUndefined(json.termsOfService)
     assert.isUndefined(json.contact)
     assert.isUndefined(json.license)
+    assert.deepEqual(json.pagination, { kind: 'cursor' })
   }).tags(['@modeling', '@api', '@serialization'])
 
   test('serializes all provided values', ({ assert }) => {
@@ -268,6 +294,7 @@ test.group('ApiModel.toJSON()', () => {
       termsOfService: 'https://example.com/terms',
       contact: { name: 'John Doe', email: 'john.doe@example.com' },
       license: { name: 'MIT', url: 'https://opensource.org/licenses/MIT' },
+      pagination: { kind: 'cursor', defaultLimit: 25 },
     }
     const model = new ApiModel(schema)
     const json = model.toJSON()
@@ -286,6 +313,7 @@ test.group('ApiModel.toJSON()', () => {
     assert.equal(json.termsOfService, 'https://example.com/terms')
     assert.deepEqual(json.contact, { name: 'John Doe', email: 'john.doe@example.com' })
     assert.deepEqual(json.license, { name: 'MIT', url: 'https://opensource.org/licenses/MIT' })
+    assert.deepEqual(json.pagination, { kind: 'cursor', defaultLimit: 25 })
   }).tags(['@modeling', '@api', '@serialization'])
 
   test('actions are immutable', ({ assert }) => {

package/tests/unit/modeling/definitions/sku.spec.ts

@@ -130,9 +130,7 @@ test.group('SKU Value Validation', () => {
 
   test('should reject empty or null values', ({ assert }) => {
     assert.include(validateSKUValue(''), 'SKU value must be a non-empty string')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     assert.include(validateSKUValue(null as any), 'SKU value must be a non-empty string')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     assert.include(validateSKUValue(undefined as any), 'SKU value must be a non-empty string')
   })
 

package/tests/unit/modeling/domain_property.spec.ts

@@ -13,6 +13,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.multiple)
     assert.isUndefined(schema.required)
     assert.isUndefined(schema.index)
+    assert.isUndefined(schema.search)
     assert.isUndefined(schema.primary)
     assert.isUndefined(schema.readOnly)
     assert.isUndefined(schema.writeOnly)
@@ -31,6 +32,7 @@ test.group('DomainProperty.createSchema()', () => {
       multiple: true,
       primary: true,
       index: true,
+      search: true,
       readOnly: true,
       writeOnly: true,
       deprecated: true,
@@ -48,6 +50,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isTrue(schema.multiple)
     assert.isTrue(schema.primary)
     assert.isTrue(schema.index)
+    assert.isTrue(schema.search)
     assert.isTrue(schema.readOnly)
     assert.isTrue(schema.writeOnly)
     assert.isTrue(schema.deprecated)
@@ -83,6 +86,7 @@ test.group('DomainProperty.createSchema()', () => {
       multiple: undefined,
       required: undefined,
       index: undefined,
+      search: undefined,
       primary: undefined,
       readOnly: undefined,
       writeOnly: undefined,
@@ -100,6 +104,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.multiple)
     assert.isUndefined(schema.required)
     assert.isUndefined(schema.index)
+    assert.isUndefined(schema.search)
     assert.isUndefined(schema.primary)
     assert.isUndefined(schema.readOnly)
     assert.isUndefined(schema.writeOnly)
@@ -119,6 +124,8 @@ test.group('DomainProperty.createSchema()', () => {
       // @ts-expect-error Testing null values
       index: null,
       // @ts-expect-error Testing null values
+      search: null,
+      // @ts-expect-error Testing null values
       primary: null,
       // @ts-expect-error Testing null values
       readOnly: null,
@@ -138,6 +145,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.multiple)
     assert.isUndefined(schema.required)
     assert.isUndefined(schema.index)
+    assert.isUndefined(schema.search)
     assert.isUndefined(schema.primary)
     assert.isUndefined(schema.readOnly)
     assert.isUndefined(schema.writeOnly)
@@ -165,6 +173,7 @@ test.group('DomainProperty.createSchema()', () => {
       multiple: false,
       primary: false,
       index: false,
+      search: false,
       readOnly: false,
       writeOnly: false,
       deprecated: false,
@@ -173,6 +182,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isFalse(schema.multiple)
     assert.isFalse(schema.primary)
     assert.isFalse(schema.index)
+    assert.isFalse(schema.search)
     assert.isFalse(schema.readOnly)
     assert.isFalse(schema.writeOnly)
     assert.isFalse(schema.deprecated)
@@ -238,6 +248,7 @@ test.group('DomainProperty.constructor()', () => {
     assert.isUndefined(property.multiple)
     assert.isUndefined(property.required)
     assert.isUndefined(property.index)
+    assert.isUndefined(property.search)
     assert.isUndefined(property.primary)
     assert.isUndefined(property.readOnly)
     assert.isUndefined(property.writeOnly)
@@ -260,6 +271,7 @@ test.group('DomainProperty.constructor()', () => {
       multiple: true,
       primary: true,
       index: true,
+      search: true,
       readOnly: true,
       writeOnly: true,
       deprecated: true,
@@ -278,6 +290,7 @@ test.group('DomainProperty.constructor()', () => {
     assert.isTrue(property.multiple)
     assert.isTrue(property.primary)
     assert.isTrue(property.index)
+    assert.isTrue(property.search)
     assert.isTrue(property.readOnly)
     assert.isTrue(property.writeOnly)
     assert.isTrue(property.deprecated)
@@ -400,6 +413,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isUndefined(json.multiple)
     assert.isUndefined(json.required)
     assert.isUndefined(json.index)
+    assert.isUndefined(json.search)
     assert.isUndefined(json.primary)
     assert.isUndefined(json.readOnly)
     assert.isUndefined(json.writeOnly)
@@ -420,6 +434,7 @@ test.group('DomainProperty.toJSON()', () => {
       multiple: true,
       primary: true,
       index: true,
+      search: true,
       readOnly: true,
       writeOnly: true,
       deprecated: true,
@@ -439,6 +454,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isTrue(json.multiple)
     assert.isTrue(json.primary)
     assert.isTrue(json.index)
+    assert.isTrue(json.search)
     assert.isTrue(json.readOnly)
     assert.isTrue(json.writeOnly)
     assert.isTrue(json.deprecated)
@@ -470,6 +486,7 @@ test.group('DomainProperty.toJSON()', () => {
       required: undefined,
       multiple: undefined,
       index: undefined,
+      search: undefined,
       primary: undefined,
       readOnly: undefined,
       writeOnly: undefined,
@@ -484,6 +501,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isUndefined(json.required)
     assert.isUndefined(json.multiple)
     assert.isUndefined(json.index)
+    assert.isUndefined(json.search)
     assert.isUndefined(json.primary)
     assert.isUndefined(json.readOnly)
     assert.isUndefined(json.writeOnly)
@@ -1296,7 +1314,6 @@ test.group('DomainProperty.toExample()', () => {
 
     // Mock the toApiShape method to return a shape without range
     const originalToApiShape = property.toApiShape
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     property.toApiShape = () => ({ range: undefined }) as any
 
     const result = property.toExample('application/json')
@@ -1545,6 +1562,7 @@ test.group('DomainProperty.duplicate()', () => {
       required: true,
       multiple: true,
       index: true,
+      search: true,
       readOnly: true,
       writeOnly: false,
       deprecated: true,
@@ -1562,6 +1580,7 @@ test.group('DomainProperty.duplicate()', () => {
     assert.equal(duplicate.required, true)
     assert.equal(duplicate.multiple, true)
     assert.equal(duplicate.index, true)
+    assert.equal(duplicate.search, true)
     assert.equal(duplicate.readOnly, true)
     assert.equal(duplicate.writeOnly, false)
     assert.equal(duplicate.deprecated, true)

package/tests/unit/modeling/exposed_entity.spec.ts

@@ -231,6 +231,77 @@ test.group('ExposedEntity', () => {
     assert.equal(ex.accessRule![0].type, 'allowPublic')
   }).tags(['@modeling', '@exposed-entity', '@immutability'])
 
+  test('initializes with paginationContract', ({ assert }) => {
+    const model = new ApiModel()
+    const contract = {
+      searchableFields: ['name'],
+      filterableFields: ['status'],
+      sortableFields: ['createdAt'],
+    }
+    const ex = new ExposedEntity(model, {
+      paginationContract: contract,
+    })
+
+    assert.deepEqual(ex.paginationContract, contract)
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('toJSON serializes paginationContract safely', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      paginationContract: { sortableFields: ['name'], filterableFields: [], searchableFields: [] },
+    })
+
+    const json = ex.toJSON()
+    assert.deepEqual(json.paginationContract, { sortableFields: ['name'], filterableFields: [], searchableFields: [] })
+
+    // Modify json to ensure immutability
+    json.paginationContract!.sortableFields.push('modified')
+    assert.lengthOf(ex.paginationContract!.sortableFields, 1)
+  }).tags(['@modeling', '@exposed-entity', '@serialization', '@immutability'])
+
+  test('constructor deep copies paginationContract (immutability)', ({ assert }) => {
+    const model = new ApiModel()
+    const contract = {
+      searchableFields: ['name'],
+      filterableFields: [],
+      sortableFields: [],
+    }
+    const ex = new ExposedEntity(model, {
+      paginationContract: contract,
+    })
+
+    contract.searchableFields.push('age')
+    assert.lengthOf(ex.paginationContract!.searchableFields, 1)
+  }).tags(['@modeling', '@exposed-entity', '@immutability'])
+
+  test('notifies change when paginationContract changes', async ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {})
+    let notified = false
+    ex.addEventListener('change', () => {
+      notified = true
+    })
+
+    ex.paginationContract = { sortableFields: [], filterableFields: [], searchableFields: [] }
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@exposed-entity', '@observed'])
+
+  test('notifies change when paginationContract property mutates', async ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      paginationContract: { sortableFields: [], filterableFields: [], searchableFields: [] },
+    })
+    let notified = false
+    ex.addEventListener('change', () => {
+      notified = true
+    })
+
+    ex.paginationContract!.sortableFields.push('name')
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@exposed-entity', '@observed'])
+
   test('getAllRules() aggregates rules from entity, parent, and API', ({ assert }) => {
     const model = new ApiModel()
     model.accessRule = [new AccessRule({ type: 'allowPublic' })]