@api-client/core 0.19.22 → 0.19.24

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

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

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

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

@@ -10,6 +10,7 @@ import {
 } from '../../../../src/modeling/index.js'
 import { nanoid } from '../../../../src/nanoid.js'
 import { ExposedEntityKind } from '../../../../src/models/kinds.js'
+import { mockExposedEntity } from '../actions/helpers.js'
 
 test.group('restoring actions', (group) => {
   let domain: DataDomain
@@ -23,12 +24,12 @@ test.group('restoring actions', (group) => {
   })
 
   test('restores rules on the API model', ({ assert }) => {
-    const r1 = new AllowAuthenticatedAccessRule()
-    const r2 = new AllowPublicAccessRule()
-    const r3 = new MatchEmailDomainAccessRule()
-    const r4 = new MatchResourceOwnerAccessRule()
-    const r5 = new MatchUserPropertyAccessRule()
-    const r6 = new MatchUserRoleAccessRule()
+    const r1 = new AllowAuthenticatedAccessRule(mockExposedEntity())
+    const r2 = new AllowPublicAccessRule(mockExposedEntity())
+    const r3 = new MatchEmailDomainAccessRule(mockExposedEntity())
+    const r4 = new MatchResourceOwnerAccessRule(mockExposedEntity())
+    const r5 = new MatchUserPropertyAccessRule(mockExposedEntity())
+    const r6 = new MatchUserRoleAccessRule(mockExposedEntity())
     const model = new ApiModel(
       {
         accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
@@ -46,12 +47,12 @@ test.group('restoring actions', (group) => {
   }).tags(['@modeling', '@rule', '@restoring'])
 
   test('restores rules on the exposed entity', ({ assert }) => {
-    const r1 = new AllowAuthenticatedAccessRule()
-    const r2 = new AllowPublicAccessRule()
-    const r3 = new MatchEmailDomainAccessRule()
-    const r4 = new MatchResourceOwnerAccessRule()
-    const r5 = new MatchUserPropertyAccessRule()
-    const r6 = new MatchUserRoleAccessRule()
+    const r1 = new AllowAuthenticatedAccessRule(mockExposedEntity())
+    const r2 = new AllowPublicAccessRule(mockExposedEntity())
+    const r3 = new MatchEmailDomainAccessRule(mockExposedEntity())
+    const r4 = new MatchResourceOwnerAccessRule(mockExposedEntity())
+    const r5 = new MatchUserPropertyAccessRule(mockExposedEntity())
+    const r6 = new MatchUserRoleAccessRule(mockExposedEntity())
     const model = new ApiModel(
       {
         exposes: [
@@ -82,17 +83,14 @@ test.group('restoring actions', (group) => {
   }).tags(['@modeling', '@rule', '@restoring'])
 
   test('restores rules on the action', ({ assert }) => {
-    const r1 = new AllowAuthenticatedAccessRule()
-    const r2 = new AllowPublicAccessRule()
-    const r3 = new MatchEmailDomainAccessRule()
-    const r4 = new MatchResourceOwnerAccessRule()
-    const r5 = new MatchUserPropertyAccessRule()
-    const r6 = new MatchUserRoleAccessRule()
+    const r1 = new AllowAuthenticatedAccessRule(mockExposedEntity())
+    const r2 = new AllowPublicAccessRule(mockExposedEntity())
+    const r3 = new MatchEmailDomainAccessRule(mockExposedEntity())
+    const r4 = new MatchResourceOwnerAccessRule(mockExposedEntity())
+    const r5 = new MatchUserPropertyAccessRule(mockExposedEntity())
+    const r6 = new MatchUserRoleAccessRule(mockExposedEntity())
     const action: ListActionSchema = {
       kind: 'list',
-      pagination: { kind: '' },
-      sortableFields: [],
-      filterableFields: [],
       accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
     }
     const model = new ApiModel(

package/tests/unit/models/store/CustomDomain.spec.ts

@@ -0,0 +1,111 @@
+import { test } from '@japa/runner'
+import { CustomDomainModel } from '../../../../src/models/store/CustomDomain.js'
+import type { CustomDomainSchema } from '../../../../src/models/store/CustomDomain.js'
+
+test.group('CustomDomain model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = CustomDomainModel.createSchema()
+    assert.isString(result.id)
+    assert.equal(result.orgId, '')
+    assert.equal(result.domain, '')
+    assert.equal(result.dnsTarget, '')
+    assert.isFalse(result.dnsVerified)
+    assert.isUndefined(result.lastVerifiedAt)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = CustomDomainModel.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.domain, 'api.example.com')
+    assert.equal(result.dnsTarget, 'target.example.com')
+    assert.isTrue(result.dnsVerified)
+    assert.equal(result.lastVerifiedAt, 11111)
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const model = new CustomDomainModel()
+    assert.isString(model.id)
+    assert.equal(model.orgId, '')
+    assert.equal(model.domain, '')
+    assert.equal(model.dnsTarget, '')
+    assert.isFalse(model.dnsVerified)
+    assert.isUndefined(model.lastVerifiedAt)
+    assert.isNumber(model.createdAt)
+    assert.isNumber(model.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsVerified: true,
+    }
+    const model = new CustomDomainModel(init)
+    assert.equal(model.orgId, 'org-1')
+    assert.equal(model.domain, 'api.example.com')
+    assert.isTrue(model.dnsVerified)
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const model = new CustomDomainModel(init)
+    const result = model.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty fields', ({ assert }) => {
+    const model = new CustomDomainModel({
+      domain: '',
+      orgId: '',
+      dnsTarget: '',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 3)
+    assert.deepEqual(errors[0], { field: 'domain', message: 'Domain must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'orgId', message: 'Org ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], { field: 'dnsTarget', message: 'DNS target must not be empty', rule: 'notEmpty' })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const model = new CustomDomainModel({
+      domain: 'api.example.com',
+      orgId: 'org-1',
+      dnsTarget: 'target.example.com',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 0)
+  })
+})