@api-client/core 0.18.31 → 0.18.33

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,
+          resourcePath: '/',
+          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: [],
+          resourcePath: '/',
+          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: [],
+          resourcePath: '/',
+          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,
+      resourcePath: '/',
+      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

@@ -15,7 +15,6 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.typeOf(exposedEntity.key, 'string')
     assert.deepEqual(exposedEntity.entity, { key: e1.key })
     assert.deepEqual(exposedEntity.actions, [])
-    assert.includeDeepMembers(model.exposes, [exposedEntity])
   }).tags(['@modeling', '@api'])
 
   test('returns an existing entity if already exposed', ({ assert }) => {
@@ -28,7 +27,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const initialExposedEntity = model.exposeEntity({ key: e1.key })
     const retrievedExposedEntity = model.exposeEntity({ key: e1.key })
 
-    assert.strictEqual(retrievedExposedEntity, initialExposedEntity)
+    assert.deepEqual(retrievedExposedEntity.toJSON(), initialExposedEntity.toJSON())
     assert.lengthOf(model.exposes, 1)
   }).tags(['@modeling', '@api'])
 
@@ -81,8 +80,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
     assert.isDefined(nestedB)
     assert.deepEqual(nestedB?.parent?.key, exposedA.key)
-    assert.strictEqual(nestedB?.relativeCollectionPath, '/entitybs')
-    assert.strictEqual(nestedB?.absoluteCollectionPath, '/as/{id}/entitybs')
+    assert.strictEqual(nestedB?.collectionPath, '/entitybs')
   })
 
   test('does not infinitely expose circular associations', ({ assert }) => {

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

@@ -45,10 +45,9 @@ test.group('ApiModel.removeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: e1.key })
-    const initialExposes = [...model.exposes]
 
     model.removeEntity({ key: 'non-existing-entity' })
-    assert.deepEqual(model.exposes, initialExposes)
+    assert.lengthOf(model.exposes, 1, 'exposes count should remain unchanged')
   }).tags(['@modeling', '@api'])
 
   test('notifies change when an entity is removed', async ({ assert }) => {

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

@@ -0,0 +1,155 @@
+import { test } from '@japa/runner'
+import { ApiModel, ExposedEntity, type ExposedEntitySchema } from '../../../src/index.js'
+import { ExposedEntityKind } from '../../../src/models/kinds.js'
+
+test.group('ExposedEntity', () => {
+  test('setCollectionPath normalizes and preserves resource param', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: true,
+      collectionPath: '/items',
+      resourcePath: '/items/{customId}',
+    })
+
+    ex.setCollectionPath('products')
+
+    assert.equal(ex.collectionPath, '/products')
+    assert.equal(ex.resourcePath, '/products/{customId}')
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('setResourcePath with collection allows only parameter name change', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: true,
+      collectionPath: '/products',
+      resourcePath: '/products/{id}',
+    })
+
+    // valid: same collection segment, different param name
+    ex.setResourcePath('/products/{productId}')
+    assert.equal(ex.resourcePath, '/products/{productId}')
+
+    // invalid: different first segment
+    assert.throws(() => ex.setResourcePath('/wrong/{id}'))
+
+    // invalid: second segment not a parameter
+    assert.throws(() => ex.setResourcePath('/products/notParam'))
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('setResourcePath without collection must have exactly two segments', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      hasCollection: false,
+      resourcePath: '/profile/{id}',
+    })
+
+    ex.setResourcePath('settings/secret')
+    assert.equal(ex.resourcePath, '/settings/secret')
+
+    assert.throws(() => ex.setResourcePath('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: Partial<ExposedEntitySchema> = {
+      key: 'root',
+      entity: { key: 'user' },
+      hasCollection: true,
+      collectionPath: '/users',
+      resourcePath: '/users/{userId}',
+      isRoot: true,
+      actions: [],
+    }
+    const childSchema: Partial<ExposedEntitySchema> = {
+      key: 'child',
+      entity: { key: 'post' },
+      hasCollection: true,
+      collectionPath: '/posts',
+      resourcePath: '/posts/{postId}',
+      parent: { key: 'root', association: { key: 'toPosts' } },
+      actions: [],
+    }
+    const grandSchema: Partial<ExposedEntitySchema> = {
+      key: 'grand',
+      entity: { key: 'details' },
+      hasCollection: false,
+      resourcePath: '/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'])
+
+  test('ApiModel notifies when nested ExposedEntity collection path changes', async ({ assert }) => {
+    const model = new ApiModel({
+      exposes: [
+        {
+          kind: ExposedEntityKind,
+          key: 'e1',
+          entity: { key: 'e1' },
+          hasCollection: true,
+          collectionPath: '/things',
+          resourcePath: '/things/{id}',
+          isRoot: true,
+          actions: [],
+        },
+      ],
+    })
+
+    let notified = 0
+    model.addEventListener('change', () => {
+      notified += 1
+    })
+
+    const ex = model.exposes[0]
+    ex.setCollectionPath('items')
+    await Promise.resolve() // allow ApiModel.notifyChange microtask to run
+    assert.isAtLeast(notified, 1)
+  }).tags(['@modeling', '@exposed-entity', '@observed'])
+
+  test('ApiModel notifies when nested ExposedEntity resource path changes', async ({ assert }) => {
+    const model = new ApiModel({
+      exposes: [
+        {
+          kind: ExposedEntityKind,
+          key: 'e1',
+          entity: { key: 'e1' },
+          hasCollection: true,
+          collectionPath: '/products',
+          resourcePath: '/products/{id}',
+          isRoot: true,
+          actions: [],
+        },
+      ],
+    })
+
+    let notified = 0
+    model.addEventListener('change', () => {
+      notified += 1
+    })
+
+    const ex = model.exposes[0]
+    ex.setResourcePath('/products/{productId}')
+    await Promise.resolve()
+    assert.isAtLeast(notified, 1)
+  }).tags(['@modeling', '@exposed-entity', '@observed'])
+})