@api-client/core 0.18.48 → 0.18.50

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

@@ -138,6 +138,13 @@ test.group('dataCatalogs()', (group) => {
     catalog.dataCatalogs(5)
     assert.equal(spy.callCount, 5)
   })
+
+  test('uses passed initialization values', ({ assert }) => {
+    const result = catalog.dataCatalogs(3, { name: 'Batch Catalog' })
+    result.forEach((item) => {
+      assert.equal(item.name, 'Batch Catalog')
+    })
+  })
 })
 
 test.group('dataCatalogVersion()', (group) => {
@@ -265,6 +272,13 @@ test.group('dataCatalogVersions()', (group) => {
     catalog.dataCatalogVersions(3)
     assert.equal(spy.callCount, 3)
   })
+
+  test('uses passed initialization values', ({ assert }) => {
+    const result = catalog.dataCatalogVersions(3, { version: 'v1.2.3' })
+    result.forEach((item) => {
+      assert.equal(item.version, 'v1.2.3')
+    })
+  })
 })
 
 test.group('dataCatalogWithVersion()', (group) => {
@@ -372,6 +386,13 @@ test.group('dataCatalogsWithVersion()', (group) => {
       assert.isAtLeast(item.versions.length, 1)
     })
   })
+
+  test('uses passed initialization values', ({ assert }) => {
+    const result = catalog.dataCatalogsWithVersion(3, { name: 'Versioned Batch' })
+    result.forEach((item) => {
+      assert.equal(item.name, 'Versioned Batch')
+    })
+  })
 })
 
 test.group('versionInfo()', (group) => {
@@ -446,4 +467,11 @@ test.group('versionInfos()', (group) => {
     catalog.versionInfos(6)
     assert.equal(spy.callCount, 6)
   })
+
+  test('uses passed initialization values', ({ assert }) => {
+    const result = catalog.versionInfos(3, { version: 'v9.9.9' })
+    result.forEach((item) => {
+      assert.equal(item.version, 'v9.9.9')
+    })
+  })
 })

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

@@ -0,0 +1,79 @@
+import { test } from '@japa/runner'
+import { File } from '../../../../src/mocking/lib/File.js'
+import { FolderKind, ProjectKind } from '../../../../src/models/kinds.js'
+import type { IFile } from '../../../../src/models/store/File.js'
+
+test.group('File', (group) => {
+  let fileMock: File
+
+  group.each.setup(() => {
+    fileMock = new File()
+  })
+
+  test('file() returns a valid object', ({ assert }) => {
+    const result = fileMock.file()
+    assert.typeOf(result, 'object')
+    assert.property(result, 'kind')
+    assert.property(result, 'info')
+  })
+
+  test('file(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IFile> = {
+      kind: ProjectKind,
+      info: { name: 'My Project' },
+    }
+    const result = fileMock.file(init)
+    assert.equal(result.kind, ProjectKind)
+    assert.equal(result.info.name, 'My Project')
+  })
+
+  test('files() returns a list', ({ assert }) => {
+    const result = fileMock.files(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('files(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IFile> = {
+      kind: ProjectKind,
+    }
+    const result = fileMock.files(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.kind, ProjectKind)
+    })
+  })
+
+  test('folder() returns a valid object', ({ assert }) => {
+    const result = fileMock.folder()
+    assert.typeOf(result, 'object')
+    assert.equal(result.kind, FolderKind)
+  })
+
+  test('folder(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IFile> = {
+      key: 'custom-folder-key',
+    }
+    const result = fileMock.folder(init)
+    assert.equal(result.kind, FolderKind)
+    assert.equal(result.key, 'custom-folder-key')
+  })
+
+  test('folders() returns a list', ({ assert }) => {
+    const result = fileMock.folders(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('folders(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IFile> = {
+      key: 'batch-key',
+    }
+    const result = fileMock.folders(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.kind, FolderKind)
+      assert.equal(item.key, 'batch-key')
+    })
+  })
+})

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

@@ -0,0 +1,49 @@
+import { test } from '@japa/runner'
+import { Group } from '../../../../src/mocking/lib/Group.js'
+import { GroupKind } from '../../../../src/models/kinds.js'
+import type { GroupSchema } from '../../../../src/models/store/Group.js'
+
+test.group('Group', (group) => {
+  let groupMock: Group
+
+  group.each.setup(() => {
+    groupMock = new Group()
+  })
+
+  test('group() returns a valid object', ({ assert }) => {
+    const result = groupMock.group()
+    assert.typeOf(result, 'object')
+    assert.equal(result.kind, GroupKind)
+    assert.property(result, 'key')
+    assert.property(result, 'name')
+    assert.property(result, 'color')
+    assert.property(result, 'users')
+  })
+
+  test('group(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<GroupSchema> = {
+      name: 'Custom Group',
+      color: '#ff0000',
+    }
+    const result = groupMock.group(init)
+    assert.equal(result.name, 'Custom Group')
+    assert.equal(result.color, '#ff0000')
+  })
+
+  test('groups() returns a list', ({ assert }) => {
+    const result = groupMock.groups(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('groups(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<GroupSchema> = {
+      description: 'Batch Description',
+    }
+    const result = groupMock.groups(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.description, 'Batch Description')
+    })
+  })
+})

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

@@ -0,0 +1,49 @@
+import { test } from '@japa/runner'
+import { Invitation } from '../../../../src/mocking/lib/Invitation.js'
+import { InvitationKind } from '../../../../src/models/kinds.js'
+import type { InvitationSchema } from '../../../../src/models/store/Invitation.js'
+
+test.group('Invitation', (group) => {
+  let invitation: Invitation
+
+  group.each.setup(() => {
+    invitation = new Invitation()
+  })
+
+  test('invitation() returns a valid object', ({ assert }) => {
+    const result = invitation.invitation()
+    assert.typeOf(result, 'object')
+    assert.equal(result.kind, InvitationKind)
+    assert.property(result, 'key')
+    assert.property(result, 'email')
+    assert.property(result, 'token')
+    assert.property(result, 'status')
+  })
+
+  test('invitation(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<InvitationSchema> = {
+      email: 'test@example.com',
+      status: 'accepted',
+    }
+    const result = invitation.invitation(init)
+    assert.equal(result.email, 'test@example.com')
+    assert.equal(result.status, 'accepted')
+  })
+
+  test('invitations() returns a list', ({ assert }) => {
+    const result = invitation.invitations(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('invitations(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<InvitationSchema> = {
+      status: 'declined',
+    }
+    const result = invitation.invitations(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.status, 'declined')
+    })
+  })
+})

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

@@ -0,0 +1,50 @@
+import { test } from '@japa/runner'
+import { Organization } from '../../../../src/mocking/lib/Organization.js'
+import { OrganizationKind } from '../../../../src/models/kinds.js'
+import type { IOrganization } from '../../../../src/models/store/Organization.js'
+
+test.group('Organization', (group) => {
+  let organization: Organization
+
+  group.each.setup(() => {
+    organization = new Organization()
+  })
+
+  test('organization() returns a valid object', ({ assert }) => {
+    const result = organization.organization()
+    assert.typeOf(result, 'object')
+    assert.equal(result.kind, OrganizationKind)
+    assert.property(result, 'key')
+    assert.property(result, 'name')
+    assert.property(result, 'createdBy')
+    assert.property(result, 'createdDate')
+    assert.property(result, 'grantType')
+  })
+
+  test('organization(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IOrganization> = {
+      key: 'custom-org-key',
+      name: 'Custom Org',
+    }
+    const result = organization.organization(init)
+    assert.equal(result.key, 'custom-org-key')
+    assert.equal(result.name, 'Custom Org')
+  })
+
+  test('organizations() returns a list', ({ assert }) => {
+    const result = organization.organizations(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('organizations(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<IOrganization> = {
+      name: 'Batch Org',
+    }
+    const result = organization.organizations(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.name, 'Batch Org')
+    })
+  })
+})

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

@@ -0,0 +1,47 @@
+import { test } from '@japa/runner'
+import { Patch } from '../../../../src/mocking/lib/Patch.js'
+import type { MediaPatchRevision } from '../../../../src/patch/types.js'
+
+test.group('Patch', (group) => {
+  let patch: Patch
+
+  group.each.setup(() => {
+    patch = new Patch()
+  })
+
+  test('mediaPatchRevision() returns a valid object', ({ assert }) => {
+    const result = patch.mediaPatchRevision()
+    assert.typeOf(result, 'object')
+    assert.property(result, 'id')
+    assert.property(result, 'timestamp')
+    assert.property(result, 'patch')
+    assert.property(result, 'version')
+  })
+
+  test('mediaPatchRevision(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<MediaPatchRevision> = {
+      id: 'custom-id',
+      version: 99,
+    }
+    const result = patch.mediaPatchRevision(init)
+    assert.equal(result.id, 'custom-id')
+    assert.equal(result.version, 99)
+  })
+
+  test('mediaPatchRevisions() returns a list', ({ assert }) => {
+    const result = patch.mediaPatchRevisions(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('mediaPatchRevisions(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<MediaPatchRevision> = {
+      version: 123,
+    }
+    const result = patch.mediaPatchRevisions(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.version, 123)
+    })
+  })
+})

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

@@ -0,0 +1,49 @@
+import { test } from '@japa/runner'
+import { Trash } from '../../../../src/mocking/lib/Trash.js'
+import { ProjectKind } from '../../../../src/models/kinds.js'
+import type { TrashEntry } from '../../../../src/models/TrashEntry.js'
+
+test.group('Trash', (group) => {
+  let trash: Trash
+
+  group.each.setup(() => {
+    trash = new Trash()
+  })
+
+  test('trashEntry() returns a valid object', ({ assert }) => {
+    const result = trash.trashEntry()
+    assert.typeOf(result, 'object')
+    assert.property(result, 'key')
+    assert.property(result, 'refKey')
+    assert.property(result, 'kind')
+    assert.property(result, 'info')
+    assert.property(result, 'capabilities')
+  })
+
+  test('trashEntry(init) allows overriding properties', ({ assert }) => {
+    const init: Partial<TrashEntry> = {
+      key: 'custom-key',
+      kind: ProjectKind,
+    }
+    const result = trash.trashEntry(init)
+    assert.equal(result.key, 'custom-key')
+    assert.equal(result.kind, ProjectKind)
+  })
+
+  test('trashEntries() returns a list', ({ assert }) => {
+    const result = trash.trashEntries(5)
+    assert.isArray(result)
+    assert.lengthOf(result, 5)
+  })
+
+  test('trashEntries(size, init) allows overriding properties', ({ assert }) => {
+    const init: Partial<TrashEntry> = {
+      kind: ProjectKind,
+    }
+    const result = trash.trashEntries(3, init)
+    assert.lengthOf(result, 3)
+    result.forEach((item) => {
+      assert.equal(item.kind, ProjectKind)
+    })
+  })
+})

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