@api-client/core 0.18.58 → 0.18.60

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'])
 })

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

@@ -0,0 +1,182 @@
+import { test } from '@japa/runner'
+import {
+  ApiModel,
+  CreateAction,
+  DataDomain,
+  DeleteAction,
+  DomainEntity,
+  ListAction,
+  ReadAction,
+  SearchAction,
+  UpdateAction,
+} from '../../../src/modeling/index.js'
+import { ExposedEntityKind } from '../../../src/models/kinds.js'
+import { nanoid } from '../../../src/nanoid.js'
+
+test.group('ExposedEntity::actions', (group) => {
+  let domain: DataDomain
+  let entity: DomainEntity
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    const m1 = domain.addModel()
+    entity = m1.addEntity()
+    domain.info.version = '1.0.0'
+  })
+
+  test('restores a list acton', ({ assert }) => {
+    const action = new ListAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'list', 'Action kind should be list')
+    assert.instanceOf(restoredAction, ListAction, 'Action should be an instance of ListAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+
+  test('restores a create acton', ({ assert }) => {
+    const action = new CreateAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'create', 'Action kind should be create')
+    assert.instanceOf(restoredAction, CreateAction, 'Action should be an instance of CreateAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+
+  test('restores a read acton', ({ assert }) => {
+    const action = new ReadAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'read', 'Action kind should be read')
+    assert.instanceOf(restoredAction, ReadAction, 'Action should be an instance of ReadAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+
+  test('restores a update acton', ({ assert }) => {
+    const action = new UpdateAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'update', 'Action kind should be update')
+    assert.instanceOf(restoredAction, UpdateAction, 'Action should be an instance of UpdateAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+
+  test('restores a delete acton', ({ assert }) => {
+    const action = new DeleteAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'delete', 'Action kind should be delete')
+    assert.instanceOf(restoredAction, DeleteAction, 'Action should be an instance of DeleteAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+
+  test('restores a search acton', ({ assert }) => {
+    const action = new SearchAction()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const restoredAction = model.exposes[0].actions[0]
+    assert.ok(restoredAction, 'Action should be restored')
+    assert.equal(restoredAction.kind, 'search', 'Action kind should be search')
+    assert.instanceOf(restoredAction, SearchAction, 'Action should be an instance of SearchAction')
+  }).tags(['@modeling', '@action', '@restoring'])
+})

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

@@ -4,14 +4,14 @@ import { AllowAuthenticatedAccessRule } from '../../../../src/modeling/rules/All
 test.group('AllowAuthenticatedAccessRule', () => {
   test('initializes with correct type', ({ assert }) => {
     const rule = new AllowAuthenticatedAccessRule()
-    assert.equal(rule.type, 'authenticated')
+    assert.equal(rule.type, 'allowAuthenticated')
   }).tags(['@modeling', '@rule', '@allow-authenticated'])
 
   test('toJSON returns valid schema', ({ assert }) => {
     const rule = new AllowAuthenticatedAccessRule()
     const json = rule.toJSON()
 
-    assert.equal(json.type, 'authenticated')
+    assert.equal(json.type, 'allowAuthenticated')
   }).tags(['@modeling', '@rule', '@allow-authenticated', '@serialization'])
 
   test('notifies change', async ({ assert }) => {

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

@@ -4,14 +4,14 @@ import { AllowPublicAccessRule } from '../../../../src/modeling/rules/AllowPubli
 test.group('AllowPublicAccessRule', () => {
   test('initializes with correct type', ({ assert }) => {
     const rule = new AllowPublicAccessRule()
-    assert.equal(rule.type, 'public')
+    assert.equal(rule.type, 'allowPublic')
   }).tags(['@modeling', '@rule', '@allow-public'])
 
   test('toJSON returns valid schema', ({ assert }) => {
     const rule = new AllowPublicAccessRule()
     const json = rule.toJSON()
 
-    assert.equal(json.type, 'public')
+    assert.equal(json.type, 'allowPublic')
   }).tags(['@modeling', '@rule', '@allow-public', '@serialization'])
 
   test('notifies change', async ({ assert }) => {

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

@@ -4,14 +4,14 @@ import { MatchResourceOwnerAccessRule } from '../../../../src/modeling/rules/Mat
 test.group('MatchResourceOwnerAccessRule', () => {
   test('initializes with default values', ({ assert }) => {
     const rule = new MatchResourceOwnerAccessRule()
-    assert.equal(rule.type, 'resourceOwner')
+    assert.equal(rule.type, 'matchResourceOwner')
     assert.equal(rule.property, '')
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
   test('initializes with provided values', ({ assert }) => {
     const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
 
-    assert.equal(rule.type, 'resourceOwner')
+    assert.equal(rule.type, 'matchResourceOwner')
     assert.equal(rule.property, 'creatorId')
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
@@ -19,7 +19,7 @@ test.group('MatchResourceOwnerAccessRule', () => {
     const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
     const json = rule.toJSON()
 
-    assert.equal(json.type, 'resourceOwner')
+    assert.equal(json.type, 'matchResourceOwner')
     assert.equal(json.property, 'creatorId')
   }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
 

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

@@ -0,0 +1,121 @@
+import { test } from '@japa/runner'
+import { ApiModel, DataDomain, DomainEntity, ListAction } from '../../../../src/modeling/index.js'
+import {
+  AllowAuthenticatedAccessRule,
+  AllowPublicAccessRule,
+  MatchEmailDomainAccessRule,
+  MatchResourceOwnerAccessRule,
+  MatchUserPropertyAccessRule,
+  MatchUserRoleAccessRule,
+} from '../../../../src/modeling/index.js'
+import { nanoid } from '../../../../src/nanoid.js'
+import { ExposedEntityKind } from '../../../../src/models/kinds.js'
+
+test.group('restoring actions', (group) => {
+  let domain: DataDomain
+  let entity: DomainEntity
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    const m1 = domain.addModel()
+    entity = m1.addEntity()
+    domain.info.version = '1.0.0'
+  })
+
+  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 model = new ApiModel(
+      {
+        accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
+      },
+      domain
+    )
+
+    assert.lengthOf(model.accessRule, 6)
+    assert.instanceOf(model.accessRule[0], AllowAuthenticatedAccessRule)
+    assert.instanceOf(model.accessRule[1], AllowPublicAccessRule)
+    assert.instanceOf(model.accessRule[2], MatchEmailDomainAccessRule)
+    assert.instanceOf(model.accessRule[3], MatchResourceOwnerAccessRule)
+    assert.instanceOf(model.accessRule[4], MatchUserPropertyAccessRule)
+    assert.instanceOf(model.accessRule[5], MatchUserRoleAccessRule)
+  }).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 model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [],
+            accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
+          },
+        ],
+      },
+      domain
+    )
+
+    const ex = model.exposes[0]!
+    assert.lengthOf(ex.accessRule!, 6)
+    assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
+    assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)
+    assert.instanceOf(ex.accessRule![2], MatchEmailDomainAccessRule)
+    assert.instanceOf(ex.accessRule![3], MatchResourceOwnerAccessRule)
+    assert.instanceOf(ex.accessRule![4], MatchUserPropertyAccessRule)
+    assert.instanceOf(ex.accessRule![5], MatchUserRoleAccessRule)
+  }).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 action = new ListAction({
+      accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
+    }).toJSON()
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            hasCollection: true,
+            collectionPath: '/things',
+            resourcePath: '/things/{id}',
+            isRoot: true,
+            actions: [action],
+          },
+        ],
+      },
+      domain
+    )
+
+    const ex = model.exposes[0]!.actions[0]!
+    assert.lengthOf(ex.accessRule!, 6)
+    assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
+    assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)
+    assert.instanceOf(ex.accessRule![2], MatchEmailDomainAccessRule)
+    assert.instanceOf(ex.accessRule![3], MatchResourceOwnerAccessRule)
+    assert.instanceOf(ex.accessRule![4], MatchUserPropertyAccessRule)
+    assert.instanceOf(ex.accessRule![5], MatchUserRoleAccessRule)
+  }).tags(['@modeling', '@rule', '@restoring'])
+})