@api-client/core 0.18.59 → 0.18.61

package/data/models/example-generator-api.json

@@ -42810,6 +42810,9 @@
 "@id": "#219"
 },
 {
+"@id": "#219"
+},
+{
 "@id": "#210"
 },
 {
@@ -42817,9 +42820,6 @@
 },
 {
 "@id": "#216"
-},
-{
-"@id": "#219"
 }
 ],
 "doc:root": false,
@@ -44232,7 +44232,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44253,7 +44253,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
+"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44274,7 +44274,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
+"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44295,7 +44295,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -45121,17 +45121,17 @@
 {
 "@id": "#215/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#215",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#218/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#218",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#221/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#221",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#338/source-map/synthesized-field/element_1",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.18.59",
+  "version": "0.18.61",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/ApiModel.ts

@@ -19,6 +19,7 @@ import { createDomainKey } from './helpers/keying.js'
 import { ExposedEntity } from './ExposedEntity.js'
 import { AccessRule, AccessRuleSchema } from './rules/AccessRule.js'
 import { RateLimitingConfiguration, RateLimitingConfigurationSchema } from './rules/RateLimitingConfiguration.js'
+import { restoreAccessRule } from './rules/index.js'
 
 /**
  * Contact information for the exposed API.
@@ -310,7 +311,7 @@ export class ApiModel extends DependentModel {
       this.exposes = []
     }
     if (Array.isArray(init.accessRule)) {
-      this.accessRule = init.accessRule.map((rule) => new AccessRule(rule))
+      this.accessRule = init.accessRule.map((rule) => restoreAccessRule(rule))
     } else {
       this.accessRule = []
     }

package/src/modeling/ExposedEntity.ts

@@ -2,9 +2,11 @@ import { observed } from '../decorators/observed.js'
 import { ExposedEntityKind } from '../models/kinds.js'
 import { nanoid } from '../nanoid.js'
 import { Action } from './actions/Action.js'
+import { restoreAction } from './actions/index.js'
 import type { ApiModel } from './ApiModel.js'
 import { ensureLeadingSlash, joinPaths } from './helpers/endpointHelpers.js'
 import { AccessRule } from './rules/AccessRule.js'
+import { restoreAccessRule } from './rules/index.js'
 import { RateLimitingConfiguration } from './rules/RateLimitingConfiguration.js'
 import type { AssociationTarget, ExposeOptions, ExposeParentRef, ExposedEntitySchema } from './types.js'
 
@@ -182,8 +184,8 @@ export class ExposedEntity extends EventTarget {
     this.isRoot = init.isRoot
     this.parent = init.parent
     this.exposeOptions = init.exposeOptions
-    this.actions = init.actions ? init.actions.map((a) => new Action(a)) : []
-    this.accessRule = init.accessRule ? init.accessRule.map((ar) => new AccessRule(ar)) : []
+    this.actions = init.actions ? init.actions.map((a) => restoreAction(a)) : []
+    this.accessRule = init.accessRule ? init.accessRule.map((ar) => restoreAccessRule(ar)) : []
     this.rateLimiting = init.rateLimiting ? new RateLimitingConfiguration(init.rateLimiting) : undefined
     this.truncated = init.truncated
     this.#initializing = false

package/src/modeling/actions/Action.ts

@@ -1,6 +1,7 @@
 import { AccessRule, AccessRuleSchema } from '../rules/AccessRule.js'
 import { RateLimitingConfiguration, RateLimitingConfigurationSchema } from '../rules/RateLimitingConfiguration.js'
 import { observed } from '../../decorators/observed.js'
+import { restoreAccessRule } from '../rules/index.js'
 
 /**
  * A base interface for common properties across all actions.
@@ -41,7 +42,7 @@ export class Action extends EventTarget implements ActionSchema {
   constructor(state: Partial<ActionSchema> = {}) {
     super()
     this.kind = state.kind || ''
-    this.accessRule = state.accessRule ? state.accessRule.map((rule) => new AccessRule(rule)) : []
+    this.accessRule = state.accessRule ? state.accessRule.map((rule) => restoreAccessRule(rule)) : []
     this.rateLimiting = state.rateLimiting ? new RateLimitingConfiguration(state.rateLimiting) : undefined
   }
 

package/src/modeling/rules/AllowAuthenticated.ts

@@ -6,7 +6,7 @@ import { AccessRule, type AccessRuleSchema } from './AccessRule.js'
  * It is used for resources that should be accessible to all logged-in users.
  */
 export interface AllowAuthenticatedAccessRuleSchema extends AccessRuleSchema {
-  type: 'authenticated'
+  type: 'allowAuthenticated'
 }
 
 /**
@@ -15,10 +15,10 @@ export interface AllowAuthenticatedAccessRuleSchema extends AccessRuleSchema {
  * It is used for resources that should be accessible to all logged-in users.
  */
 export class AllowAuthenticatedAccessRule extends AccessRule implements AllowAuthenticatedAccessRuleSchema {
-  override readonly type: 'authenticated'
+  override readonly type: 'allowAuthenticated'
 
   constructor(state: Partial<AllowAuthenticatedAccessRuleSchema> = {}) {
     super(state)
-    this.type = 'authenticated'
+    this.type = 'allowAuthenticated'
   }
 }

package/src/modeling/rules/AllowPublic.ts

@@ -6,7 +6,7 @@ import { AccessRule, type AccessRuleSchema } from './AccessRule.js'
  * It is the most permissive rule and should be used with caution.
  */
 export interface AllowPublicAccessRuleSchema extends AccessRuleSchema {
-  type: 'public'
+  type: 'allowPublic'
 }
 
 /**
@@ -15,10 +15,10 @@ export interface AllowPublicAccessRuleSchema extends AccessRuleSchema {
  * It is the most permissive rule and should be used with caution.
  */
 export class AllowPublicAccessRule extends AccessRule implements AllowPublicAccessRuleSchema {
-  override readonly type: 'public'
+  override readonly type: 'allowPublic'
 
   constructor(state: Partial<AllowPublicAccessRuleSchema> = {}) {
     super(state)
-    this.type = 'public'
+    this.type = 'allowPublic'
   }
 }

package/src/modeling/rules/MatchResourceOwner.ts

@@ -7,15 +7,24 @@ import { observed } from '../../decorators/observed.js'
  * For example, a user can only access their own profile or documents.
  */
 export interface MatchResourceOwnerAccessRuleSchema extends AccessRuleSchema {
-  type: 'resourceOwner'
+  type: 'matchResourceOwner'
   /**
-   * The property on the resource that should match the authenticated user's ID.
-   * This is typically the ID of the user who owns the resource.
+   * The property on the resource that references the user's ID (the key in the semantically annotated `User` entity).
+   *
+   * When the current exposed entity has a property annotated with the "ResourceOwnerIdentifier" semantic,
+   * this property should be used. It directly references the user's key.
    *
    * The domain model should annotate this property with the "ResourceOwnerIdentifier" semantic
    * to indicate that it is used for ownership checks.
    */
-  property: string
+  property?: string
+
+  /**
+   * The target for the ownership check.
+   * - `property`: The check is performed against a specific property on the resource (default).
+   * - `user-entity`: The check is performed against the entity itself (used when the entity represents the user).
+   */
+  target?: 'property' | 'user-entity'
 }
 
 /**
@@ -24,20 +33,26 @@ export interface MatchResourceOwnerAccessRuleSchema extends AccessRuleSchema {
  * For example, a user can only access their own profile or documents.
  */
 export class MatchResourceOwnerAccessRule extends AccessRule implements MatchResourceOwnerAccessRuleSchema {
-  override readonly type: 'resourceOwner'
+  override readonly type: 'matchResourceOwner'
 
-  @observed() accessor property: string
+  @observed() accessor property: string | undefined
+  @observed() accessor target: 'property' | 'user-entity'
 
   constructor(state: Partial<MatchResourceOwnerAccessRuleSchema> = {}) {
     super(state)
-    this.type = 'resourceOwner'
-    this.property = state.property ?? ''
+    this.type = 'matchResourceOwner'
+    this.property = state.property
+    this.target = state.target ?? 'property'
   }
 
   override toJSON(): MatchResourceOwnerAccessRuleSchema {
-    return {
+    const json: MatchResourceOwnerAccessRuleSchema = {
       ...(super.toJSON() as MatchResourceOwnerAccessRuleSchema),
-      property: this.property,
+      target: this.target,
+    }
+    if (this.property) {
+      json.property = this.property
     }
+    return json
   }
 }

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

@@ -13,27 +13,27 @@ test.group('Action', () => {
   test('initializes with provided values', ({ assert }) => {
     const schema: ActionSchema = {
       kind: 'read',
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
     }
     const action = new Action(schema)
     assert.equal(action.kind, 'read')
     assert.lengthOf(action.accessRule, 1)
     assert.instanceOf(action.accessRule[0], AccessRule)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
     assert.instanceOf(action.rateLimiting, RateLimitingConfiguration)
   }).tags(['@modeling', '@action'])
 
   test('serializes to JSON', ({ assert }) => {
     const action = new Action({
       kind: 'write',
-      accessRule: [{ type: 'admin' }],
+      accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
     })
     const json = action.toJSON()
 
     assert.equal(json.kind, 'write')
-    assert.deepEqual(json.accessRule, [{ type: 'admin' }])
+    assert.deepEqual(json.accessRule, [{ type: 'allowPublic' }])
     assert.deepEqual(json.rateLimiting, { rules: [] })
   }).tags(['@modeling', '@action'])
 
@@ -58,7 +58,7 @@ test.group('Action', () => {
       notified = true
     })
 
-    action.accessRule = [new AccessRule({ type: 'public' })]
+    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@observed'])
@@ -76,21 +76,21 @@ test.group('Action', () => {
   }).tags(['@modeling', '@action', '@observed'])
 
   test('constructor copies accessRule array (immutability)', ({ assert }) => {
-    const rules = [{ type: 'public' }]
+    const rules = [{ type: 'allowPublic' }]
     const action = new Action({ kind: 'read', accessRule: rules })
 
     // Modify original array
-    rules.push({ type: 'admin' })
+    rules.push({ type: 'other' })
     rules[0].type = 'changed'
 
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@immutability'])
 
   test('toJSON returns safe copy', ({ assert }) => {
     const action = new Action({
       kind: 'read',
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
     })
     const json = action.toJSON()
@@ -104,6 +104,6 @@ test.group('Action', () => {
 
     assert.equal(action.kind, 'read')
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@immutability'])
 })

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

@@ -11,32 +11,32 @@ test.group('CreateAction', () => {
 
   test('initializes with inherited values', ({ assert }) => {
     const action = new CreateAction({
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     assert.equal(action.kind, 'create')
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@create-action'])
 
   test('constructor copies arrays (immutability)', ({ assert }) => {
-    const rules = [{ type: 'public' }]
+    const rules = [{ type: 'allowPublic' }]
 
     const action = new CreateAction({
       accessRule: rules,
     })
 
     // Modify original source
-    rules.push({ type: 'admin' })
+    rules.push({ type: 'other' })
     rules[0].type = 'changed'
 
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@create-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
     const action = new CreateAction({
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     const json = action.toJSON()
@@ -44,7 +44,7 @@ test.group('CreateAction', () => {
     assert.equal(json.kind, 'create')
     if (json.accessRule) {
       assert.lengthOf(json.accessRule, 1)
-      assert.equal(json.accessRule[0].type, 'public')
+      assert.equal(json.accessRule[0].type, 'allowPublic')
     } else {
       assert.fail('accessRule should be present in JSON')
     }
@@ -58,7 +58,7 @@ test.group('CreateAction', () => {
     })
 
     // Modify inherited property
-    action.accessRule = [new AccessRule({ type: 'admin' })]
+    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@create-action', '@observed'])

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

@@ -14,29 +14,29 @@ test.group('DeleteAction', () => {
     const action = new DeleteAction({
       strategy: 'hard',
       retentionPeriod: 0,
-      accessRule: [{ type: 'admin' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     assert.equal(action.kind, 'delete')
     assert.equal(action.strategy, 'hard')
     assert.equal(action.retentionPeriod, 0)
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'admin')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@delete-action'])
 
   test('constructor copies arrays (immutability)', ({ assert }) => {
-    const rules = [{ type: 'public' }]
+    const rules = [{ type: 'allowPublic' }]
 
     const action = new DeleteAction({
       accessRule: rules,
     })
 
     // Modify original source
-    rules.push({ type: 'admin' })
+    rules.push({ type: 'other' })
     rules[0].type = 'changed'
 
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@delete-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {

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

@@ -11,32 +11,32 @@ test.group('ReadAction', () => {
 
   test('initializes with inherited values', ({ assert }) => {
     const action = new ReadAction({
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     assert.equal(action.kind, 'read')
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@read-action'])
 
   test('constructor copies arrays (immutability)', ({ assert }) => {
-    const rules = [{ type: 'public' }]
+    const rules = [{ type: 'allowPublic' }]
 
     const action = new ReadAction({
       accessRule: rules,
     })
 
     // Modify original source
-    rules.push({ type: 'admin' })
+    rules.push({ type: 'other' })
     rules[0].type = 'changed'
 
     assert.lengthOf(action.accessRule, 1)
-    assert.equal(action.accessRule[0].type, 'public')
+    assert.equal(action.accessRule[0].type, 'allowPublic')
   }).tags(['@modeling', '@action', '@read-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
     const action = new ReadAction({
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     const json = action.toJSON()
@@ -44,7 +44,7 @@ test.group('ReadAction', () => {
     assert.equal(json.kind, 'read')
     if (json.accessRule) {
       assert.lengthOf(json.accessRule, 1)
-      assert.equal(json.accessRule[0].type, 'public')
+      assert.equal(json.accessRule[0].type, 'allowPublic')
     } else {
       assert.fail('accessRule should be present in JSON')
     }
@@ -58,7 +58,7 @@ test.group('ReadAction', () => {
     })
 
     // Modify inherited property
-    action.accessRule = [new AccessRule({ type: 'admin' })]
+    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])
@@ -70,7 +70,7 @@ test.group('ReadAction', () => {
       notified = true
     })
 
-    action.accessRule.push(new AccessRule({ type: 'admin' }))
+    action.accessRule.push(new AccessRule({ type: 'allowPublic' }))
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])

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

@@ -130,7 +130,7 @@ test.group('ApiModel.constructor()', () => {
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
       termsOfService: 'https://example.com/terms',
       contact: { name: 'John Doe', email: 'john.doe@example.com' },
@@ -263,7 +263,7 @@ test.group('ApiModel.toJSON()', () => {
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
-      accessRule: [{ type: 'public' }],
+      accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
       termsOfService: 'https://example.com/terms',
       contact: { name: 'John Doe', email: 'john.doe@example.com' },
@@ -281,7 +281,7 @@ test.group('ApiModel.toJSON()', () => {
     assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(json.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(json.session, { secret: 'secret', properties: ['email'] })
-    assert.deepEqual(json.accessRule, [{ type: 'public' }])
+    assert.deepEqual(json.accessRule, [{ type: 'allowPublic' }])
     assert.deepEqual(json.rateLimiting, { rules: [] })
     assert.equal(json.termsOfService, 'https://example.com/terms')
     assert.deepEqual(json.contact, { name: 'John Doe', email: 'john.doe@example.com' })

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

@@ -156,29 +156,29 @@ test.group('ExposedEntity', () => {
   test('restores actions and rules from schema', ({ assert }) => {
     const model = new ApiModel()
     const ex = new ExposedEntity(model, {
-      actions: [{ kind: 'read', accessRule: [{ type: 'public' }] }],
-      accessRule: [{ type: 'admin' }],
+      actions: [{ kind: 'read', accessRule: [{ type: 'allowPublic' }] }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     assert.lengthOf(ex.actions, 1)
     assert.equal(ex.actions[0].kind, 'read')
     assert.lengthOf(ex.actions[0].accessRule, 1)
-    assert.equal(ex.actions[0].accessRule[0].type, 'public')
+    assert.equal(ex.actions[0].accessRule[0].type, 'allowPublic')
 
     assert.lengthOf(ex.accessRule!, 1)
-    assert.equal(ex.accessRule![0].type, 'admin')
+    assert.equal(ex.accessRule![0].type, 'allowPublic')
   }).tags(['@modeling', '@exposed-entity'])
 
   test('serializes actions and rules', ({ assert }) => {
     const model = new ApiModel()
     const ex = new ExposedEntity(model, {
       actions: [{ kind: 'read' }],
-      accessRule: [{ type: 'admin' }],
+      accessRule: [{ type: 'allowPublic' }],
     })
 
     const json = ex.toJSON()
     assert.deepInclude(json.actions[0], { kind: 'read' })
-    assert.deepInclude(json.accessRule![0], { type: 'admin' })
+    assert.deepInclude(json.accessRule![0], { type: 'allowPublic' })
   }).tags(['@modeling', '@exposed-entity'])
 
   test('notifies change when action property changes', async ({ assert }) => {
@@ -212,7 +212,7 @@ test.group('ExposedEntity', () => {
 
   test('constructor copies accessRule array (immutability)', ({ assert }) => {
     const model = new ApiModel()
-    const rules = [{ type: 'public' }]
+    const rules = [{ type: 'allowPublic' }]
     const ex = new ExposedEntity(model, {
       actions: [],
       accessRule: rules,
@@ -223,6 +223,6 @@ test.group('ExposedEntity', () => {
     rules[0].type = 'changed'
 
     assert.lengthOf(ex.accessRule!, 1)
-    assert.equal(ex.accessRule![0].type, 'public')
+    assert.equal(ex.accessRule![0].type, 'allowPublic')
   }).tags(['@modeling', '@exposed-entity', '@immutability'])
 })