@api-client/core 0.19.9 → 0.19.11

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

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { ApiModel, ExposedEntity, type ExposedEntitySchema } from '../../../src/index.js'
+import { AccessRule, RateLimitingConfiguration } from '../../../src/modeling/index.js'
 import { ExposedEntityKind } from '../../../src/models/kinds.js'
 
 test.group('ExposedEntity', () => {
@@ -84,7 +85,11 @@ test.group('ExposedEntity', () => {
     const childEx = new ExposedEntity(model, childSchema)
     const grandEx = new ExposedEntity(model, grandSchema)
     // attach to model as instances
-    model.exposes = [rootEx, childEx, grandEx]
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+      [grandEx.key, grandEx],
+    ])
 
     // root
     assert.equal(rootEx.getAbsoluteCollectionPath(), '/users')
@@ -120,7 +125,7 @@ test.group('ExposedEntity', () => {
       notified += 1
     })
 
-    const ex = model.exposes[0]
+    const ex = Array.from(model.exposes.values())[0]
     ex.setCollectionPath('items')
     await Promise.resolve() // allow ApiModel.notifyChange microtask to run
     assert.isAtLeast(notified, 1)
@@ -147,7 +152,7 @@ test.group('ExposedEntity', () => {
       notified += 1
     })
 
-    const ex = model.exposes[0]
+    const ex = Array.from(model.exposes.values())[0]
     ex.setResourcePath('/products/{productId}')
     await Promise.resolve()
     assert.isAtLeast(notified, 1)
@@ -225,4 +230,119 @@ test.group('ExposedEntity', () => {
     assert.lengthOf(ex.accessRule!, 1)
     assert.equal(ex.accessRule![0].type, 'allowPublic')
   }).tags(['@modeling', '@exposed-entity', '@immutability'])
+
+  test('getAllRules() aggregates rules from entity, parent, and API', ({ assert }) => {
+    const model = new ApiModel()
+    model.accessRule = [new AccessRule({ type: 'allowPublic' })]
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      accessRule: [{ type: 'matchResourceOwner' }],
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      accessRule: [{ type: 'allowAuthenticated' }],
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childRules = childEx.getAllRules()
+    assert.lengthOf(childRules, 3)
+    assert.equal(childRules[0].type, 'allowPublic')
+    assert.equal(childRules[1].type, 'allowAuthenticated')
+    assert.equal(childRules[2].type, 'matchResourceOwner')
+
+    const rootRules = rootEx.getAllRules()
+    assert.lengthOf(rootRules, 2)
+    assert.equal(rootRules[0].type, 'allowPublic')
+    assert.equal(rootRules[1].type, 'matchResourceOwner')
+  }).tags(['@modeling', '@exposed-entity', '@rules'])
+
+  test('getAllRateLimiters() aggregates rate limiters from entity, parent, and API', ({ assert }) => {
+    const model = new ApiModel()
+    model.rateLimiting = new RateLimitingConfiguration({ rules: [{ rate: 10, interval: 'second' }] })
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      rateLimiting: { rules: [{ rate: 20, interval: 'minute' }] },
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      rateLimiting: { rules: [{ rate: 30, interval: 'hour' }] },
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childLimiters = childEx.getAllRateLimiters()
+    assert.lengthOf(childLimiters, 3)
+    assert.equal(childLimiters[0].rules[0].rate, 10)
+    assert.equal(childLimiters[1].rules[0].rate, 30)
+    assert.equal(childLimiters[2].rules[0].rate, 20)
+
+    const rootLimiters = rootEx.getAllRateLimiters()
+    assert.lengthOf(rootLimiters, 2)
+    assert.equal(rootLimiters[0].rules[0].rate, 10)
+    assert.equal(rootLimiters[1].rules[0].rate, 20)
+  }).tags(['@modeling', '@exposed-entity', '@rate-limiting'])
+
+  test('getAllRateLimiterRules() aggregates rate limiter rules flattened', ({ assert }) => {
+    const model = new ApiModel()
+    model.rateLimiting = new RateLimitingConfiguration({
+      rules: [
+        { rate: 10, interval: 'second' },
+        { rate: 15, interval: 'minute' },
+      ],
+    })
+
+    const rootEx = new ExposedEntity(model, {
+      key: 'root',
+      entity: { key: 'user' },
+      isRoot: true,
+      actions: [],
+      rateLimiting: { rules: [{ rate: 20, interval: 'hour' }] },
+    })
+
+    const childEx = new ExposedEntity(model, {
+      key: 'child',
+      entity: { key: 'post' },
+      isRoot: false,
+      actions: [],
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      rateLimiting: { rules: [{ rate: 30, interval: 'day' }] },
+    })
+
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    const childRules = childEx.getAllRateLimiterRules()
+    assert.lengthOf(childRules, 4)
+    assert.equal(childRules[0].rate, 10)
+    assert.equal(childRules[1].rate, 15)
+    assert.equal(childRules[2].rate, 30)
+    assert.equal(childRules[3].rate, 20)
+  }).tags(['@modeling', '@exposed-entity', '@rate-limiting'])
 })

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

@@ -2,13 +2,19 @@ import { test } from '@japa/runner'
 import {
   ApiModel,
   CreateAction,
+  type CreateActionSchema,
   DataDomain,
   DeleteAction,
+  type DeleteActionSchema,
   DomainEntity,
   ListAction,
+  type ListActionSchema,
   ReadAction,
+  type ReadActionSchema,
   SearchAction,
+  type SearchActionSchema,
   UpdateAction,
+  type UpdateActionSchema,
 } from '../../../src/modeling/index.js'
 import { ExposedEntityKind } from '../../../src/models/kinds.js'
 import { nanoid } from '../../../src/nanoid.js'
@@ -25,7 +31,12 @@ test.group('ExposedEntity::actions', (group) => {
   })
 
   test('restores a list acton', ({ assert }) => {
-    const action = new ListAction()
+    const action: ListActionSchema = {
+      kind: 'list',
+      pagination: { kind: '' },
+      sortableFields: [],
+      filterableFields: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -37,21 +48,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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 action: CreateActionSchema = {
+      kind: 'create',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -63,21 +76,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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 action: ReadActionSchema = {
+      kind: 'read',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -89,21 +104,24 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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 action: UpdateActionSchema = {
+      kind: 'update',
+      allowedMethods: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -115,21 +133,23 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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 action: DeleteActionSchema = {
+      kind: 'delete',
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -141,21 +161,24 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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 action: SearchActionSchema = {
+      kind: 'search',
+      fields: [],
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -167,14 +190,14 @@ test.group('ExposedEntity::actions', (group) => {
             collectionPath: '/things',
             resourcePath: '/things/{id}',
             isRoot: true,
-            actions: [action.toJSON()],
+            actions: [action],
           },
         ],
       },
       domain
     )
 
-    const restoredAction = model.exposes[0].actions[0]
+    const restoredAction = Array.from(model.exposes.values())[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')

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

@@ -84,7 +84,7 @@ test.group('ExposedEntity Path Setter Validation', () => {
 
     // expose A -> B
     const rootExp = model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedExp = model.exposes.find((e) => !e.isRoot)
+    const nestedExp = Array.from(model.exposes.values()).find((e) => !e.isRoot)
 
     assert.isDefined(nestedExp)
     // Assuming root entity has collection path /as

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

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { ApiModel, DataDomain, DomainEntity, ListAction } from '../../../../src/modeling/index.js'
+import { ApiModel, DataDomain, DomainEntity, type ListActionSchema } from '../../../../src/modeling/index.js'
 import {
   AllowAuthenticatedAccessRule,
   AllowPublicAccessRule,
@@ -71,7 +71,7 @@ test.group('restoring actions', (group) => {
       domain
     )
 
-    const ex = model.exposes[0]!
+    const ex = Array.from(model.exposes.values())[0]!
     assert.lengthOf(ex.accessRule!, 6)
     assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
     assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)
@@ -88,9 +88,13 @@ test.group('restoring actions', (group) => {
     const r4 = new MatchResourceOwnerAccessRule()
     const r5 = new MatchUserPropertyAccessRule()
     const r6 = new MatchUserRoleAccessRule()
-    const action = new ListAction({
+    const action: ListActionSchema = {
+      kind: 'list',
+      pagination: { kind: '' },
+      sortableFields: [],
+      filterableFields: [],
       accessRule: [r1.toJSON(), r2.toJSON(), r3.toJSON(), r4.toJSON(), r5.toJSON(), r6.toJSON()],
-    }).toJSON()
+    }
     const model = new ApiModel(
       {
         exposes: [
@@ -109,7 +113,7 @@ test.group('restoring actions', (group) => {
       domain
     )
 
-    const ex = model.exposes[0]!.actions[0]!
+    const ex = Array.from(model.exposes.values())[0]!.actions[0]!
     assert.lengthOf(ex.accessRule!, 6)
     assert.instanceOf(ex.accessRule![0], AllowAuthenticatedAccessRule)
     assert.instanceOf(ex.accessRule![1], AllowPublicAccessRule)