@api-client/core 0.13.6 → 0.14.1

package/src/models/kinds.ts

@@ -20,28 +20,3 @@ export const DataCatalogKind = 'Core#DataCatalog'
 export const DataCatalogVersionKind = 'Core#DataCatalogVersion'
 export const OrganizationKind = 'Core#Organization'
 export const InvitationKind = 'Core#Invitation'
-
-/**
- * @deprecated Not used anymore.
- */
-export const DataFileKind = 'Core#DataFile'
-/**
- * @deprecated Not used anymore.
- */
-export const DataNamespaceKind = 'Data#DataNamespace'
-/**
- * @deprecated Not used anymore.
- */
-export const DataModelKind = 'Data#DataModel'
-/**
- * @deprecated Not used anymore.
- */
-export const DataEntityKind = 'Data#DataEntity'
-/**
- * @deprecated Not used anymore.
- */
-export const DataAssociationKind = 'Data#DataAssociation'
-/**
- * @deprecated Not used anymore.
- */
-export const DataPropertyKind = 'Data#DataProperty'

package/src/models/store/File.ts

@@ -51,19 +51,10 @@ export interface IStoredFile {
    * The identifier of the entity
    */
   key: string
-  /**
-   * The parent organization of the file.
-   */
-  organization: string
   /**
    * The file's meta info.
    */
   info: IThing
-  /**
-   * The owner of this object. The id of the User object.
-   * Once the File is persistent by the API this is always populated.
-   */
-  owner?: string
   /**
    * The color of the icon to render for this file in the file explorer.
    * This should be a hex format, e.g.: #c00 for red.
@@ -144,7 +135,6 @@ export interface IFile extends IStoredFile {
 const parentsSymbol = Symbol('parents')
 const deletedSymbol = Symbol('deleted')
 const deletedInfoSymbol = Symbol('deletedInfo')
-const ownerSymbol = Symbol('owner')
 const lastModifiedSymbol = Symbol('lastModified')
 const capabilitiesSymbol = Symbol('capabilities')
 const permissionsSymbol = Symbol('permissions')
@@ -160,24 +150,10 @@ export class StoredFile {
    * The identifier of the entity
    */
   key = ''
-  /**
-   * The parent organization of the file.
-   */
-  organization = ''
   /**
    * The name of the environment.
    */
-  info: Thing = Thing.fromName('');
-
-  [ownerSymbol]?: string
-
-  /**
-   * The owner of this file. This is the id of the User object.
-   * Set to `default` when there are no users in the system (no authentication).
-   */
-  get owner(): string | undefined {
-    return this[ownerSymbol]
-  }
+  info: Thing = Thing.fromName('')
 
   /**
    * The color of the icon to render for this file in the file explorer.
@@ -206,11 +182,9 @@ export class StoredFile {
   }
 
   new(init: IStoredFile): this {
-    const { key = nanoid(), info, kind, owner, iconColor, organization, shortcutTarget } = init
+    const { key = nanoid(), info, kind, iconColor, shortcutTarget } = init
     this.key = key
-    this.organization = organization
     this.kind = kind
-    this[ownerSymbol] = owner
     if (info) {
       this.info = new Thing(info)
     } else {
@@ -230,13 +204,10 @@ export class StoredFile {
   }
 
   toJSON(): IStoredFile {
-    const { owner } = this
     const result: IStoredFile = {
       key: this.key,
-      organization: this.organization,
       kind: this.kind,
       info: this.info.toJSON(),
-      owner,
     }
     if (this.iconColor) {
       result.iconColor = this.iconColor
@@ -484,19 +455,17 @@ export class File extends StoredFile {
    * @param name The name to set.
    * @param owner The user id that is the owner of the file.
    */
-  static fromName(name: string, organization: string, owner?: string, kind = ''): File {
+  static fromName(name: string, kind = ''): File {
     const key = nanoid()
     const definition = new File()
     definition.new({
       key,
       kind,
-      organization,
       info: Thing.fromName(name).toJSON(),
-      owner,
       parents: [],
       permissionIds: [],
       permissions: [],
-      lastModified: { user: owner || '', time: 0, byMe: false },
+      lastModified: { user: '', time: 0, byMe: false },
     })
     return definition
   }

package/src/models/store/data_catalog.ts

@@ -23,7 +23,7 @@ export interface PublishedDataDomain {
    */
   version: string
   /**
-   * Key of the referenced `DataNamespace` document.
+   * Key of the referenced `DomainNamespace` document.
    * Essentially this is a document id.
    */
   fid: string

package/src/sdk/FilesSdk.ts

@@ -200,7 +200,7 @@ export class FilesSdk extends SdkBase {
     opts: IMetaCreateOptions = {},
     request: SdkOptions = {}
   ): Promise<IFolder> {
-    const file = Folder.fromName(name, organization)
+    const file = Folder.fromName(name)
     const { token } = request
     const url = this.sdk.getUrl(RouteBuilder.files(organization))
     if (opts.parent) {

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

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { DataDomain, DataFormat } from '../../../src/index.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DataDomain change observers', () => {
   test('does not notifies a change when initializing a domain', async ({ assert }) => {
@@ -276,24 +277,24 @@ test.group('DomainEntity change observers', () => {
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when adding a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when adding a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     await sleep(1)
-    e1.taxonomy.push('test')
+    e1.semantics.push({ id: SemanticType.User })
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when removing a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when removing a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
-    e1.taxonomy.push('test')
+    e1.semantics.push({ id: SemanticType.User })
     await sleep(1)
-    e1.taxonomy.pop()
+    e1.semantics.pop()
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
@@ -508,26 +509,26 @@ test.group('DomainProperty change observers', () => {
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when adding a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when adding a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     const p1 = e1.addProperty()
     await sleep(1)
-    p1.taxonomy.push('test')
+    p1.semantics.push({ id: SemanticType.CreatedTimestamp })
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when removing a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when removing a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     const p1 = e1.addProperty()
-    p1.taxonomy.push('test')
+    p1.semantics.push({ id: SemanticType.CreatedTimestamp })
     await sleep(1)
-    p1.taxonomy.pop()
+    p1.semantics.pop()
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 

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

@@ -1,6 +1,7 @@
 import { test } from '@japa/runner'
 import { DataDomain } from '../../../src/modeling/DataDomain.js'
 import { DomainEntity } from '../../../src/modeling/DomainEntity.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DataDomain.addEntity()', () => {
   test('addEntity adds an entity to the graph', ({ assert }) => {
@@ -70,7 +71,7 @@ test.group('DataDomain.addEntity()', () => {
     assert.throws(() => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addEntity(undefined, { key: 'test-entity' })
-    }, `An entity expects a DataModel parent`)
+    }, `An entity expects a DomainModel parent`)
   })
 
   test('addEntity throws when adding the same entity twice', ({ assert }) => {
@@ -328,6 +329,133 @@ test.group('DataDomain.findEntity()', () => {
   })
 })
 
+test.group('DomainEntity.addSemantic()', () => {
+  test('adds a new semantic to the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.deepInclude(entity.semantics, semantic)
+  })
+
+  test('updates an existing semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic1 = { id: SemanticType.User, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.User, config: { value: 'new' } }
+    entity.addSemantic(semantic1)
+    entity.addSemantic(semantic2)
+    assert.lengthOf(entity.semantics, 1)
+    assert.deepInclude(entity.semantics, semantic2)
+  })
+
+  test('throws an error if the semantic is not an entity semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.CreatedTimestamp } // CreatedTimestamp is a Property semantic
+    assert.throws(() => {
+      entity.addSemantic(semantic)
+    }, `Invalid semantic type: ${SemanticType.CreatedTimestamp}. Expected an entity semantic.`)
+  })
+
+  test('notifies change when adding a new semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('notifies change when updating an existing semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic1 = { id: SemanticType.User, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.User, config: { value: 'new' } }
+    entity.addSemantic(semantic1)
+    // Clear the event queue before the second add
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.addSemantic(semantic2)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainEntity.removeSemantic()', () => {
+  test('removes an existing semantic from the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.deepInclude(entity.semantics, semantic)
+    entity.removeSemantic(SemanticType.User)
+    assert.notDeepInclude(entity.semantics, semantic)
+    assert.lengthOf(entity.semantics, 0)
+  })
+
+  test('does nothing if the semantic to remove does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    const initialSemantics = [...entity.semantics]
+    entity.removeSemantic('non-existent-semantic-id' as SemanticType)
+    assert.deepEqual(entity.semantics, initialSemantics)
+  })
+
+  test('notifies change when a semantic is removed', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.removeSemantic(SemanticType.User)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('does not notify change if the semantic to remove does not exist', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.removeSemantic('non-existent-semantic-id' as SemanticType)
+    await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainEntity.hasSemantic()', () => {
+  test('returns true if the entity has the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.isTrue(entity.hasSemantic(SemanticType.User))
+  })
+
+  test('returns false if the entity does not have the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    assert.isFalse(entity.hasSemantic(SemanticType.User))
+  })
+
+  test('returns false for an empty semantics array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    assert.isFalse(entity.hasSemantic(SemanticType.User))
+  })
+})
+
 test.group('DataDomain.moveEntity()', () => {
   test('moves an entity from one model to another', ({ assert }) => {
     const dataDomain = new DataDomain()

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

@@ -67,7 +67,7 @@ test.group('DataDomain.addProperty()', () => {
     assert.throws(() => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addProperty(undefined)
-    }, 'A property expects a DataEntity parent')
+    }, 'A property expects a DomainEntity parent')
   })
 
   test('addProperty throws when adding property to a foreign entity', ({ assert }) => {