@api-client/core 0.19.21 → 0.19.23

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('DeleteAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     assert.equal(action.kind, 'delete')
     assert.equal(action.strategy, 'soft')
     assert.equal(action.retentionPeriod, 30)
@@ -11,7 +12,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action'])
 
   test('initializes with provided values', ({ assert }) => {
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       strategy: 'hard',
       retentionPeriod: 0,
       accessRule: [{ type: 'allowPublic' }],
@@ -27,7 +28,7 @@ test.group('DeleteAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
 
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       accessRule: rules,
     })
 
@@ -40,7 +41,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       strategy: 'hard',
       retentionPeriod: 0,
     })
@@ -53,7 +54,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@serialization'])
 
   test('notifies change when strategy changes', async ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
@@ -65,7 +66,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@observed'])
 
   test('notifies change when retentionPeriod changes', async ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('ListAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new ListAction({} as any)
+    const action = new ListAction(mockExposedEntity())
     assert.equal(action.kind, 'list')
     assert.isUndefined(action.cacheTtl)
     assert.isEmpty(action.accessRule) // Inherited from Action
@@ -12,7 +13,7 @@ test.group('ListAction', () => {
   test('initializes with provided values', ({ assert }) => {
     const cacheTtl = 100
 
-    const action = new ListAction({} as any, {
+    const action = new ListAction(mockExposedEntity(), {
       cacheTtl,
     })
 
@@ -20,7 +21,7 @@ test.group('ListAction', () => {
   }).tags(['@modeling', '@action', '@list-action'])
 
   test('toJSON returns safe copy', ({ assert }) => {
-    const action = new ListAction({} as any, {
+    const action = new ListAction(mockExposedEntity(), {
       cacheTtl: 100,
     })
 
@@ -33,7 +34,7 @@ test.group('ListAction', () => {
   }).tags(['@modeling', '@action', '@list-action', '@immutability'])
 
   test('notifies change when cacheTtl changes', async ({ assert }) => {
-    const action = new ListAction({} as any)
+    const action = new ListAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
 import { AccessRule } from '../../../../src/modeling/rules/index.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('ReadAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     assert.equal(action.kind, 'read')
     assert.isEmpty(action.accessRule) // Inherited from Action
   }).tags(['@modeling', '@action', '@read-action'])
 
   test('initializes with inherited values', ({ assert }) => {
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -22,7 +23,7 @@ test.group('ReadAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
 
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: rules,
     })
 
@@ -35,7 +36,7 @@ test.group('ReadAction', () => {
   }).tags(['@modeling', '@action', '@read-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -51,26 +52,26 @@ test.group('ReadAction', () => {
   }).tags(['@modeling', '@action', '@read-action', '@serialization'])
 
   test('notifies change when inherited property changes', async ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
     // Modify inherited property
-    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
+    action.accessRule = [new AccessRule(mockExposedEntity(), { type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])
 
   test('notifies change when accessRule value change', async ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
-    action.accessRule.push(new AccessRule({ type: 'allowPublic' }))
+    action.accessRule.push(new AccessRule(mockExposedEntity(), { type: 'allowPublic' }))
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('SearchAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new SearchAction({} as any)
+    const action = new SearchAction(mockExposedEntity())
     assert.equal(action.kind, 'search')
     assert.isUndefined(action.maxAstDepth)
     assert.isEmpty(action.accessRule)
@@ -11,7 +12,7 @@ test.group('SearchAction', () => {
 
   test('initializes with provided values', ({ assert }) => {
     const maxAstDepth = 10
-    const action = new SearchAction({} as any, {
+    const action = new SearchAction(mockExposedEntity(), {
       maxAstDepth,
     })
 
@@ -20,7 +21,7 @@ test.group('SearchAction', () => {
   }).tags(['@modeling', '@action', '@search-action'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new SearchAction({} as any, {
+    const action = new SearchAction(mockExposedEntity(), {
       maxAstDepth: 10,
     })
 
@@ -34,7 +35,7 @@ test.group('SearchAction', () => {
   }).tags(['@modeling', '@action', '@search-action', '@serialization', '@immutability'])
 
   test('notifies change when maxAstDepth changes', async ({ assert }) => {
-    const action = new SearchAction({} as any)
+    const action = new SearchAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { UpdateAction } from '../../../../src/modeling/actions/UpdateAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('UpdateAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new UpdateAction({} as any)
+    const action = new UpdateAction(mockExposedEntity())
     assert.equal(action.kind, 'update')
     assert.deepEqual(action.allowedMethods, ['PATCH'])
     assert.isEmpty(action.accessRule)
@@ -11,7 +12,7 @@ test.group('UpdateAction', () => {
 
   test('initializes with provided values', ({ assert }) => {
     const methods: ('PUT' | 'PATCH')[] = ['PUT', 'PATCH']
-    const action = new UpdateAction({} as any, {
+    const action = new UpdateAction(mockExposedEntity(), {
       allowedMethods: methods,
     })
 
@@ -22,7 +23,7 @@ test.group('UpdateAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const methods: ('PUT' | 'PATCH')[] = ['PUT']
 
-    const action = new UpdateAction({} as any, {
+    const action = new UpdateAction(mockExposedEntity(), {
       allowedMethods: methods,
     })
 
@@ -33,7 +34,7 @@ test.group('UpdateAction', () => {
   }).tags(['@modeling', '@action', '@update-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new UpdateAction({} as any, {
+    const action = new UpdateAction(mockExposedEntity(), {
       allowedMethods: ['PUT'],
     })
 
@@ -48,7 +49,7 @@ test.group('UpdateAction', () => {
   }).tags(['@modeling', '@action', '@update-action', '@serialization', '@immutability'])
 
   test('notifies change when allowedMethods changes', async ({ assert }) => {
-    const action = new UpdateAction({} as any)
+    const action = new UpdateAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
@@ -60,7 +61,7 @@ test.group('UpdateAction', () => {
   }).tags(['@modeling', '@action', '@update-action', '@observed'])
 
   test('notifies change when allowedMethods value change', async ({ assert }) => {
-    const action = new UpdateAction({} as any)
+    const action = new UpdateAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

package/tests/unit/modeling/actions/helpers.ts

@@ -0,0 +1,7 @@
+import { type ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
+
+export function mockExposedEntity(): ExposedEntity {
+  return {
+    notifyChange: () => {},
+  } as unknown as ExposedEntity
+}

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

@@ -152,7 +152,7 @@ test.group('ApiModel.constructor()', () => {
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(model.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(model.session, { secret: 'secret', properties: ['email'] })
-    assert.deepEqual(model.accessRule, [new AllowPublicAccessRule()])
+    assert.deepEqual(model.accessRule, [new AllowPublicAccessRule(model)])
     assert.deepEqual(model.rateLimiting, new RateLimitingConfiguration())
     assert.equal(model.termsOfService, 'https://example.com/terms')
     assert.deepEqual(model.contact, { name: 'John Doe', email: 'john.doe@example.com' })
@@ -223,6 +223,8 @@ test.group('ApiModel.constructor()', () => {
     })
 
     Array.from(model.exposes.values())[0]!.actions[0]!.kind = 'write'
+    // there are two microtasks on the notification path.
+    await Promise.resolve()
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@api', '@observed'])

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

@@ -35,20 +35,6 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.deepEqual(exposedEntity.actions, [])
   }).tags(['@modeling', '@api'])
 
-  test('returns an existing entity if already exposed', ({ assert }) => {
-    const domain = new DataDomain()
-    domain.info.version = '1.0.0'
-    const dm = domain.addModel()
-    const e1 = dm.addEntity()
-    const model = new ApiModel()
-    model.attachDataDomain(domain)
-    const initialExposedEntity = model.exposeEntity({ key: e1.key })
-    const retrievedExposedEntity = model.exposeEntity({ key: e1.key })
-
-    assert.deepEqual(retrievedExposedEntity.toJSON(), initialExposedEntity.toJSON())
-    assert.equal(model.exposes.size, 1)
-  }).tags(['@modeling', '@api'])
-
   test('notifies change when a new entity is exposed', async ({ assert }) => {
     const domain = new DataDomain()
     domain.info.version = '1.0.0'
@@ -65,7 +51,7 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.isTrue(notified)
   }).tags(['@modeling', '@api'])
 
-  test('does not notify change if entity already exposed', async ({ assert }) => {
+  test('throws if entity already exposed', async ({ assert }) => {
     const domain = new DataDomain()
     domain.info.version = '1.0.0'
     const dm = domain.addModel()
@@ -78,9 +64,11 @@ test.group('ApiModel.exposeEntity()', () => {
     model.addEventListener('change', () => {
       notified = true
     })
-    model.exposeEntity({ key: e1.key }) // Second exposure
+    await assert.rejects(async () => {
+      model.exposeEntity({ key: e1.key }) // Second exposure
+    }, `Entity ${e1.key} is already exposed.`)
     await Promise.resolve() // Allow microtask to run
-    assert.isFalse(notified)
+    assert.isFalse(notified, 'should not notify change if entity already exposed')
   }).tags(['@modeling', '@api'])
 
   test('exposes nested entities through associations', ({ assert }) => {

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

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { ApiModel, ExposedEntity, type ExposedEntitySchema } from '../../../src/index.js'
+import { ApiModel, DataDomain, ExposedEntity, type ExposedEntitySchema } from '../../../src/index.js'
 import { AccessRule, RateLimitingConfiguration } from '../../../src/modeling/index.js'
 import { ExposedEntityKind } from '../../../src/models/kinds.js'
 
@@ -127,7 +127,9 @@ test.group('ExposedEntity', () => {
 
     const ex = Array.from(model.exposes.values())[0]
     ex.setCollectionPath('items')
-    await Promise.resolve() // allow ApiModel.notifyChange microtask to run
+    // there are two microtasks on the notification path.
+    await Promise.resolve()
+    await Promise.resolve()
     assert.isAtLeast(notified, 1)
   }).tags(['@modeling', '@exposed-entity', '@observed'])
 
@@ -154,6 +156,8 @@ test.group('ExposedEntity', () => {
 
     const ex = Array.from(model.exposes.values())[0]
     ex.setResourcePath('/products/{productId}')
+    // there are two microtasks on the notification path.
+    await Promise.resolve()
     await Promise.resolve()
     assert.isAtLeast(notified, 1)
   }).tags(['@modeling', '@exposed-entity', '@observed'])
@@ -304,7 +308,7 @@ test.group('ExposedEntity', () => {
 
   test('getAllRules() aggregates rules from entity, parent, and API', ({ assert }) => {
     const model = new ApiModel()
-    model.accessRule = [new AccessRule({ type: 'allowPublic' })]
+    model.accessRule = [new AccessRule(model, { type: 'allowPublic' })]
 
     const rootEx = new ExposedEntity(model, {
       key: 'root',
@@ -417,3 +421,146 @@ test.group('ExposedEntity', () => {
     assert.equal(childRules[3].rate, 20)
   }).tags(['@modeling', '@exposed-entity', '@rate-limiting'])
 })
+
+// ---------------------------------------------------------------------------
+// Helper: build a DataDomain + ApiModel with a single entity already attached.
+// Returns the domain, api model, and the entity key so tests can add properties
+// and then call createPaginationContract() without repeating boilerplate.
+// ---------------------------------------------------------------------------
+function makeFixture() {
+  const domain = new DataDomain()
+  domain.info.version = '1.0.0'
+  const dm = domain.addModel()
+  const entity = domain.addEntity(dm.key)
+  const model = new ApiModel()
+  model.attachDataDomain(domain)
+  return { domain, model, entity }
+}
+
+test.group('ExposedEntity.createPaginationContract()', () => {
+  test('throws when no domain is attached to the API model', ({ assert }) => {
+    const model = new ApiModel() // no domain attached
+    const ex = new ExposedEntity(model, { entity: { key: 'some-entity' } })
+
+    assert.throws(() => ex.createPaginationContract(), 'Entity "some-entity" not found')
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('throws when the entity key does not exist in the domain', ({ assert }) => {
+    const { model } = makeFixture()
+    const ex = new ExposedEntity(model, { entity: { key: 'non-existent' } })
+
+    assert.throws(() => ex.createPaginationContract(), 'Entity "non-existent" not found')
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('creates a fresh paginationContract when one is not yet set', ({ assert }) => {
+    const { model, entity } = makeFixture()
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+
+    assert.isUndefined(ex.paginationContract)
+    ex.createPaginationContract()
+
+    assert.isDefined(ex.paginationContract)
+    assert.deepEqual(ex.paginationContract!.filterableFields, [])
+    assert.deepEqual(ex.paginationContract!.sortableFields, [])
+    assert.deepEqual(ex.paginationContract!.searchableFields, [])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('indexed props are added to filterableFields and sortableFields', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'status', index: true })
+    domain.addProperty(entity.key, { key: 'createdAt', index: true })
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.deepEqual(ex.paginationContract!.filterableFields, ['status', 'createdAt'])
+    assert.deepEqual(ex.paginationContract!.sortableFields, ['status', 'createdAt'])
+    assert.deepEqual(ex.paginationContract!.searchableFields, [])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('search props are added to searchableFields only', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'name', search: true })
+    domain.addProperty(entity.key, { key: 'description', search: true })
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.deepEqual(ex.paginationContract!.searchableFields, ['name', 'description'])
+    assert.deepEqual(ex.paginationContract!.filterableFields, [])
+    assert.deepEqual(ex.paginationContract!.sortableFields, [])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('a prop with both index and search appears in all three lists', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'email', index: true, search: true })
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.include(ex.paginationContract!.filterableFields, 'email')
+    assert.include(ex.paginationContract!.sortableFields, 'email')
+    assert.include(ex.paginationContract!.searchableFields, 'email')
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('props without index or search are not added to any list', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'bio' }) // no index, no search
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.deepEqual(ex.paginationContract!.filterableFields, [])
+    assert.deepEqual(ex.paginationContract!.sortableFields, [])
+    assert.deepEqual(ex.paginationContract!.searchableFields, [])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('resets existing contract arrays before repopulating (destructive)', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'title', index: true, search: true })
+
+    const ex = new ExposedEntity(model, {
+      entity: { key: entity.key },
+      paginationContract: {
+        filterableFields: ['stale-filter'],
+        sortableFields: ['stale-sort'],
+        searchableFields: ['stale-search'],
+      },
+    })
+
+    // Sanity check: pre-existing stale values are present
+    assert.include(ex.paginationContract!.filterableFields, 'stale-filter')
+
+    ex.createPaginationContract()
+
+    // Stale values are gone; only the freshly scanned fields remain
+    assert.deepEqual(ex.paginationContract!.filterableFields, ['title'])
+    assert.deepEqual(ex.paginationContract!.sortableFields, ['title'])
+    assert.deepEqual(ex.paginationContract!.searchableFields, ['title'])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('entity with no properties produces empty contract lists', ({ assert }) => {
+    const { model, entity } = makeFixture() // entity has no props
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.deepEqual(ex.paginationContract!.filterableFields, [])
+    assert.deepEqual(ex.paginationContract!.sortableFields, [])
+    assert.deepEqual(ex.paginationContract!.searchableFields, [])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+
+  test('mixed props: only the flagged ones appear in the relevant lists', ({ assert }) => {
+    const { domain, model, entity } = makeFixture()
+    domain.addProperty(entity.key, { key: 'id', index: true }) // filterable + sortable
+    domain.addProperty(entity.key, { key: 'body', search: true }) // searchable
+    domain.addProperty(entity.key, { key: 'metadata' }) // neither
+
+    const ex = new ExposedEntity(model, { entity: { key: entity.key } })
+    ex.createPaginationContract()
+
+    assert.deepEqual(ex.paginationContract!.filterableFields, ['id'])
+    assert.deepEqual(ex.paginationContract!.sortableFields, ['id'])
+    assert.deepEqual(ex.paginationContract!.searchableFields, ['body'])
+  }).tags(['@modeling', '@exposed-entity', '@pagination'])
+})

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

@@ -33,9 +33,6 @@ test.group('ExposedEntity::actions', (group) => {
   test('restores a list acton', ({ assert }) => {
     const action: ListActionSchema = {
       kind: 'list',
-      pagination: { kind: '' },
-      sortableFields: [],
-      filterableFields: [],
     }
     const model = new ApiModel(
       {
@@ -177,7 +174,6 @@ test.group('ExposedEntity::actions', (group) => {
   test('restores a search acton', ({ assert }) => {
     const action: SearchActionSchema = {
       kind: 'search',
-      fields: [],
     }
     const model = new ApiModel(
       {

package/tests/unit/modeling/rules/AccessRule.spec.ts

@@ -1,26 +1,27 @@
 import { test } from '@japa/runner'
 import { AccessRule, type AccessRuleSchema } from '../../../../src/modeling/index.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('AccessRule', () => {
   test('initializes with default values', ({ assert }) => {
-    const rule = new AccessRule()
+    const rule = new AccessRule(mockExposedEntity())
     assert.equal(rule.type, '')
   }).tags(['@modeling', '@access-rule'])
 
   test('initializes with provided values', ({ assert }) => {
     const schema: AccessRuleSchema = { type: 'public' }
-    const rule = new AccessRule(schema)
+    const rule = new AccessRule(mockExposedEntity(), schema)
     assert.equal(rule.type, 'public')
   }).tags(['@modeling', '@access-rule'])
 
   test('serializes to JSON', ({ assert }) => {
-    const rule = new AccessRule({ type: 'authenticated' })
+    const rule = new AccessRule(mockExposedEntity(), { type: 'authenticated' })
     const json = rule.toJSON()
     assert.deepEqual(json, { type: 'authenticated' })
   }).tags(['@modeling', '@access-rule'])
 
   test('notifies change', async ({ assert }) => {
-    const rule = new AccessRule({ type: 'public' })
+    const rule = new AccessRule(mockExposedEntity(), { type: 'public' })
     let notified = false
     rule.addEventListener('change', () => {
       notified = true
@@ -31,7 +32,7 @@ test.group('AccessRule', () => {
   }).tags(['@modeling', '@access-rule'])
 
   test('toJSON returns safe copy (immutability)', ({ assert }) => {
-    const rule = new AccessRule({ type: 'public' })
+    const rule = new AccessRule(mockExposedEntity(), { type: 'public' })
     const json = rule.toJSON()
 
     // Modify JSON (simulate runtime mutation)

package/tests/unit/modeling/rules/AllowAuthenticated.spec.ts

@@ -1,21 +1,22 @@
 import { test } from '@japa/runner'
 import { AllowAuthenticatedAccessRule } from '../../../../src/modeling/rules/AllowAuthenticated.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('AllowAuthenticatedAccessRule', () => {
   test('initializes with correct type', ({ assert }) => {
-    const rule = new AllowAuthenticatedAccessRule()
+    const rule = new AllowAuthenticatedAccessRule(mockExposedEntity())
     assert.equal(rule.type, 'allowAuthenticated')
   }).tags(['@modeling', '@rule', '@allow-authenticated'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const rule = new AllowAuthenticatedAccessRule()
+    const rule = new AllowAuthenticatedAccessRule(mockExposedEntity())
     const json = rule.toJSON()
 
     assert.equal(json.type, 'allowAuthenticated')
   }).tags(['@modeling', '@rule', '@allow-authenticated', '@serialization'])
 
   test('notifies change', async ({ assert }) => {
-    const rule = new AllowAuthenticatedAccessRule()
+    const rule = new AllowAuthenticatedAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true

package/tests/unit/modeling/rules/AllowPublic.spec.ts

@@ -1,21 +1,22 @@
 import { test } from '@japa/runner'
 import { AllowPublicAccessRule } from '../../../../src/modeling/rules/AllowPublic.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('AllowPublicAccessRule', () => {
   test('initializes with correct type', ({ assert }) => {
-    const rule = new AllowPublicAccessRule()
+    const rule = new AllowPublicAccessRule(mockExposedEntity())
     assert.equal(rule.type, 'allowPublic')
   }).tags(['@modeling', '@rule', '@allow-public'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const rule = new AllowPublicAccessRule()
+    const rule = new AllowPublicAccessRule(mockExposedEntity())
     const json = rule.toJSON()
 
     assert.equal(json.type, 'allowPublic')
   }).tags(['@modeling', '@rule', '@allow-public', '@serialization'])
 
   test('notifies change', async ({ assert }) => {
-    const rule = new AllowPublicAccessRule()
+    const rule = new AllowPublicAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true