@api-client/core 0.18.59 → 0.18.61

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,23 +4,43 @@ 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.property, '')
+    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' })
 
-    assert.equal(rule.type, 'resourceOwner')
+    assert.equal(rule.type, 'matchResourceOwner')
     assert.equal(rule.property, 'creatorId')
+    assert.equal(rule.target, 'property')
+  }).tags(['@modeling', '@rule', '@match-resource-owner'])
+
+  test('initializes with target user-entity', ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule({ target: 'user-entity' })
+
+    assert.equal(rule.type, 'matchResourceOwner')
+    assert.isUndefined(rule.property)
+    assert.equal(rule.target, 'user-entity')
   }).tags(['@modeling', '@rule', '@match-resource-owner'])
 
   test('toJSON returns valid schema', ({ assert }) => {
     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')
+    assert.equal(json.target, 'property')
+  }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
+
+  test('toJSON omits property when undefined', ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule({ target: 'user-entity' })
+    const json = rule.toJSON()
+
+    assert.equal(json.type, 'matchResourceOwner')
+    assert.isUndefined(json.property)
+    assert.equal(json.target, 'user-entity')
   }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
 
   test('notifies change when property changes', async ({ assert }) => {

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