@api-client/core 0.19.9 → 0.19.10

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

@@ -13,7 +13,7 @@ import {
 } from '../../../src/index.js'
 import { AllowPublicAccessRule } from '../../../src/modeling/rules/AllowPublic.js'
 import { RateLimitingConfiguration } from '../../../src/modeling/rules/RateLimitingConfiguration.js'
-import { Action } from '../../../src/modeling/index.js'
+import { ReadActionSchema } from '../../../src/modeling/index.js'
 
 test.group('ApiModel.createSchema()', () => {
   test('creates a schema with default values', ({ assert }) => {
@@ -97,7 +97,7 @@ test.group('ApiModel.constructor()', () => {
     assert.typeOf(model.key, 'string')
     assert.isNotEmpty(model.key)
     assert.equal(model.info.name, 'Unnamed API')
-    assert.deepEqual(model.exposes, [])
+    assert.equal(model.exposes.size, 0)
     assert.isUndefined(model.user)
     assert.isUndefined(model.authentication)
     assert.isUndefined(model.authorization)
@@ -140,8 +140,8 @@ test.group('ApiModel.constructor()', () => {
 
     assert.equal(model.key, 'test-api')
     assert.equal(model.info.name, 'Test API')
-    assert.lengthOf(model.exposes, 1, 'should have one exposed entity')
-    assert.equal(model.exposes[0].key, 'entity1', 'exposed entity should have correct key')
+    assert.equal(model.exposes.size, 1, 'should have one exposed entity')
+    assert.equal(Array.from(model.exposes.values())[0]!.entity.key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(model.user, { key: 'user-entity' })
     assert.deepEqual(model.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
@@ -216,7 +216,7 @@ test.group('ApiModel.constructor()', () => {
       notified = true
     })
 
-    model.exposes[0].actions[0].kind = 'write'
+    Array.from(model.exposes.values())[0]!.actions[0]!.kind = 'write'
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@api', '@observed'])
@@ -290,20 +290,22 @@ test.group('ApiModel.toJSON()', () => {
 
   test('actions are immutable', ({ assert }) => {
     const model = new ApiModel()
-    const action = new Action({ kind: 'read' })
+    const action: ReadActionSchema = {
+      kind: 'read',
+    }
     const entityKey = 'get-entity'
     const exposed: ExposedEntitySchema = {
       key: entityKey,
-      actions: [action.toJSON()],
+      actions: [action],
       hasCollection: true,
       kind: ExposedEntityKind,
       resourcePath: '/',
       entity: { key: entityKey },
     }
-    model.exposes.push(new ExposedEntity(model, exposed))
+    model.exposes.set(exposed.key, new ExposedEntity(model, exposed))
     const json = model.toJSON()
-    json.exposes[0].actions[0].kind = 'write'
-    assert.equal(model.exposes[0].actions[0].kind, 'read')
+    json.exposes![0]!.actions![0]!.kind = 'write'
+    assert.equal(Array.from(model.exposes.values())[0]!.actions[0]!.kind, 'read')
   }).tags(['@modeling', '@api', '@serialization'])
 })
 
@@ -319,15 +321,190 @@ test.group('ApiModel.getExposedEntity()', () => {
       resourcePath: '/',
       entity: { key: entityKey },
     }
-    model.exposes.push(new ExposedEntity(model, exposed))
+    model.exposes.set(exposed.key, new ExposedEntity(model, exposed))
 
-    const retrievedEntity = model.getExposedEntity({ key: entityKey })
+    const retrievedEntity = model.exposes.get(entityKey)
     assert.deepEqual(retrievedEntity?.toJSON(), exposed)
   }).tags(['@modeling', '@api'])
 
   test('returns undefined if entity is not exposed', ({ assert }) => {
     const model = new ApiModel()
-    const retrievedEntity = model.getExposedEntity({ key: 'non-exposed-entity' })
+    const retrievedEntity = model.exposes.get('non-exposed-entity')
     assert.isUndefined(retrievedEntity)
   }).tags(['@modeling', '@api'])
 })
+
+test.group('ApiModel.findResourcePathCollision()', () => {
+  test('returns the entity if resource path collides', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    const collision = model.findResourcePathCollision('/test')
+    assert.isDefined(collision)
+    assert.equal(collision?.key, 'ent1')
+  }).tags(['@modeling', '@api'])
+
+  test('returns undefined if no collision', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/other'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores the entity with the ignore key', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/test', 'ent1'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores non-root entities', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: false,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/test'))
+  }).tags(['@modeling', '@api'])
+})
+
+test.group('ApiModel.findCollectionPathCollision()', () => {
+  test('returns the entity if collection path collides', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    const collision = model.findCollectionPathCollision('/tests')
+    assert.isDefined(collision)
+    assert.equal(collision?.key, 'ent1')
+  }).tags(['@modeling', '@api'])
+
+  test('returns undefined if no collision', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/other'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores the entity with the ignore key', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests', 'ent1'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores non-root entities', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: false,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores entities without collections', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/tests',
+        collectionPath: '/tests',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests'))
+  }).tags(['@modeling', '@api'])
+})

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

@@ -1,5 +1,23 @@
 import { test } from '@japa/runner'
-import { ApiModel, DataDomain } from '../../../src/index.js'
+import { ApiModel, DataDomain, type ExposedEntity } from '../../../src/index.js'
+
+function findRootExposedEntity(model: ApiModel, entityKey: string) {
+  for (const e of model.exposes.values()) {
+    if (e.isRoot && e.entity.key === entityKey) {
+      return e
+    }
+  }
+  return undefined
+}
+
+function findNonRootExposedEntity(model: ApiModel, entityKey: string) {
+  for (const e of model.exposes.values()) {
+    if (!e.isRoot && e.entity.key === entityKey) {
+      return e
+    }
+  }
+  return undefined
+}
 
 test.group('ApiModel.exposeEntity()', () => {
   test('exposes a new entity', ({ assert }) => {
@@ -28,7 +46,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const retrievedExposedEntity = model.exposeEntity({ key: e1.key })
 
     assert.deepEqual(retrievedExposedEntity.toJSON(), initialExposedEntity.toJSON())
-    assert.lengthOf(model.exposes, 1)
+    assert.equal(model.exposes.size, 1)
   }).tags(['@modeling', '@api'])
 
   test('notifies change when a new entity is exposed', async ({ assert }) => {
@@ -77,7 +95,7 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     const exposedA = model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Find nested exposure for B
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
     assert.isDefined(nestedB)
     assert.deepEqual(nestedB?.parent?.key, exposedA.key)
     assert.strictEqual(nestedB?.collectionPath, '/entitybs')
@@ -96,15 +114,21 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 4 })
 
-    assert.lengthOf(model.exposes, 2, 'has only 2 exposures')
+    assert.equal(model.exposes.size, 2, 'has only 2 exposures')
     // Should expose A (root), B (nested under A), but not infinitely nest
-    const exposedA = model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const exposedA = findRootExposedEntity(model, eA.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
     // There should be only one nested exposure for B under A
     assert.isDefined(exposedA)
     assert.isDefined(nestedB)
     // There should NOT be a nested exposure for A under B
-    const circularA = model.exposes.find((e) => !e.isRoot && e.entity.key === eA.key && e.parent?.key === nestedB?.key)
+    let circularA: ExposedEntity | undefined
+    for (const e of model.exposes.values()) {
+      if (!e.isRoot && e.entity.key === eA.key && e.parent?.key === nestedB?.key) {
+        circularA = e
+        break
+      }
+    }
     assert.isUndefined(circularA)
   })
 
@@ -119,8 +143,8 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Should only expose A as root, not as nested
-    const exposedA = model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)
-    const nestedA = model.exposes.find((e) => !e.isRoot && e.entity.key === eA.key)
+    const exposedA = findRootExposedEntity(model, eA.key)
+    const nestedA = findNonRootExposedEntity(model, eA.key)
     assert.isDefined(exposedA)
     assert.isUndefined(nestedA)
   })
@@ -137,11 +161,11 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
-    assert.deepEqual(nestedB?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
+    assert.deepEqual(nestedB?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
     assert.deepEqual(nestedC?.parent?.key, nestedB?.key)
   })
 
@@ -157,12 +181,12 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
-    assert.deepEqual(nestedB?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
-    assert.deepEqual(nestedC?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
+    assert.deepEqual(nestedB?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
+    assert.deepEqual(nestedC?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
   })
 
   test('respects maxDepth option (A -> B -> C -> D, maxDepth=2)', ({ assert }) => {
@@ -179,9 +203,9 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 2 })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
-    const nestedD = model.exposes.find((e) => !e.isRoot && e.entity.key === eD.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
+    const nestedD = findNonRootExposedEntity(model, eD.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
     assert.isUndefined(nestedD)

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

@@ -10,10 +10,10 @@ test.group('ApiModel.removeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     const exposure = model.exposeEntity({ key: e1.key })
-    assert.lengthOf(model.exposes, 1)
+    assert.equal(model.exposes.size, 1)
 
     model.removeExposedEntity(exposure.key)
-    assert.lengthOf(model.exposes, 0)
+    assert.equal(model.exposes.size, 0)
   }).tags(['@modeling', '@api'])
 
   test('removes an entity and its nested children', ({ assert }) => {
@@ -28,13 +28,13 @@ test.group('ApiModel.removeEntity()', () => {
     model.attachDataDomain(domain)
     const rootExposure = model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Ensure nested exposure for B was created
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const nestedB = Array.from(model.exposes.values()).find((e) => !e.isRoot && e.entity.key === eB.key)
     assert.isDefined(nestedB)
-    assert.isAbove(model.exposes.length, 1)
+    assert.isAbove(model.exposes.size, 1)
 
     // Remove root exposure for A and expect children to be removed as well
     model.removeExposedEntity(rootExposure.key)
-    assert.lengthOf(model.exposes, 0)
+    assert.equal(model.exposes.size, 0)
   }).tags(['@modeling', '@api'])
 
   test('throws error if entity does not exist', ({ assert }) => {
@@ -50,7 +50,7 @@ test.group('ApiModel.removeEntity()', () => {
       () => model.removeExposedEntity('non-existing-key'),
       'Exposed entity with key "non-existing-key" not found.'
     )
-    assert.lengthOf(model.exposes, 1, 'exposes count should remain unchanged')
+    assert.equal(model.exposes.size, 1, 'exposes count should remain unchanged')
   }).tags(['@modeling', '@api'])
 
   test('notifies change when an entity is removed', async ({ assert }) => {

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

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { ApiModel, ExposedEntity, type ExposedEntitySchema } from '../../../src/index.js'
+import { AccessRule, RateLimitingConfiguration } from '../../../src/modeling/index.js'
 import { ExposedEntityKind } from '../../../src/models/kinds.js'
 
 test.group('ExposedEntity', () => {
@@ -84,7 +85,11 @@ test.group('ExposedEntity', () => {
     const childEx = new ExposedEntity(model, childSchema)
     const grandEx = new ExposedEntity(model, grandSchema)
     // attach to model as instances
-    model.exposes = [rootEx, childEx, grandEx]
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+      [grandEx.key, grandEx],
+    ])
 
     // root
     assert.equal(rootEx.getAbsoluteCollectionPath(), '/users')
@@ -120,7 +125,7 @@ test.group('ExposedEntity', () => {
       notified += 1
     })
 
-    const ex = model.exposes[0]
+    const ex = Array.from(model.exposes.values())[0]
     ex.setCollectionPath('items')
     await Promise.resolve() // allow ApiModel.notifyChange microtask to run
     assert.isAtLeast(notified, 1)
@@ -147,7 +152,7 @@ test.group('ExposedEntity', () => {
       notified += 1
     })
 
-    const ex = model.exposes[0]
+    const ex = Array.from(model.exposes.values())[0]
     ex.setResourcePath('/products/{productId}')
     await Promise.resolve()
     assert.isAtLeast(notified, 1)
@@ -225,4 +230,119 @@ test.group('ExposedEntity', () => {
     assert.lengthOf(ex.accessRule!, 1)
     assert.equal(ex.accessRule![0].type, 'allowPublic')
   }).tags(['@modeling', '@exposed-entity', '@immutability'])
+
+  test('getAllRules() aggregates rules from entity, parent, and API', ({ assert }) => {
+    const model = new ApiModel()
+    model.accessRule = [new AccessRule({ type: 'allowPublic' })]
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      accessRule: [{ type: 'matchResourceOwner' }],
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      accessRule: [{ type: 'allowAuthenticated' }],
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childRules = childEx.getAllRules()
+    assert.lengthOf(childRules, 3)
+    assert.equal(childRules[0].type, 'allowPublic')
+    assert.equal(childRules[1].type, 'allowAuthenticated')
+    assert.equal(childRules[2].type, 'matchResourceOwner')
+
+    const rootRules = rootEx.getAllRules()
+    assert.lengthOf(rootRules, 2)
+    assert.equal(rootRules[0].type, 'allowPublic')
+    assert.equal(rootRules[1].type, 'matchResourceOwner')
+  }).tags(['@modeling', '@exposed-entity', '@rules'])
+
+  test('getAllRateLimiters() aggregates rate limiters from entity, parent, and API', ({ assert }) => {
+    const model = new ApiModel()
+    model.rateLimiting = new RateLimitingConfiguration({ rules: [{ rate: 10, interval: 'second' }] })
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      rateLimiting: { rules: [{ rate: 20, interval: 'minute' }] },
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      rateLimiting: { rules: [{ rate: 30, interval: 'hour' }] },
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childLimiters = childEx.getAllRateLimiters()
+    assert.lengthOf(childLimiters, 3)
+    assert.equal(childLimiters[0].rules[0].rate, 10)
+    assert.equal(childLimiters[1].rules[0].rate, 30)
+    assert.equal(childLimiters[2].rules[0].rate, 20)
+
+    const rootLimiters = rootEx.getAllRateLimiters()
+    assert.lengthOf(rootLimiters, 2)
+    assert.equal(rootLimiters[0].rules[0].rate, 10)
+    assert.equal(rootLimiters[1].rules[0].rate, 20)
+  }).tags(['@modeling', '@exposed-entity', '@rate-limiting'])
+
+  test('getAllRateLimiterRules() aggregates rate limiter rules flattened', ({ assert }) => {
+    const model = new ApiModel()
+    model.rateLimiting = new RateLimitingConfiguration({
+      rules: [
+        { rate: 10, interval: 'second' },
+        { rate: 15, interval: 'minute' },
+      ],
+    })
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      rateLimiting: { rules: [{ rate: 20, interval: 'hour' }] },
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      rateLimiting: { rules: [{ rate: 30, interval: 'day' }] },
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childRules = childEx.getAllRateLimiterRules()
+    assert.lengthOf(childRules, 4)
+    assert.equal(childRules[0].rate, 10)
+    assert.equal(childRules[1].rate, 15)
+    assert.equal(childRules[2].rate, 30)
+    assert.equal(childRules[3].rate, 20)
+  }).tags(['@modeling', '@exposed-entity', '@rate-limiting'])
 })