@api-client/core 0.18.47 → 0.18.49

package/tests/unit/mocking/current/Permission.spec.ts

@@ -0,0 +1,285 @@
+import { test } from '@japa/runner'
+import { Permission } from '../../../../src/mocking/lib/Permission.js'
+import { Kind as PermissionKind } from '../../../../src/models/store/Permission.js'
+import type { IPermission } from '../../../../src/models/store/Permission.js'
+
+test.group('permission()', (group) => {
+  let permission: Permission
+
+  group.each.setup(() => {
+    permission = new Permission()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = permission.permission()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has the {property} property of a type {type}')
+    .with([
+      { property: 'kind', type: 'string' },
+      { property: 'key', type: 'string' },
+      { property: 'type', type: 'string' },
+      { property: 'granteeId', type: 'string' },
+      { property: 'itemId', type: 'string' },
+      { property: 'role', type: 'string' },
+      { property: 'addingUser', type: 'string' },
+      { property: 'depth', type: 'number' },
+      { property: 'sourceRule', type: 'string' },
+    ])
+    .run(({ assert }, { property, type }) => {
+      const result = permission.permission()
+      assert.typeOf(result[property as keyof IPermission], type)
+    })
+
+  test('has the correct kind', ({ assert }) => {
+    const result = permission.permission()
+    assert.equal(result.kind, PermissionKind)
+  })
+
+  test('type is one of the valid values', ({ assert }) => {
+    const result = permission.permission()
+    assert.include(['user', 'group', 'organization'], result.type)
+  })
+
+  test('role is one of the valid values', ({ assert }) => {
+    const result = permission.permission()
+    assert.include(['reader', 'commenter', 'writer', 'owner'], result.role)
+  })
+
+  test('sourceRule is one of the valid values', ({ assert }) => {
+    const result = permission.permission()
+    assert.include(['direct_user_grant', 'creator_default_owner', 'parent_owner_editor_rule'], result.sourceRule)
+  })
+
+  test('uses passed key', ({ assert }) => {
+    const result = permission.permission({ key: 'custom-key' })
+    assert.equal(result.key, 'custom-key')
+  })
+
+  test('uses passed type', ({ assert }) => {
+    const result = permission.permission({ type: 'group' })
+    assert.equal(result.type, 'group')
+  })
+
+  test('uses passed granteeId', ({ assert }) => {
+    const result = permission.permission({ granteeId: 'grantee-123' })
+    assert.equal(result.granteeId, 'grantee-123')
+  })
+
+  test('uses passed itemId', ({ assert }) => {
+    const result = permission.permission({ itemId: 'item-456' })
+    assert.equal(result.itemId, 'item-456')
+  })
+
+  test('uses passed role', ({ assert }) => {
+    const result = permission.permission({ role: 'writer' })
+    assert.equal(result.role, 'writer')
+  })
+
+  test('uses passed addingUser', ({ assert }) => {
+    const result = permission.permission({ addingUser: 'user-789' })
+    assert.equal(result.addingUser, 'user-789')
+  })
+
+  test('uses passed depth', ({ assert }) => {
+    const result = permission.permission({ depth: 2 })
+    assert.equal(result.depth, 2)
+  })
+
+  test('uses passed sourceRule', ({ assert }) => {
+    const result = permission.permission({ sourceRule: 'creator_default_owner' })
+    assert.equal(result.sourceRule, 'creator_default_owner')
+  })
+
+  test('generates displayName by default', ({ assert }) => {
+    const result = permission.permission()
+    assert.typeOf(result.displayName, 'string')
+  })
+
+  test('uses passed displayName', ({ assert }) => {
+    const result = permission.permission({ displayName: 'John Doe' })
+    assert.equal(result.displayName, 'John Doe')
+  })
+
+  test('can explicitly set displayName to undefined', ({ assert }) => {
+    const result = permission.permission({ displayName: undefined })
+    assert.isUndefined(result.displayName)
+  })
+
+  test('generates expirationTime for user type by default', ({ assert }) => {
+    const result = permission.permission({ type: 'user' })
+    assert.typeOf(result.expirationTime, 'number')
+  })
+
+  test('generates expirationTime for group type by default', ({ assert }) => {
+    const result = permission.permission({ type: 'group' })
+    assert.typeOf(result.expirationTime, 'number')
+  })
+
+  test('does not generate expirationTime for organization type', ({ assert }) => {
+    const result = permission.permission({ type: 'organization' })
+    assert.isUndefined(result.expirationTime)
+  })
+
+  test('uses passed expirationTime', ({ assert }) => {
+    const time = Date.now() + 86400000
+    const result = permission.permission({ expirationTime: time })
+    assert.equal(result.expirationTime, time)
+  })
+
+  test('can explicitly set expirationTime to undefined', ({ assert }) => {
+    const result = permission.permission({ type: 'user', expirationTime: undefined })
+    assert.isUndefined(result.expirationTime)
+  })
+})
+
+test.group('userPermission()', (group) => {
+  let permission: Permission
+
+  group.each.setup(() => {
+    permission = new Permission()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = permission.userPermission()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has type set to user', ({ assert }) => {
+    const result = permission.userPermission()
+    assert.equal(result.type, 'user')
+  })
+
+  test('has displayName', ({ assert }) => {
+    const result = permission.userPermission()
+    assert.typeOf(result.displayName, 'string')
+  })
+
+  test('has expirationTime', ({ assert }) => {
+    const result = permission.userPermission()
+    assert.typeOf(result.expirationTime, 'number')
+  })
+
+  test('uses passed init values', ({ assert }) => {
+    const result = permission.userPermission({ role: 'owner', itemId: 'item-123' })
+    assert.equal(result.type, 'user')
+    assert.equal(result.role, 'owner')
+    assert.equal(result.itemId, 'item-123')
+  })
+})
+
+test.group('groupPermission()', (group) => {
+  let permission: Permission
+
+  group.each.setup(() => {
+    permission = new Permission()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = permission.groupPermission()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has type set to group', ({ assert }) => {
+    const result = permission.groupPermission()
+    assert.equal(result.type, 'group')
+  })
+
+  test('has displayName', ({ assert }) => {
+    const result = permission.groupPermission()
+    assert.typeOf(result.displayName, 'string')
+  })
+
+  test('has expirationTime', ({ assert }) => {
+    const result = permission.groupPermission()
+    assert.typeOf(result.expirationTime, 'number')
+  })
+
+  test('uses passed init values', ({ assert }) => {
+    const result = permission.groupPermission({ role: 'commenter', granteeId: 'group-456' })
+    assert.equal(result.type, 'group')
+    assert.equal(result.role, 'commenter')
+    assert.equal(result.granteeId, 'group-456')
+  })
+})
+
+test.group('organizationPermission()', (group) => {
+  let permission: Permission
+
+  group.each.setup(() => {
+    permission = new Permission()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = permission.organizationPermission()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has type set to organization', ({ assert }) => {
+    const result = permission.organizationPermission()
+    assert.equal(result.type, 'organization')
+  })
+
+  test('has displayName', ({ assert }) => {
+    const result = permission.organizationPermission()
+    assert.typeOf(result.displayName, 'string')
+  })
+
+  test('does not have expirationTime', ({ assert }) => {
+    const result = permission.organizationPermission()
+    assert.isUndefined(result.expirationTime)
+  })
+
+  test('uses passed init values', ({ assert }) => {
+    const result = permission.organizationPermission({ role: 'reader', addingUser: 'admin-789' })
+    assert.equal(result.type, 'organization')
+    assert.equal(result.role, 'reader')
+    assert.equal(result.addingUser, 'admin-789')
+  })
+})
+
+test.group('permissions()', (group) => {
+  let permission: Permission
+
+  group.each.setup(() => {
+    permission = new Permission()
+  })
+
+  test('returns an array', ({ assert }) => {
+    const result = permission.permissions()
+    assert.isArray(result)
+  })
+
+  test('returns 25 items by default', ({ assert }) => {
+    const result = permission.permissions()
+    assert.lengthOf(result, 25)
+  })
+
+  test('returns specified number of items', ({ assert }) => {
+    const result = permission.permissions(10)
+    assert.lengthOf(result, 10)
+  })
+
+  test('all items have the correct kind', ({ assert }) => {
+    const result = permission.permissions(5)
+    result.forEach((item) => {
+      assert.equal(item.kind, PermissionKind)
+    })
+  })
+
+  test('uses passed init values for all items', ({ assert }) => {
+    const result = permission.permissions(5, { type: 'user', role: 'owner' })
+    result.forEach((item) => {
+      assert.equal(item.type, 'user')
+      assert.equal(item.role, 'owner')
+    })
+  })
+
+  test('generates unique keys', ({ assert }) => {
+    const result = permission.permissions(10)
+    const keys = result.map((item) => item.key)
+    const uniqueKeys = new Set(keys)
+    assert.equal(keys.length, uniqueKeys.size)
+  })
+})

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

@@ -163,6 +163,26 @@ test.group('ApiModel.constructor()', () => {
     assert.equal(model.domain!.key, 'my-domain')
   }).tags(['@modeling', '@api', '@creation'])
 
+  test('initializes domain dependency correctly when passed to constructor', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+
+    const model = new ApiModel({}, domain)
+
+    assert.isDefined(model.domain)
+    assert.equal(model.domain?.key, domain.key)
+    assert.lengthOf(model.dependencyList, 1)
+    assert.equal(model.dependencyList[0].key, domain.key)
+    assert.equal(model.dependencyList[0].version, '1.0.0')
+  }).tags(['@modeling', '@api', '@creation'])
+
+  test('throws if passed domain has no version', ({ assert }) => {
+    const domain = new DataDomain()
+    // No version set
+
+    assert.throws(() => new ApiModel({}, domain), /must have a version/)
+  }).tags(['@modeling', '@api', '@creation'])
+
   test('notifies change when info is modified', async ({ assert }) => {
     const model = new ApiModel()
     let notified = false

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

@@ -186,4 +186,29 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.isDefined(nestedC)
     assert.isUndefined(nestedD)
   })
+  test('resolves root path collision by appending a number', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    // Two entities that will generate the same plural path "/items"
+    const e1 = dm.addEntity({ info: { name: 'Item' } })
+    const e2 = dm.addEntity({ info: { name: 'Item' } }) // Same name
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    // Expose first entity -> /items
+    const exp1 = model.exposeEntity({ key: e1.key })
+    assert.equal(exp1.collectionPath, '/items')
+
+    // Expose second entity -> should resolve collision to /items-1
+    const exp2 = model.exposeEntity({ key: e2.key })
+    assert.equal(exp2.collectionPath, '/items-1')
+    assert.equal(exp2.resourcePath, '/items-1/{id}')
+
+    // Expose third entity -> /items-2
+    const e3 = dm.addEntity({ info: { name: 'Item' } })
+    const exp3 = model.exposeEntity({ key: e3.key })
+    assert.equal(exp3.collectionPath, '/items-2')
+  }).tags(['@modeling', '@api'])
 })

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

@@ -9,10 +9,10 @@ test.group('ApiModel.removeEntity()', () => {
     const e1 = dm.addEntity()
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: e1.key })
+    const exposure = model.exposeEntity({ key: e1.key })
     assert.lengthOf(model.exposes, 1)
 
-    model.removeEntity({ key: e1.key })
+    model.removeExposedEntity(exposure.key)
     assert.lengthOf(model.exposes, 0)
   }).tags(['@modeling', '@api'])
 
@@ -26,18 +26,18 @@ test.group('ApiModel.removeEntity()', () => {
     eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: eA.key }, { followAssociations: true })
+    const rootExposure = model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Ensure nested exposure for B was created
     const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
     assert.isDefined(nestedB)
     assert.isAbove(model.exposes.length, 1)
 
-    // Remove root entity A and expect children to be removed as well
-    model.removeEntity({ key: eA.key })
+    // Remove root exposure for A and expect children to be removed as well
+    model.removeExposedEntity(rootExposure.key)
     assert.lengthOf(model.exposes, 0)
   }).tags(['@modeling', '@api'])
 
-  test('does nothing if entity does not exist', ({ assert }) => {
+  test('throws error if entity does not exist', ({ assert }) => {
     const domain = new DataDomain()
     domain.info.version = '1.0.0'
     const dm = domain.addModel()
@@ -46,7 +46,10 @@ test.group('ApiModel.removeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: e1.key })
 
-    model.removeEntity({ key: 'non-existing-entity' })
+    assert.throws(
+      () => model.removeExposedEntity('non-existing-key'),
+      'Exposed entity with key "non-existing-key" not found.'
+    )
     assert.lengthOf(model.exposes, 1, 'exposes count should remain unchanged')
   }).tags(['@modeling', '@api'])
 
@@ -57,13 +60,13 @@ test.group('ApiModel.removeEntity()', () => {
     const e1 = dm.addEntity()
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: e1.key })
+    const exposure = model.exposeEntity({ key: e1.key })
 
     let notified = false
     model.addEventListener('change', () => {
       notified = true
     })
-    model.removeEntity({ key: e1.key })
+    model.removeExposedEntity(exposure.key)
     await Promise.resolve() // Allow microtask to run
     assert.isTrue(notified)
   }).tags(['@modeling', '@api'])
@@ -74,7 +77,11 @@ test.group('ApiModel.removeEntity()', () => {
     model.addEventListener('change', () => {
       notified = true
     })
-    model.removeEntity({ key: 'no-notify-remove-entity' })
+    try {
+      model.removeExposedEntity('no-notify-remove-entity')
+    } catch {
+      // ignore error
+    }
     await Promise.resolve() // Allow microtask to run
     assert.isFalse(notified)
   }).tags(['@modeling', '@api'])

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

@@ -0,0 +1,107 @@
+import { test } from '@japa/runner'
+import { ApiModel, DataDomain } from '../../../src/index.js'
+
+test.group('ExposedEntity Path Setter Validation', () => {
+  test('throws when setting collection path that collides with another root entity', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+    const e2 = dm.addEntity({ info: { name: 'B' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    model.exposeEntity({ key: e1.key }) // /as
+    const exp2 = model.exposeEntity({ key: e2.key }) // /bs
+
+    // Try to rename exp2's collection path to /as (collision)
+    assert.throws(
+      () => exp2.setCollectionPath('/as'),
+      'Collection path "/as" is already in use by another root entity.'
+    )
+  })
+
+  test('throws when setting resource path that collides with another root entity (singleton)', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+    const e2 = dm.addEntity({ info: { name: 'B' } }) // Collection-less
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    const exp1 = model.exposeEntity({ key: e1.key }) // /as, /as/{id}
+    // Manually force a collision for testing resource path (singleton vs singleton or singleton vs resource)
+    // Let's make exp2 a singleton
+    const exp2 = model.exposeEntity({ key: e2.key })
+    // Remove collection from exp2 so we can set arbitrary resource path
+    // Note: implementation of setResourcePath for collection-less allows any 2 segments
+    // We need to simulate the state where hasCollection is false
+    exp2.hasCollection = false
+
+    // Set exp1 resource path to something specific
+    exp1.hasCollection = false
+    exp1.setResourcePath('/shared/path')
+
+    // Try to set exp2 resource path to same
+    assert.throws(
+      () => exp2.setResourcePath('/shared/path'),
+      'Resource path "/shared/path" is already in use by another root entity.'
+    )
+  })
+
+  test('allows setting non-colliding paths for root entity', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    const exp1 = model.exposeEntity({ key: e1.key }) // /as
+
+    exp1.setCollectionPath('/new-path')
+    assert.equal(exp1.collectionPath, '/new-path')
+
+    exp1.hasCollection = false // allow arbitrary resource path
+    exp1.setResourcePath('/custom/resource')
+    assert.equal(exp1.resourcePath, '/custom/resource')
+  })
+
+  test('does not validate collision for non-root entities', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const eA = dm.addEntity({ info: { name: 'A' } })
+    const eB = dm.addEntity({ info: { name: 'B' } })
+    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    // expose A -> B
+    const rootExp = model.exposeEntity({ key: eA.key }, { followAssociations: true })
+    const nestedExp = model.exposes.find((e) => !e.isRoot)
+
+    assert.isDefined(nestedExp)
+    // Assuming root entity has collection path /as
+    assert.equal(rootExp.collectionPath, '/as')
+
+    // Try to set nested entity's collection path to /as
+    // Since it's not root, it should NOT check for collision with rootExp
+    // (In reality this path is technically valid relative to parent, but here we just check that
+    // it doesn't throw the specific root collision error)
+
+    // setCollectionPath logic for non-root:
+    // It doesn't check checks.
+
+    try {
+      nestedExp?.setCollectionPath('/as')
+    } catch (e) {
+      assert.notInclude((e as Error).message, 'already in use by another root entity')
+    }
+  })
+})