@api-client/core 0.19.22 → 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

@@ -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',

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

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { MatchEmailDomainAccessRule } from '../../../../src/modeling/rules/MatchEmailDomain.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('MatchEmailDomainAccessRule', () => {
   test('initializes with default values', ({ assert }) => {
-    const rule = new MatchEmailDomainAccessRule()
+    const rule = new MatchEmailDomainAccessRule(mockExposedEntity())
     assert.equal(rule.type, 'matchEmailDomain')
     assert.deepEqual(rule.domains, [])
   }).tags(['@modeling', '@rule', '@match-email-domain'])
 
   test('initializes with provided values', ({ assert }) => {
     const domains = ['example.com', 'test.org']
-    const rule = new MatchEmailDomainAccessRule({ domains })
+    const rule = new MatchEmailDomainAccessRule(mockExposedEntity(), { domains })
 
     assert.equal(rule.type, 'matchEmailDomain')
     assert.deepEqual(rule.domains, domains)
@@ -18,7 +19,7 @@ test.group('MatchEmailDomainAccessRule', () => {
 
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const domains = ['example.com']
-    const rule = new MatchEmailDomainAccessRule({ domains })
+    const rule = new MatchEmailDomainAccessRule(mockExposedEntity(), { domains })
 
     // Modify original source
     domains.push('hacker.com')
@@ -27,7 +28,7 @@ test.group('MatchEmailDomainAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-email-domain', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const rule = new MatchEmailDomainAccessRule({ domains: ['example.com'] })
+    const rule = new MatchEmailDomainAccessRule(mockExposedEntity(), { domains: ['example.com'] })
     const json = rule.toJSON()
 
     // Modify JSON
@@ -39,7 +40,7 @@ test.group('MatchEmailDomainAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-email-domain', '@serialization', '@immutability'])
 
   test('notifies change when domains changes', async ({ assert }) => {
-    const rule = new MatchEmailDomainAccessRule()
+    const rule = new MatchEmailDomainAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { MatchResourceOwnerAccessRule } from '../../../../src/modeling/rules/MatchResourceOwner.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('MatchResourceOwnerAccessRule', () => {
   test('initializes with default values', ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule()
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity())
     assert.equal(rule.type, 'matchResourceOwner')
     assert.isUndefined(rule.property)
     assert.equal(rule.target, 'property')
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
   test('initializes with provided values', ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity(), { property: 'creatorId' })
 
     assert.equal(rule.type, 'matchResourceOwner')
     assert.equal(rule.property, 'creatorId')
@@ -18,7 +19,7 @@ test.group('MatchResourceOwnerAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
   test('initializes with target user-entity', ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule({ target: 'user-entity' })
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity(), { target: 'user-entity' })
 
     assert.equal(rule.type, 'matchResourceOwner')
     assert.isUndefined(rule.property)
@@ -26,7 +27,7 @@ test.group('MatchResourceOwnerAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity(), { property: 'creatorId' })
     const json = rule.toJSON()
 
     assert.equal(json.type, 'matchResourceOwner')
@@ -35,7 +36,7 @@ test.group('MatchResourceOwnerAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
 
   test('toJSON omits property when undefined', ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule({ target: 'user-entity' })
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity(), { target: 'user-entity' })
     const json = rule.toJSON()
 
     assert.equal(json.type, 'matchResourceOwner')
@@ -44,7 +45,7 @@ test.group('MatchResourceOwnerAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
 
   test('notifies change when property changes', async ({ assert }) => {
-    const rule = new MatchResourceOwnerAccessRule()
+    const rule = new MatchResourceOwnerAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { MatchUserPropertyAccessRule } from '../../../../src/modeling/rules/MatchUserProperty.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('MatchUserPropertyAccessRule', () => {
   test('initializes with default values', ({ assert }) => {
-    const rule = new MatchUserPropertyAccessRule()
+    const rule = new MatchUserPropertyAccessRule(mockExposedEntity())
     assert.equal(rule.type, 'matchUserProperty')
     assert.equal(rule.property, '')
     assert.equal(rule.value, '')
   }).tags(['@modeling', '@rule', '@match-user-property'])
 
   test('initializes with provided values', ({ assert }) => {
-    const rule = new MatchUserPropertyAccessRule({
+    const rule = new MatchUserPropertyAccessRule(mockExposedEntity(), {
       property: 'department',
       value: 'engineering',
     })
@@ -21,7 +22,7 @@ test.group('MatchUserPropertyAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-user-property'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const rule = new MatchUserPropertyAccessRule({
+    const rule = new MatchUserPropertyAccessRule(mockExposedEntity(), {
       property: 'department',
       value: 'engineering',
     })
@@ -33,7 +34,7 @@ test.group('MatchUserPropertyAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-user-property', '@serialization'])
 
   test('notifies change when property changes', async ({ assert }) => {
-    const rule = new MatchUserPropertyAccessRule()
+    const rule = new MatchUserPropertyAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true
@@ -45,7 +46,7 @@ test.group('MatchUserPropertyAccessRule', () => {
   }).tags(['@modeling', '@rule', '@match-user-property', '@observed'])
 
   test('notifies change when value changes', async ({ assert }) => {
-    const rule = new MatchUserPropertyAccessRule()
+    const rule = new MatchUserPropertyAccessRule(mockExposedEntity())
     let notified = false
     rule.addEventListener('change', () => {
       notified = true