@api-client/core 0.19.1 → 0.19.2

package/tests/unit/modeling/ai/DataDomainDelta.spec.ts

@@ -0,0 +1,419 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../../src/index.js'
+import { SemanticType } from '../../../../src/modeling/Semantics.js'
+import { DataDomainDelta } from '../../../../src/modeling/ai/DataDomainDelta.js'
+import type { AiDomainDelta } from '../../../../src/modeling/ai/types.js'
+
+test.group('DataDomainDelta.apply()', () => {
+  test('adds new models', ({ assert }) => {
+    const domain = new DataDomain()
+    const delta: AiDomainDelta = {
+      addedModels: [{ key: 'new-model', name: 'New Model', description: 'Testing new model' }],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    const model = [...domain.listModels()][0]
+    assert.isDefined(model)
+    assert.equal(model!.info.name, 'New Model')
+    assert.equal(model!.info.description, 'Testing new model')
+  })
+
+  test('does not duplicate existing models being added', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addModel({ key: 'existing-model', info: { name: 'Existing' } })
+    const delta: AiDomainDelta = {
+      addedModels: [{ key: 'existing-model', name: 'Should Not Override' }],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    const model = domain.findModel('existing-model')
+    assert.equal(model!.info.name, 'Existing')
+  })
+
+  test('modifies existing models', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addModel({ key: 'mod-model', info: { name: 'Old Name', description: 'Old desc' } })
+    const delta: AiDomainDelta = {
+      modifiedModels: [{ key: 'mod-model', name: 'New Name', description: 'New desc' }],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    const model = domain.findModel('mod-model')
+    assert.equal(model!.info.name, 'New Name')
+    assert.equal(model!.info.description, 'New desc')
+  })
+
+  test('deletes existing models', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addModel({ key: 'del-model' })
+    const delta: AiDomainDelta = { deletedModelKeys: ['del-model'] }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    assert.isUndefined(domain.findModel('del-model'))
+  })
+
+  test('ignores deleting non-existing models', ({ assert }) => {
+    const domain = new DataDomain()
+    const delta: AiDomainDelta = { deletedModelKeys: ['fake-model'] }
+    const instance = new DataDomainDelta(domain)
+    assert.doesNotThrow(() => instance.apply(delta))
+  })
+
+  test('adds new entities', ({ assert }) => {
+    const domain = new DataDomain()
+    const delta: AiDomainDelta = {
+      addedEntities: [
+        {
+          key: 'new-entity',
+          modelKey: 'test-model',
+          name: 'New Entity',
+          properties: [{ key: 'new-prop', type: 'string', name: 'New Prop' }],
+          associations: [{ key: 'new-assoc', name: 'New Assoc', targets: [] }],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    // Check auto-created model
+    const createdModel =
+      domain.findModel('test-model') || Array.from(domain.listModels()).find((m) => m.info.name === 'test-model')
+    assert.isDefined(createdModel)
+
+    const entity = [...createdModel!.listEntities()][0]
+    assert.isDefined(entity)
+    assert.equal(entity!.info.name, 'New Entity')
+    assert.lengthOf(Array.from(entity!.listProperties()), 1)
+    assert.lengthOf(Array.from(entity!.listAssociations()), 1)
+  })
+
+  test('deletes existing entities', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    domain.addEntity(model.key, { key: 'del-entity' })
+    const delta: AiDomainDelta = { deletedEntityKeys: ['del-entity'] }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    assert.isUndefined(domain.findEntity('del-entity'))
+  })
+
+  test('modifies existing entities', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel({ key: 'mod-model' })
+    domain.addEntity(model.key, { key: 'mod-entity', info: { name: 'Old' } })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'mod-entity',
+          name: 'New Entity Name',
+          displayName: 'New Display Name',
+          description: 'New Description',
+          addedSemantics: [{ id: SemanticType.User }],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const modifiedEntity = domain.findEntity('mod-entity')
+    assert.isDefined(modifiedEntity)
+    assert.equal(modifiedEntity!.info.name, 'New Entity Name')
+    assert.equal(modifiedEntity!.info.displayName, 'New Display Name')
+    assert.equal(modifiedEntity!.info.description, 'New Description')
+
+    const semantics = modifiedEntity!.semantics
+    assert.isDefined(semantics)
+    assert.lengthOf(semantics!, 1)
+    assert.equal(semantics![0].id, SemanticType.User)
+  })
+
+  test('re-attaches entity to a new model', ({ assert }) => {
+    const domain = new DataDomain()
+    const model1 = domain.addModel({ key: 'model1' })
+    const model2 = domain.addModel({ key: 'model2' })
+    domain.addEntity(model1.key, { key: 'move-entity' })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'move-entity',
+          modelKey: 'model2',
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const movedEntity = domain.findEntity('move-entity')
+    assert.isDefined(movedEntity)
+    assert.equal(movedEntity!.getParentInstance()?.key, model2.key)
+  })
+
+  test('modifies entity properties', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { info: { name: 'prop-entity' } })
+    entity.addProperty({ key: 'prop1', type: 'string', info: { name: 'Old' } })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: entity.key,
+          addedProperties: [{ key: 'prop2', type: 'number', name: 'New Prop' }],
+          modifiedProperties: [
+            {
+              key: 'prop1',
+              name: 'Modified Prop',
+              type: 'boolean',
+              constraints: { required: true },
+              schema: { minimum: 5 },
+            },
+          ],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const [prop1, prop2] = [...entity.listProperties()]
+
+    assert.isDefined(prop1)
+    assert.equal(prop1!.info.name, 'Modified Prop')
+    assert.equal(prop1!.type, 'boolean')
+    assert.isTrue(prop1!.required)
+    assert.equal(prop1!.schema?.minimum, 5)
+
+    assert.isDefined(prop2)
+    assert.equal(prop2!.type, 'number')
+    assert.equal(prop2!.info.name, 'New Prop')
+  })
+
+  test('deletes entity properties', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { key: 'prop-del-entity' })
+    entity.addProperty({ key: 'prop1', type: 'string' })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'prop-del-entity',
+          deletedPropertyKeys: ['prop1'],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    assert.isUndefined(domain.findProperty('prop1'))
+  })
+
+  test('modifies entity associations', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { info: { name: 'assoc-entity' } })
+    const targetEntity1 = domain.addEntity(model.key, { key: 'target1', info: { name: 'Target 1' } })
+    const targetEntity2 = domain.addEntity(model.key, { key: 'target2', info: { name: 'Target 2' } })
+    entity.addAssociation({ key: 'assoc1', info: { name: 'Old Assoc' } })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: entity.key,
+          addedAssociations: [{ key: 'assoc2', name: 'New Assoc', targets: [{ key: targetEntity2.key }] }],
+          modifiedAssociations: [
+            { key: 'assoc1', name: 'Modified Assoc', required: true, targets: [{ key: targetEntity1.key }] },
+          ],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const [assoc1, assoc2] = [...entity.listAssociations()]
+
+    assert.isDefined(assoc1)
+    assert.equal(assoc1!.info.name, 'Modified Assoc')
+    assert.isTrue(assoc1!.required)
+    assert.includeMembers(
+      assoc1!.targets.map((t) => t.key),
+      [targetEntity1.key]
+    )
+
+    assert.isDefined(assoc2)
+    assert.equal(assoc2!.info.name, 'New Assoc')
+    assert.includeMembers(
+      assoc2!.targets.map((t) => t.key),
+      [targetEntity2.key]
+    )
+  })
+
+  test('deletes entity associations', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { key: 'assoc-del-entity' })
+    entity.addAssociation({ key: 'assoc1' })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'assoc-del-entity',
+          deletedAssociationKeys: ['assoc1'],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+    assert.isUndefined(domain.findAssociation('assoc1'))
+  })
+
+  test('adds, modifies, and deletes semantics on an entity', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { key: 'semantic-entity' })
+    entity.addSemantic({ id: SemanticType.Address })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'semantic-entity',
+          addedSemantics: [{ id: SemanticType.User }],
+          modifiedSemantics: [{ id: SemanticType.Address, config: { someVal: true } }],
+          deletedSemanticIds: [SemanticType.Tags],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const semantics = entity.semantics
+    assert.isDefined(semantics)
+    assert.lengthOf(semantics!, 2)
+    const intSem = semantics!.find((s) => s.id === SemanticType.Address)
+    assert.isDefined(intSem)
+    assert.deepEqual(intSem!.config, { someVal: true })
+
+    const userSem = semantics!.find((s) => s.id === SemanticType.User)
+    assert.isDefined(userSem)
+
+    // Now delete
+    const deltaDel: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'semantic-entity',
+          deletedSemanticIds: [SemanticType.User],
+        },
+      ],
+    }
+    instance.apply(deltaDel)
+    assert.lengthOf(entity.semantics!, 1)
+    assert.isUndefined(entity.semantics!.find((s) => s.id === SemanticType.User))
+  })
+
+  test('adds semantics to properties and associations', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { key: 'sem-prop-entity' })
+    entity.addProperty({ key: 'prop1', type: 'string' })
+    entity.addAssociation({ key: 'assoc1' })
+
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: entity.key,
+          modifiedProperties: [
+            {
+              key: 'prop1',
+              addedSemantics: [{ id: SemanticType.Password }],
+            },
+          ],
+          modifiedAssociations: [
+            {
+              key: 'assoc1',
+              addedSemantics: [{ id: SemanticType.Tags }], // Example valid for association in some contexts
+            },
+          ],
+        },
+      ],
+    }
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    const prop1 = domain.findProperty('prop1')
+    assert.lengthOf(prop1!.semantics!, 1)
+    assert.equal(prop1!.semantics![0].id, SemanticType.Password)
+
+    const assoc1 = domain.findAssociation('assoc1')
+    assert.lengthOf(assoc1!.semantics!, 1)
+    assert.equal(assoc1!.semantics![0].id, SemanticType.Tags)
+  })
+})
+
+test.group('DataDomainDelta.normalize()', () => {
+  test('merges duplicated entities', ({ assert }) => {
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        { key: 'ent1', name: 'First Name', addedProperties: [{ key: 'p1', type: 'string', name: 'Prop 1' }] },
+        { key: 'ent1', displayName: 'Display', addedProperties: [{ key: 'p2', type: 'number', name: 'Prop 2' }] },
+      ],
+    }
+
+    const normalized = DataDomainDelta.normalize(delta)
+    assert.lengthOf(normalized.modifiedEntities!, 1)
+
+    const ent = normalized.modifiedEntities![0]
+    assert.equal(ent.name, 'First Name')
+    assert.equal(ent.displayName, 'Display')
+    assert.lengthOf(ent.addedProperties!, 2)
+    assert.equal(ent.addedProperties![0].key, 'p1')
+    assert.equal(ent.addedProperties![1].key, 'p2')
+  })
+
+  test('merges primitive arrays like tags and deleted keys', ({ assert }) => {
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        { key: 'ent1', tags: ['a'], deletedPropertyKeys: ['p1'] },
+        { key: 'ent1', tags: ['b', 'a'], deletedPropertyKeys: ['p2', 'p1'] },
+      ],
+      deletedModelKeys: ['m1', 'm2', 'm1'],
+      deletedEntityKeys: ['e1', 'e1'],
+    }
+
+    const normalized = DataDomainDelta.normalize(delta)
+    const ent = normalized.modifiedEntities![0]
+    assert.sameMembers(ent.tags!, ['a', 'b'])
+    assert.sameMembers(ent.deletedPropertyKeys!, ['p1', 'p2'])
+
+    assert.sameMembers(normalized.deletedModelKeys!, ['m1', 'm2'])
+    assert.sameMembers(normalized.deletedEntityKeys!, ['e1'])
+  })
+
+  test('merges nested properties and semantics', ({ assert }) => {
+    const delta: AiDomainDelta = {
+      modifiedEntities: [
+        {
+          key: 'ent1',
+          modifiedProperties: [{ key: 'p1', name: 'Name', constraints: { required: true } }],
+          addedSemantics: [{ id: SemanticType.User, config: { a: 1 } }],
+        },
+        {
+          key: 'ent1',
+          modifiedProperties: [{ key: 'p1', type: 'number', constraints: { unique: true } }],
+          addedSemantics: [{ id: SemanticType.User, config: { b: 2 } }],
+        },
+      ],
+    }
+
+    const normalized = DataDomainDelta.normalize(delta)
+    const ent = normalized.modifiedEntities![0]
+
+    assert.lengthOf(ent.modifiedProperties!, 1)
+    const p1 = ent.modifiedProperties![0]
+    assert.equal(p1.name, 'Name')
+    assert.equal(p1.type, 'number')
+    assert.deepEqual(p1.constraints, { required: true, unique: true })
+
+    assert.lengthOf(ent.addedSemantics!, 1)
+    assert.deepEqual(ent.addedSemantics![0].config, { a: 1, b: 2 })
+  })
+})

package/tests/unit/modeling/ai/DomainAiTools.spec.ts

@@ -0,0 +1,29 @@
+import { test } from '@japa/runner'
+import { tools, functions } from '../../../../src/modeling/ai/domain_tools.js'
+
+test.group('DomainAiTools', () => {
+  test('all declared functions have an implementation', ({ assert }) => {
+    const declarations = tools[0].functionDeclarations!
+    for (const decl of declarations) {
+      assert.property(
+        functions,
+        decl.name as string,
+        `Function declaration ${decl.name} does not have a corresponding implementation in functions object`
+      )
+      assert.isFunction(functions[decl.name as string], `Implementation for ${decl.name} must be a function`)
+    }
+  })
+
+  test('all implemented functions have a declaration', ({ assert }) => {
+    const declarations = tools[0].functionDeclarations!
+    const declaredNames = declarations.map((d) => d.name)
+
+    for (const funcName of Object.keys(functions)) {
+      assert.include(
+        declaredNames,
+        funcName,
+        `Implemented function ${funcName} does not have a corresponding declaration in tools object`
+      )
+    }
+  })
+})

package/tests/unit/modeling/ai/DomainSerialization.spec.ts

@@ -0,0 +1,143 @@
+import { test } from '@japa/runner'
+import { serializeDomainForAi, serializeEntity } from '../../../../src/modeling/ai/DomainSerialization.js'
+import { DataDomain } from '../../../../src/index.js'
+import { SemanticType } from '../../../../src/modeling/Semantics.js'
+
+test.group('DomainSerialization', () => {
+  test('serializeDomainForAi correctly serializes models, entities, and namespaces', ({ assert }) => {
+    const domain = new DataDomain({
+      info: { name: 'Test Domain', description: 'Testing out serialization' },
+    })
+
+    const rootModel = domain.addModel({
+      info: { name: 'Root Model' },
+    })
+    const rootEntity = domain.addEntity(rootModel.key, {
+      info: { name: 'Root Entity' },
+    })
+
+    // Add a namespace
+    const namespace = domain.addNamespace({
+      info: { name: 'Core Namespace', description: 'Core items' },
+    })
+
+    const nsModel = domain.addModel({ info: { name: 'NS Model' } }, namespace.key)
+    const nsEntity = domain.addEntity(nsModel.key, { info: { name: 'NS Entity' } })
+
+    // Perform serialization
+    const serializedDomain = serializeDomainForAi(domain)
+
+    // Domain Assertions
+    assert.equal(serializedDomain.key, domain.key)
+    assert.equal(serializedDomain.name, 'Test Domain')
+
+    // Models Assertions (Should include both root and namespace models due to processNamespace recursion)
+    assert.lengthOf(serializedDomain.models, 2)
+    const serializedRootModel = serializedDomain.models.find((m) => m.key === rootModel.key)
+    assert.isDefined(serializedRootModel)
+    assert.equal(serializedRootModel!.name, 'Root Model')
+
+    const serializedNsModel = serializedDomain.models.find((m) => m.key === nsModel.key)
+    assert.isDefined(serializedNsModel)
+    assert.equal(serializedNsModel!.name, 'NS Model')
+
+    // Entities Assertions
+    assert.lengthOf(serializedDomain.entities, 2)
+    const serializedRootEntity = serializedDomain.entities.find((e) => e.key === rootEntity.key)
+    assert.isDefined(serializedRootEntity)
+    assert.equal(serializedRootEntity!.modelKey, rootModel.key)
+    assert.equal(serializedRootEntity!.name, 'Root Entity')
+
+    const serializedNsEntity = serializedDomain.entities.find((e) => e.key === nsEntity.key)
+    assert.isDefined(serializedNsEntity)
+    assert.equal(serializedNsEntity!.modelKey, nsModel.key)
+    assert.equal(serializedNsEntity!.name, 'NS Entity')
+  })
+
+  test('serializeEntity correctly serializes properties, associations, and semantics', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel({ info: { name: 'User Model' } })
+    const entity = domain.addEntity(model.key, {
+      info: { name: 'User', displayName: 'System User', description: 'User entity' },
+      tags: ['auth', 'core'],
+    })
+    entity.addSemantic({ id: SemanticType.User })
+
+    const stringProp = entity.addProperty({
+      type: 'string',
+      info: { name: 'username', displayName: 'Username', description: 'The username' },
+      required: true,
+      unique: true,
+      schema: {
+        minimum: 3,
+        maximum: 50,
+      },
+    })
+    stringProp.addSemantic({ id: SemanticType.Username })
+
+    const booleanProp = entity.addProperty({
+      type: 'boolean',
+      info: { name: 'isActive', displayName: 'Active', description: 'Is the user active' },
+    })
+    booleanProp.addSemantic({ id: SemanticType.Calculated, config: { formula: 'true' } })
+
+    const otherModel = domain.addModel()
+    const otherEntity = domain.addEntity(otherModel.key, { info: { name: 'Role' } })
+
+    const assoc = entity.addAssociation({
+      info: { name: 'roles', displayName: 'Roles', description: 'User roles' },
+      multiple: true,
+      required: false,
+    })
+    assoc.addTarget(otherEntity.key)
+    assoc.addSemantic({ id: SemanticType.Tags })
+
+    // Perform Entity Full Serialization Assertions
+    const serializedEntity = serializeEntity(entity, model.key)
+    assert.equal(serializedEntity.key, entity.key)
+    assert.equal(serializedEntity.modelKey, model.key)
+    assert.equal(serializedEntity.name, 'User')
+    assert.equal(serializedEntity.displayName, 'System User')
+    assert.equal(serializedEntity.description, 'User entity')
+    assert.deepEqual(serializedEntity.tags, ['auth', 'core'])
+
+    // Entity Semantics
+    assert.isDefined(serializedEntity.semantics)
+    assert.lengthOf(serializedEntity.semantics!, 1)
+    assert.equal(serializedEntity.semantics![0].id, SemanticType.User)
+
+    // Properties Assertions
+    assert.isDefined(serializedEntity.properties)
+    assert.lengthOf(serializedEntity.properties!, 2)
+
+    const serializedStringProp = serializedEntity.properties!.find((p) => p.name === 'username')
+    assert.isDefined(serializedStringProp)
+    assert.equal(serializedStringProp!.type, 'string')
+    assert.equal(serializedStringProp!.displayName, 'Username')
+    assert.equal(serializedStringProp!.description, 'The username')
+    assert.deepEqual(serializedStringProp!.constraints, { required: true, unique: true })
+    assert.deepEqual(serializedStringProp!.schema, { minimum: 3, maximum: 50 })
+    assert.isDefined(serializedStringProp!.semantics)
+    assert.equal(serializedStringProp!.semantics![0].id, SemanticType.Username)
+
+    const serializedBoolProp = serializedEntity.properties!.find((p) => p.name === 'isActive')
+    assert.isDefined(serializedBoolProp)
+    assert.equal(serializedBoolProp!.type, 'boolean')
+    assert.isDefined(serializedBoolProp!.semantics)
+    assert.equal(serializedBoolProp!.semantics![0].id, SemanticType.Calculated)
+    assert.deepEqual(serializedBoolProp!.semantics![0].config, { formula: 'true' })
+
+    // Association Assertions
+    assert.isDefined(serializedEntity.associations)
+    assert.lengthOf(serializedEntity.associations!, 1)
+
+    const serializedAssoc = serializedEntity.associations![0]
+    assert.equal(serializedAssoc.key, assoc.key)
+    assert.equal(serializedAssoc.name, 'roles')
+    assert.equal(serializedAssoc.displayName, 'Roles')
+    assert.equal(serializedAssoc.description, 'User roles')
+    assert.equal(serializedAssoc.required, false)
+    assert.isDefined(serializedAssoc.semantics)
+    assert.equal(serializedAssoc.semantics![0].id, SemanticType.Tags)
+  })
+})