@api-client/core 0.18.31 → 0.18.32

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

@@ -5,9 +5,11 @@ import {
   DataDomain,
   type RolesBasedAccessControl,
   type ApiModelSchema,
-  type ExposedEntity,
+  type ExposedEntitySchema,
   type ApiContact,
   type ApiLicense,
+  ExposedEntityKind,
+  ExposedEntity,
 } from '../../../src/index.js'
 
 test.group('ApiModel.createSchema()', () => {
@@ -34,7 +36,16 @@ test.group('ApiModel.createSchema()', () => {
     const input: Partial<ApiModelSchema> = {
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          hasCollection: true,
+          kind: ExposedEntityKind,
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -51,7 +62,8 @@ test.group('ApiModel.createSchema()', () => {
     assert.equal(schema.kind, ApiModelKind)
     assert.equal(schema.key, 'test-api')
     assert.deepInclude(schema.info, { name: 'Test API', description: 'A test API' })
-    assert.deepEqual(schema.exposes, [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(schema.exposes, 1, 'should have one exposed entity')
+    assert.equal(schema.exposes[0].key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(schema.user, { key: 'user-entity' })
     assert.deepEqual(schema.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(schema.authentication, { strategy: 'UsernamePassword' })
@@ -100,7 +112,16 @@ test.group('ApiModel.constructor()', () => {
       kind: ApiModelKind,
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+          hasCollection: true,
+          kind: ExposedEntityKind,
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -116,7 +137,8 @@ test.group('ApiModel.constructor()', () => {
 
     assert.equal(model.key, 'test-api')
     assert.equal(model.info.name, 'Test API')
-    assert.deepEqual(model.exposes, [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(model.exposes, 1, 'should have one exposed entity')
+    assert.equal(model.exposes[0].key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(model.user, { key: 'user-entity' })
     assert.deepEqual(model.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
@@ -179,7 +201,16 @@ test.group('ApiModel.toJSON()', () => {
       kind: ApiModelKind,
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+          hasCollection: true,
+          kind: ExposedEntityKind,
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -196,7 +227,8 @@ test.group('ApiModel.toJSON()', () => {
 
     assert.equal(json.key, 'test-api')
     assert.deepInclude(json.info, { name: 'Test API', description: 'A test API' })
-    assert.deepEqual(json.exposes, [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(json.exposes, 1, 'should have one exposed entity')
+    assert.equal(json.exposes[0].key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(json.user, { key: 'user-entity' })
     assert.deepEqual(json.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
@@ -214,11 +246,18 @@ test.group('ApiModel.getExposedEntity()', () => {
   test('returns an existing exposed entity', ({ assert }) => {
     const model = new ApiModel()
     const entityKey = 'get-entity'
-    const exposed: ExposedEntity = { key: entityKey, actions: [], path: '', entity: { key: entityKey } }
-    model.exposes.push(exposed)
+    const exposed: ExposedEntitySchema = {
+      key: entityKey,
+      actions: [],
+      hasCollection: true,
+      kind: ExposedEntityKind,
+      relativeResourcePath: '/',
+      entity: { key: entityKey },
+    }
+    model.exposes.push(new ExposedEntity(model, exposed))
 
     const retrievedEntity = model.getExposedEntity({ key: entityKey })
-    assert.deepEqual(retrievedEntity, exposed)
+    assert.deepEqual(retrievedEntity?.toJSON(), exposed)
   }).tags(['@modeling', '@api'])
 
   test('returns undefined if entity is not exposed', ({ assert }) => {

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

@@ -82,7 +82,6 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.isDefined(nestedB)
     assert.deepEqual(nestedB?.parent?.key, exposedA.key)
     assert.strictEqual(nestedB?.relativeCollectionPath, '/entitybs')
-    assert.strictEqual(nestedB?.absoluteCollectionPath, '/as/{id}/entitybs')
   })
 
   test('does not infinitely expose circular associations', ({ assert }) => {

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

@@ -0,0 +1,100 @@
+import { test } from '@japa/runner'
+import { ApiModel, ExposedEntity } from '../../../src/index.js'
+
+test.group('ExposedEntity', () => {
+  test('setRelativeCollectionPath normalizes and preserves resource param', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: true,
+      relativeCollectionPath: '/items',
+      relativeResourcePath: '/items/{customId}',
+    })
+
+    ex.setRelativeCollectionPath('products')
+
+    assert.equal(ex.relativeCollectionPath, '/products')
+    assert.equal(ex.relativeResourcePath, '/products/{customId}')
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('setRelativeResourcePath with collection allows only parameter name change', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: true,
+      relativeCollectionPath: '/products',
+      relativeResourcePath: '/products/{id}',
+    })
+
+    // valid: same collection segment, different param name
+    ex.setRelativeResourcePath('/products/{productId}')
+    assert.equal(ex.relativeResourcePath, '/products/{productId}')
+
+    // invalid: different first segment
+    assert.throws(() => ex.setRelativeResourcePath('/wrong/{id}'))
+
+    // invalid: second segment not a parameter
+    assert.throws(() => ex.setRelativeResourcePath('/products/notParam'))
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('setRelativeResourcePath without collection must have exactly two segments', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: false,
+      relativeResourcePath: '/profile/{id}',
+    })
+
+    ex.setRelativeResourcePath('settings/secret')
+    assert.equal(ex.relativeResourcePath, '/settings/secret')
+
+    assert.throws(() => ex.setRelativeResourcePath('onlyone'))
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('computes absolute resource and collection paths along parent chain', ({ assert }) => {
+    const model = new ApiModel()
+
+    // Build exposure schemas
+    const rootSchema = {
+      key: 'root',
+      entity: { key: 'user' },
+      hasCollection: true,
+      relativeCollectionPath: '/users',
+      relativeResourcePath: '/users/{userId}',
+      isRoot: true,
+      actions: [],
+    }
+    const childSchema = {
+      key: 'child',
+      entity: { key: 'post' },
+      hasCollection: true,
+      relativeCollectionPath: '/posts',
+      relativeResourcePath: '/posts/{postId}',
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      actions: [],
+    }
+    const grandSchema = {
+      key: 'grand',
+      entity: { key: 'details' },
+      hasCollection: false,
+      relativeResourcePath: '/details',
+      parent: { key: 'child', association: { key: 'toDetails' } },
+      actions: [],
+    }
+    // Instantiate instances bound to the model
+    const rootEx = new ExposedEntity(model, rootSchema)
+    const childEx = new ExposedEntity(model, childSchema)
+    const grandEx = new ExposedEntity(model, grandSchema)
+    // attach to model as instances
+    model.exposes = [rootEx, childEx, grandEx]
+
+    // root
+    assert.equal(rootEx.getAbsoluteCollectionPath(), '/users')
+    assert.equal(rootEx.getAbsoluteResourcePath(), '/users/{userId}')
+
+    // child
+    assert.equal(childEx.getAbsoluteCollectionPath(), '/users/{userId}/posts')
+    assert.equal(childEx.getAbsoluteResourcePath(), '/users/{userId}/posts/{postId}')
+
+    // grand (no collection)
+    assert.isUndefined(grandEx.getAbsoluteCollectionPath())
+    assert.equal(grandEx.getAbsoluteResourcePath(), '/users/{userId}/posts/{postId}/details')
+  }).tags(['@modeling', '@exposed-entity'])
+})