@api-client/core 0.14.1 → 0.14.2

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

@@ -8,6 +8,7 @@ import {
   DataDomain,
   DataFormat,
   SemanticType,
+  type OnDeleteRule,
 } from '../../../src/index.js'
 
 test.group('DomainAssociation.createSchema()', () => {
@@ -23,6 +24,8 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.isUndefined(schema.bindings)
     assert.isUndefined(schema.targets)
     assert.deepEqual(schema.semantics, [])
+    assert.isUndefined(schema.onDelete)
+    assert.isUndefined(schema.readOnly)
   })
 
   test('creates a schema with provided key', ({ assert }) => {
@@ -43,6 +46,17 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.deepEqual(schema.semantics, semantics)
   })
 
+  test('creates a schema with provided onDelete rule', ({ assert }) => {
+    const onDelete: OnDeleteRule = 'cascade'
+    const schema = DomainAssociation.createSchema({ onDelete })
+    assert.equal(schema.onDelete, onDelete)
+  })
+
+  test('creates a schema with provided readOnly rule', ({ assert }) => {
+    const schema = DomainAssociation.createSchema({ readOnly: true })
+    assert.isTrue(schema.readOnly)
+  })
+
   test('creates a schema with provided schema', ({ assert }) => {
     const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
@@ -80,6 +94,8 @@ test.group('DomainAssociation.createSchema()', () => {
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const readOnly = true
+    const onDelete: OnDeleteRule = 'restrict'
 
     const schema = DomainAssociation.createSchema({
       key,
@@ -90,6 +106,8 @@ test.group('DomainAssociation.createSchema()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(schema.key, key)
@@ -100,6 +118,8 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.deepEqual(schema.bindings, bindings)
     assert.deepEqual(schema.targets, targets)
     assert.deepEqual(schema.semantics, semantics)
+    assert.equal(schema.onDelete, onDelete)
+    assert.isTrue(schema.readOnly)
   })
 
   test('creates a schema with cloned bindings', ({ assert }) => {
@@ -145,6 +165,8 @@ test.group('DomainAssociation.constructor()', () => {
     assert.deepEqual(association.bindings, [])
     assert.deepEqual(association.targets, [])
     assert.deepEqual(association.semantics, [])
+    assert.isUndefined(association.onDelete)
+    assert.isUndefined(association.readOnly)
   })
 
   test('creates an instance with provided key', ({ assert }) => {
@@ -163,6 +185,22 @@ test.group('DomainAssociation.constructor()', () => {
     assert.deepEqual(association.semantics, semantics)
   })
 
+  test('creates an instance with provided onDelete rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const onDelete: OnDeleteRule = 'setNull'
+    const association = new DomainAssociation(dataDomain, parentKey, { onDelete })
+    assert.equal(association.onDelete, onDelete)
+  })
+
+  test('creates an instance with provided readOnly rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const readOnly = true
+    const association = new DomainAssociation(dataDomain, parentKey, { readOnly })
+    assert.isTrue(association.readOnly)
+  })
+
   test('creates an instance with provided info', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -220,6 +258,8 @@ test.group('DomainAssociation.constructor()', () => {
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const readOnly = false
+    const onDelete: OnDeleteRule = 'cascade'
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -230,6 +270,8 @@ test.group('DomainAssociation.constructor()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(association.key, key)
@@ -240,6 +282,8 @@ test.group('DomainAssociation.constructor()', () => {
     assert.deepEqual(association.bindings, bindings)
     assert.deepEqual(association.targets, targets)
     assert.deepEqual(association.semantics, semantics)
+    assert.equal(association.onDelete, onDelete)
+    assert.isFalse(association.readOnly)
   })
 
   test('creates an instance with cloned bindings', ({ assert }) => {
@@ -294,6 +338,8 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.isUndefined(json.bindings)
     assert.isUndefined(json.targets)
     assert.isUndefined(json.semantics)
+    assert.isUndefined(json.onDelete)
+    assert.isUndefined(json.readOnly)
   })
 
   test('returns a JSON representation with provided key', ({ assert }) => {
@@ -311,7 +357,25 @@ test.group('DomainAssociation.toJSON()', () => {
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
     const association = new DomainAssociation(dataDomain, parentKey, { semantics })
     const json = association.toJSON()
-    assert.deepEqual(json.semantics, semantics)
+    assert.deepEqual(json.semantics, semantics, 'Semantics are serialized')
+  })
+
+  test('returns a JSON representation with provided onDelete rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const onDelete: OnDeleteRule = 'cascade'
+    const association = new DomainAssociation(dataDomain, parentKey, { onDelete })
+    const json = association.toJSON()
+    assert.equal(json.onDelete, onDelete, 'onDelete is serialized')
+  })
+
+  test('returns a JSON representation with provided readOnly rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const readOnly = true
+    const association = new DomainAssociation(dataDomain, parentKey, { readOnly })
+    const json = association.toJSON()
+    assert.isTrue(json.readOnly, 'readOnly is serialized when true')
   })
 
   test('returns a JSON representation with provided info', ({ assert }) => {
@@ -380,6 +444,8 @@ test.group('DomainAssociation.toJSON()', () => {
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const readOnly = true
+    const onDelete: OnDeleteRule = 'restrict'
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -390,6 +456,8 @@ test.group('DomainAssociation.toJSON()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     const json = association.toJSON()
@@ -402,6 +470,8 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.deepEqual(json.bindings, bindings)
     assert.deepEqual(json.targets, targets)
     assert.deepEqual(json.semantics, semantics)
+    assert.equal(json.onDelete, onDelete)
+    assert.isTrue(json.readOnly)
   })
 
   test('returns a JSON representation with cloned bindings', ({ assert }) => {
@@ -421,7 +491,27 @@ test.group('DomainAssociation.toJSON()', () => {
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
     association.semantics = semantics
     const json = association.toJSON()
-    assert.deepEqual(json.semantics, semantics)
+    assert.deepEqual(json.semantics, semantics, 'Semantics are serialized after creation')
+  })
+
+  test('returns a JSON representation with onDelete rule when it is set after creation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const association = new DomainAssociation(dataDomain, parentKey)
+    const onDelete: OnDeleteRule = 'setNull'
+    association.onDelete = onDelete
+    const json = association.toJSON()
+    assert.equal(json.onDelete, onDelete, 'onDelete is serialized after creation')
+  })
+
+  test('returns a JSON representation with readOnly rule when it is set after creation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const association = new DomainAssociation(dataDomain, parentKey)
+    const readOnly = true
+    association.readOnly = readOnly
+    const json = association.toJSON()
+    assert.isTrue(json.readOnly, 'readOnly is serialized after creation when true')
   })
 
   test('returns a JSON representation with cloned targets', ({ assert }) => {

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

@@ -0,0 +1,149 @@
+import { test } from '@japa/runner'
+import {
+  SemanticType,
+  SemanticScope,
+  isEntitySemantic,
+  isPropertySemantic,
+  isAssociationSemantic,
+  DataSemantics,
+  type EntitySemantic,
+  type PropertySemantic,
+  type AssociationSemantic,
+  type DataSemantic,
+} from '../../../src/modeling/Semantics.js'
+
+test.group('Semantics', () => {
+  test('SemanticType enum should have correct values', ({ assert }) => {
+    assert.equal(SemanticType.User, 'https://apinow.app/semantics/entities/#User')
+    assert.equal(SemanticType.CreatedTimestamp, 'https://apinow.app/semantics/properties/#CreatedTimestamp')
+    assert.equal(SemanticType.UpdatedTimestamp, 'https://apinow.app/semantics/properties/#UpdatedTimestamp')
+    assert.equal(SemanticType.DeletedTimestamp, 'https://apinow.app/semantics/properties/#DeletedTimestamp')
+    assert.equal(SemanticType.DeletedFlag, 'https://apinow.app/semantics/properties/#DeletedFlag')
+    assert.equal(SemanticType.PublicUniqueName, 'https://apinow.app/semantics/properties/#PublicUniqueName')
+    assert.equal(SemanticType.UserRole, 'https://apinow.app/semantics/entities/#UserRole')
+    assert.equal(
+      SemanticType.ResourceOwnerIdentifier,
+      'https://apinow.app/semantics/associations/#ResourceOwnerIdentifier'
+    )
+  })
+
+  test('SemanticScope enum should have correct values', ({ assert }) => {
+    assert.equal(SemanticScope.Entity, 'Entity')
+    assert.equal(SemanticScope.Property, 'Property')
+    assert.equal(SemanticScope.Association, 'Association')
+  })
+
+  test('isEntitySemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isTrue(isEntitySemantic(entitySemantic))
+    assert.isFalse(isEntitySemantic(propertySemantic))
+    assert.isFalse(isEntitySemantic(associationSemantic))
+  })
+
+  test('isPropertySemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isFalse(isPropertySemantic(entitySemantic))
+    assert.isTrue(isPropertySemantic(propertySemantic))
+    assert.isFalse(isPropertySemantic(associationSemantic))
+  })
+
+  test('isAssociationSemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isFalse(isAssociationSemantic(entitySemantic))
+    assert.isFalse(isAssociationSemantic(propertySemantic))
+    assert.isTrue(isAssociationSemantic(associationSemantic))
+  })
+
+  test('DataSemantics should contain correct definitions', ({ assert }) => {
+    const semanticTypes = Object.values(SemanticType)
+    semanticTypes.forEach((type) => {
+      const semantic: DataSemantic | undefined = DataSemantics[type]
+      assert.isDefined(semantic, `Semantic definition for ${type} should exist`)
+      if (!semantic) return
+
+      assert.equal(semantic.id, type, `ID for ${type} should match`)
+      assert.isString(semantic.displayName, `displayName for ${type} should be a string`)
+      assert.isNotEmpty(semantic.displayName, `displayName for ${type} should not be empty`)
+      assert.isString(semantic.description, `description for ${type} should be a string`)
+      assert.isNotEmpty(semantic.description, `description for ${type} should not be empty`)
+
+      assert.oneOf(semantic.scope, Object.values(SemanticScope), `scope for ${type} should be a valid SemanticScope`)
+
+      if (isPropertySemantic(semantic)) {
+        if (semantic.applicableDataTypes) {
+          assert.isArray(semantic.applicableDataTypes, `applicableDataTypes for ${type} should be an array if present`)
+          semantic.applicableDataTypes.forEach((dt) => {
+            assert.isString(dt, `Each applicableDataType for ${type} should be a string`)
+          })
+        }
+      }
+    })
+
+    // Specific checks for some semantics
+    const userSemantic = DataSemantics[SemanticType.User]
+    assert.equal(userSemantic.scope, SemanticScope.Entity)
+
+    const createdTimestampSemantic = DataSemantics[SemanticType.CreatedTimestamp]
+    assert.equal(createdTimestampSemantic.scope, SemanticScope.Property)
+    if (isPropertySemantic(createdTimestampSemantic)) {
+      assert.deepEqual(createdTimestampSemantic.applicableDataTypes, ['datetime'])
+    }
+
+    const resourceOwnerSemantic = DataSemantics[SemanticType.ResourceOwnerIdentifier]
+    assert.equal(resourceOwnerSemantic.scope, SemanticScope.Association)
+  })
+})