@api-client/core 0.15.1 → 0.16.1

package/tests/unit/modeling/definitions/sku.spec.ts

@@ -0,0 +1,240 @@
+import { test } from '@japa/runner'
+import {
+  createSKUSemantic,
+  isSKUSemantic,
+  type SKUConfig,
+  DEFAULT_SKU_CONFIG,
+  SKU_PRESETS,
+  validateSKUConfig,
+  validateSKUValue,
+} from '../../../../src/modeling/definitions/SKU.js'
+import { SemanticType, type AppliedDataSemantic } from '../../../../src/modeling/Semantics.js'
+
+test.group('SKU Semantic Configuration', () => {
+  test('should create semantic with default config', ({ assert }) => {
+    const semantic = createSKUSemantic()
+    assert.equal(semantic.id, SemanticType.SKU)
+    assert.deepEqual(semantic.config, DEFAULT_SKU_CONFIG)
+  })
+
+  test('should create semantic with custom config', ({ assert }) => {
+    const config: SKUConfig = {
+      validationMode: 'lenient',
+      caseMode: 'lowercase',
+      prefix: 'PROD-',
+      enforceUniqueness: false,
+    }
+    const semantic = createSKUSemantic(config)
+    assert.equal(semantic.id, SemanticType.SKU)
+    assert.deepEqual(semantic.config, { ...DEFAULT_SKU_CONFIG, ...config })
+  })
+
+  test('should merge metadata separately', ({ assert }) => {
+    const config: SKUConfig = {
+      metadata: { source: 'legacy-system' },
+    }
+    const semantic = createSKUSemantic(config)
+    assert.deepEqual(semantic.config?.metadata, { source: 'legacy-system' })
+  })
+
+  test('should identify SKU semantic', ({ assert }) => {
+    const semantic = createSKUSemantic()
+    assert.isTrue(isSKUSemantic(semantic))
+  })
+
+  test('should not identify non-SKU semantic', ({ assert }) => {
+    const fakeSemantic: AppliedDataSemantic = { id: SemanticType.Email, config: {} }
+    assert.isFalse(isSKUSemantic(fakeSemantic))
+  })
+
+  test('presets should be valid SKU semantics', ({ assert }) => {
+    Object.values(SKU_PRESETS).forEach((preset) => {
+      assert.isTrue(isSKUSemantic(preset))
+      assert.equal(preset.id, SemanticType.SKU)
+    })
+  })
+
+  test('PRODUCT_STANDARD preset should have correct configuration', ({ assert }) => {
+    const preset = SKU_PRESETS.PRODUCT_STANDARD
+    assert.equal(preset.config?.validationMode, 'strict')
+    assert.equal(preset.config?.caseMode, 'uppercase')
+    assert.equal(preset.config?.prefix, 'PROD-')
+    assert.equal(preset.config?.enforceUniqueness, true)
+  })
+
+  test('SIMPLE preset should have correct configuration', ({ assert }) => {
+    const preset = SKU_PRESETS.SIMPLE
+    assert.equal(preset.config?.validationMode, 'lenient')
+    assert.equal(preset.config?.caseMode, 'preserve')
+    assert.equal(preset.config?.enforceUniqueness, true)
+  })
+
+  test('AUTO_GENERATE preset should have correct configuration', ({ assert }) => {
+    const preset = SKU_PRESETS.AUTO_GENERATE
+    assert.equal(preset.config?.validationMode, 'strict')
+    assert.equal(preset.config?.caseMode, 'uppercase')
+    assert.equal(preset.config?.autoGenerate, true)
+    assert.equal(preset.config?.autoGenerateSource, 'name')
+    assert.equal(preset.config?.enforceUniqueness, true)
+  })
+
+  test('FLEXIBLE preset should have correct configuration', ({ assert }) => {
+    const preset = SKU_PRESETS.FLEXIBLE
+    assert.equal(preset.config?.validationMode, 'lenient')
+    assert.equal(preset.config?.caseMode, 'preserve')
+    assert.equal(preset.config?.enforceUniqueness, true)
+    assert.equal(preset.config?.validateReservedWords, false)
+  })
+})
+
+test.group('SKU Configuration Validation', () => {
+  test('should validate valid configuration', ({ assert }) => {
+    const config: SKUConfig = {
+      validationMode: 'strict',
+      caseMode: 'uppercase',
+    }
+    const errors = validateSKUConfig(config)
+    assert.lengthOf(errors, 0)
+  })
+
+  test('should require customPattern when validationMode is custom', ({ assert }) => {
+    const config: SKUConfig = { validationMode: 'custom' }
+    const errors = validateSKUConfig(config)
+    assert.include(errors, 'customPattern is required when validationMode is custom')
+  })
+
+  test('should validate custom pattern regex', ({ assert }) => {
+    const config: SKUConfig = { validationMode: 'custom', customPattern: '[invalid regex' }
+    const errors = validateSKUConfig(config)
+    assert.include(errors, 'customPattern must be a valid regular expression')
+  })
+
+  test('should require autoGenerate when autoGenerateSource is specified', ({ assert }) => {
+    const config: SKUConfig = { autoGenerateSource: 'name', autoGenerate: false }
+    const errors = validateSKUConfig(config)
+    assert.include(errors, 'autoGenerate must be true when autoGenerateSource is specified')
+  })
+
+  test('should accept valid custom pattern', ({ assert }) => {
+    const config: SKUConfig = { validationMode: 'custom', customPattern: '^[A-Z]{3}-\\d{3}$' }
+    const errors = validateSKUConfig(config)
+    assert.lengthOf(errors, 0)
+  })
+})
+
+test.group('SKU Value Validation', () => {
+  test('should validate valid SKU with default config', ({ assert }) => {
+    const errors = validateSKUValue('PRODUCT123')
+    assert.lengthOf(errors, 0)
+  })
+
+  test('should reject empty or null values', ({ assert }) => {
+    assert.include(validateSKUValue(''), 'SKU value must be a non-empty string')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    assert.include(validateSKUValue(null as any), 'SKU value must be a non-empty string')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    assert.include(validateSKUValue(undefined as any), 'SKU value must be a non-empty string')
+  })
+
+  test('should validate strict mode', ({ assert }) => {
+    const config: SKUConfig = { validationMode: 'strict' }
+
+    assert.lengthOf(validateSKUValue('ABC123', config), 0)
+    assert.lengthOf(validateSKUValue('ABC-123', config), 0)
+    assert.lengthOf(validateSKUValue('ABC_123', config), 0)
+    assert.include(
+      validateSKUValue('ABC.123', config),
+      'SKU can only contain alphanumeric characters, hyphens, and underscores'
+    )
+    assert.include(
+      validateSKUValue('ABC@123', config),
+      'SKU can only contain alphanumeric characters, hyphens, and underscores'
+    )
+  })
+
+  test('should validate lenient mode', ({ assert }) => {
+    const config: SKUConfig = { validationMode: 'lenient' }
+
+    assert.lengthOf(validateSKUValue('ABC123', config), 0)
+    assert.lengthOf(validateSKUValue('ABC-123', config), 0)
+    assert.lengthOf(validateSKUValue('ABC_123', config), 0)
+    assert.lengthOf(validateSKUValue('ABC.123', config), 0)
+    assert.include(validateSKUValue('ABC@123', config), 'SKU contains invalid characters')
+    assert.include(validateSKUValue('ABC#123', config), 'SKU contains invalid characters')
+  })
+
+  test('should validate custom pattern mode', ({ assert }) => {
+    const config: SKUConfig = {
+      validationMode: 'custom',
+      customPattern: '^[A-Z]{3}-\\d{3}$',
+    }
+
+    assert.lengthOf(validateSKUValue('ABC-123', config), 0)
+    assert.include(validateSKUValue('abc-123', config), 'SKU does not match the required pattern')
+    assert.include(validateSKUValue('ABCD-123', config), 'SKU does not match the required pattern')
+    assert.include(validateSKUValue('ABC-12', config), 'SKU does not match the required pattern')
+  })
+
+  test('should validate reserved words', ({ assert }) => {
+    const config: SKUConfig = {
+      validateReservedWords: true,
+      reservedValues: ['ADMIN', 'TEST', 'NULL'],
+    }
+
+    assert.include(validateSKUValue('ADMIN', config), 'SKU cannot use reserved value: ADMIN')
+    assert.include(validateSKUValue('test', config), 'SKU cannot use reserved value: test')
+    assert.include(validateSKUValue('null', config), 'SKU cannot use reserved value: null')
+    assert.lengthOf(validateSKUValue('PRODUCT', config), 0)
+  })
+
+  test('should skip reserved word validation when disabled', ({ assert }) => {
+    const config: SKUConfig = {
+      validateReservedWords: false,
+      reservedValues: ['ADMIN', 'TEST'],
+    }
+
+    assert.lengthOf(validateSKUValue('ADMIN', config), 0)
+    assert.lengthOf(validateSKUValue('TEST', config), 0)
+  })
+
+  test('should handle invalid custom pattern gracefully', ({ assert }) => {
+    const config: SKUConfig = {
+      validationMode: 'custom',
+      customPattern: '[invalid',
+    }
+
+    assert.include(validateSKUValue('ANYTHING', config), 'Invalid custom pattern configuration')
+  })
+
+  test('should validate multiple errors', ({ assert }) => {
+    const config: SKUConfig = {
+      validationMode: 'strict',
+      validateReservedWords: true,
+      reservedValues: ['TEST'],
+    }
+
+    const errors = validateSKUValue('TE$T', config)
+    assert.include(errors, 'SKU can only contain alphanumeric characters, hyphens, and underscores')
+  })
+})
+
+test.group('SKU Default Configuration', () => {
+  test('should have sensible defaults', ({ assert }) => {
+    assert.equal(DEFAULT_SKU_CONFIG.validationMode, 'strict')
+    assert.equal(DEFAULT_SKU_CONFIG.caseMode, 'uppercase')
+    assert.equal(DEFAULT_SKU_CONFIG.enforceUniqueness, true)
+    assert.equal(DEFAULT_SKU_CONFIG.autoGenerate, false)
+    assert.equal(DEFAULT_SKU_CONFIG.validateReservedWords, true)
+  })
+
+  test('should include common reserved values', ({ assert }) => {
+    const reservedValues = DEFAULT_SKU_CONFIG.reservedValues || []
+    assert.include(reservedValues, 'ADMIN')
+    assert.include(reservedValues, 'TEST')
+    assert.include(reservedValues, 'NULL')
+    assert.include(reservedValues, 'DEFAULT')
+    assert.include(reservedValues, 'UNDEFINED')
+    assert.include(reservedValues, 'SAMPLE')
+    assert.include(reservedValues, 'DEMO')
+  })
+})

package/tests/unit/modeling/definitions/status.spec.ts

@@ -0,0 +1,37 @@
+import { test } from '@japa/runner'
+import {
+  createStatusSemantic,
+  isStatusSemantic,
+  DEFAULT_STATUS_CONFIG,
+  type StatusConfig,
+} from '../../../../src/modeling/definitions/Status.js'
+import { SemanticType, type AppliedDataSemantic } from '../../../../src/modeling/Semantics.js'
+
+test.group('Status Semantic Configuration', () => {
+  test('should create semantic with default config', ({ assert }) => {
+    const semantic = createStatusSemantic()
+    assert.equal(semantic.id, SemanticType.Status)
+    assert.deepEqual(semantic.config, DEFAULT_STATUS_CONFIG)
+  })
+
+  test('should create semantic with custom config', ({ assert }) => {
+    const config: StatusConfig = {
+      allowedStates: ['active', 'inactive'],
+      defaultState: 'active',
+    }
+    const semantic = createStatusSemantic(config)
+    assert.equal(semantic.id, SemanticType.Status)
+    assert.deepEqual(semantic.config, { ...DEFAULT_STATUS_CONFIG, ...config })
+  })
+
+  test('should identify status semantic', ({ assert }) => {
+    const semantic = createStatusSemantic()
+    assert.isTrue(isStatusSemantic(semantic))
+  })
+
+  test('should not identify non-status semantic', ({ assert }) => {
+    // Simulate a different semantic
+    const fakeSemantic: AppliedDataSemantic = { id: SemanticType.Email, config: {} }
+    assert.isFalse(isStatusSemantic(fakeSemantic))
+  })
+})

package/tests/unit/modeling/definitions/summary.spec.ts

@@ -0,0 +1,36 @@
+import { test } from '@japa/runner'
+import {
+  createSummarySemantic,
+  isSummarySemantic,
+  DEFAULT_SUMMARY_CONFIG,
+  type SummaryConfig,
+} from '../../../../src/modeling/definitions/Summary.js'
+import { SemanticType, type AppliedDataSemantic } from '../../../../src/modeling/Semantics.js'
+
+test.group('Summary Semantic Configuration', () => {
+  test('should create semantic with default config', ({ assert }) => {
+    const semantic = createSummarySemantic()
+    assert.equal(semantic.id, SemanticType.Summary)
+    assert.deepEqual(semantic.config, DEFAULT_SUMMARY_CONFIG)
+  })
+
+  test('should create semantic with custom config', ({ assert }) => {
+    const config: SummaryConfig = {
+      metadata: { customField: 'value' },
+    }
+    const semantic = createSummarySemantic(config)
+    assert.equal(semantic.id, SemanticType.Summary)
+    assert.deepEqual(semantic.config, { ...DEFAULT_SUMMARY_CONFIG, ...config })
+  })
+
+  test('should identify summary semantic', ({ assert }) => {
+    const semantic = createSummarySemantic()
+    assert.isTrue(isSummarySemantic(semantic))
+  })
+
+  test('should not identify non-summary semantic', ({ assert }) => {
+    // Simulate a different semantic
+    const fakeSemantic: AppliedDataSemantic = { id: SemanticType.Email, config: {} }
+    assert.isFalse(isSummarySemantic(fakeSemantic))
+  })
+})

package/tests/unit/modeling/definitions/tags.spec.ts

@@ -0,0 +1,38 @@
+import { test } from '@japa/runner'
+import {
+  createTagsSemantic,
+  isTagsSemantic,
+  DEFAULT_TAGS_CONFIG,
+  type TagsConfig,
+} from '../../../../src/modeling/definitions/Tags.js'
+import { SemanticType, type AppliedDataSemantic } from '../../../../src/modeling/Semantics.js'
+
+test.group('Tags Semantic Configuration', () => {
+  test('should create semantic with default config', ({ assert }) => {
+    const semantic = createTagsSemantic()
+    assert.equal(semantic.id, SemanticType.Tags)
+    assert.deepEqual(semantic.config, DEFAULT_TAGS_CONFIG)
+  })
+
+  test('should create semantic with custom config', ({ assert }) => {
+    const config: TagsConfig = {
+      maxTags: 10,
+      allowCustomTags: true,
+      predefinedTags: ['urgent', 'important'],
+    }
+    const semantic = createTagsSemantic(config)
+    assert.equal(semantic.id, SemanticType.Tags)
+    assert.deepEqual(semantic.config, { ...DEFAULT_TAGS_CONFIG, ...config })
+  })
+
+  test('should identify tags semantic', ({ assert }) => {
+    const semantic = createTagsSemantic()
+    assert.isTrue(isTagsSemantic(semantic))
+  })
+
+  test('should not identify non-tags semantic', ({ assert }) => {
+    // Simulate a different semantic
+    const fakeSemantic: AppliedDataSemantic = { id: SemanticType.Email, config: {} }
+    assert.isFalse(isTagsSemantic(fakeSemantic))
+  })
+})

package/tests/unit/modeling/definitions/url.spec.ts

@@ -0,0 +1,38 @@
+import { test } from '@japa/runner'
+import {
+  createURLSemantic,
+  isURLSemantic,
+  DEFAULT_URL_CONFIG,
+  type URLConfig,
+} from '../../../../src/modeling/definitions/URL.js'
+import { SemanticType, type AppliedDataSemantic } from '../../../../src/modeling/Semantics.js'
+
+test.group('URL Semantic Configuration', () => {
+  test('should create semantic with default config', ({ assert }) => {
+    const semantic = createURLSemantic()
+    assert.equal(semantic.id, SemanticType.URL)
+    assert.deepEqual(semantic.config, DEFAULT_URL_CONFIG)
+  })
+
+  test('should create semantic with custom config', ({ assert }) => {
+    const config: URLConfig = {
+      allowedProtocols: ['https'],
+      allowedDomains: ['example.com'],
+      requireHTTPS: true,
+    }
+    const semantic = createURLSemantic(config)
+    assert.equal(semantic.id, SemanticType.URL)
+    assert.deepEqual(semantic.config, { ...DEFAULT_URL_CONFIG, ...config })
+  })
+
+  test('should identify URL semantic', ({ assert }) => {
+    const semantic = createURLSemantic()
+    assert.isTrue(isURLSemantic(semantic))
+  })
+
+  test('should not identify non-URL semantic', ({ assert }) => {
+    // Simulate a different semantic
+    const fakeSemantic: AppliedDataSemantic = { id: SemanticType.Email, config: {} }
+    assert.isFalse(isURLSemantic(fakeSemantic))
+  })
+})

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

@@ -936,3 +936,109 @@ test.group('DomainProperty.hasSemantic()', () => {
     assert.isFalse(property.hasSemantic(SemanticType.CreatedTimestamp))
   })
 })
+
+test.group('DomainProperty with GeospatialCoordinates semantic', () => {
+  test('can add GeospatialCoordinates semantic to a string property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic = { id: SemanticType.GeospatialCoordinates }
+    property.addSemantic(semantic)
+    assert.deepInclude(property.semantics, semantic)
+    assert.isTrue(property.hasSemantic(SemanticType.GeospatialCoordinates))
+  })
+
+  test('can add GeospatialCoordinates semantic with configuration', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic = {
+      id: SemanticType.GeospatialCoordinates,
+      config: { format: 'lat,lon' },
+    }
+    property.addSemantic(semantic)
+    assert.deepInclude(property.semantics, semantic)
+    assert.isTrue(property.hasSemantic(SemanticType.GeospatialCoordinates))
+  })
+
+  test('can remove GeospatialCoordinates semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic = { id: SemanticType.GeospatialCoordinates }
+    property.addSemantic(semantic)
+    assert.isTrue(property.hasSemantic(SemanticType.GeospatialCoordinates))
+
+    property.removeSemantic(SemanticType.GeospatialCoordinates)
+    assert.isFalse(property.hasSemantic(SemanticType.GeospatialCoordinates))
+    assert.lengthOf(property.semantics, 0)
+  })
+
+  test('can update existing GeospatialCoordinates semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic1 = {
+      id: SemanticType.GeospatialCoordinates,
+      config: { format: 'lat,lon' },
+    }
+    const semantic2 = {
+      id: SemanticType.GeospatialCoordinates,
+      config: { format: 'postgis' },
+    }
+
+    property.addSemantic(semantic1)
+    property.addSemantic(semantic2)
+
+    assert.lengthOf(property.semantics, 1)
+    assert.deepInclude(property.semantics, semantic2)
+    assert.isTrue(property.hasSemantic(SemanticType.GeospatialCoordinates))
+  })
+
+  test('serializes GeospatialCoordinates semantic correctly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      type: 'string',
+      semantics: [{ id: SemanticType.GeospatialCoordinates }],
+    })
+
+    const json = property.toJSON()
+    assert.deepEqual(json.semantics, [{ id: SemanticType.GeospatialCoordinates }])
+  })
+
+  test('creates schema with GeospatialCoordinates semantic', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      type: 'string',
+      semantics: [{ id: SemanticType.GeospatialCoordinates }],
+    })
+
+    assert.deepEqual(schema.semantics, [{ id: SemanticType.GeospatialCoordinates }])
+    assert.equal(schema.type, 'string')
+  })
+
+  test('constructor accepts GeospatialCoordinates semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      type: 'string',
+      semantics: [{ id: SemanticType.GeospatialCoordinates }],
+    })
+
+    assert.deepEqual(property.semantics, [{ id: SemanticType.GeospatialCoordinates }])
+    assert.isTrue(property.hasSemantic(SemanticType.GeospatialCoordinates))
+  })
+
+  test('notifies change when adding GeospatialCoordinates semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic = { id: SemanticType.GeospatialCoordinates }
+    property.addSemantic(semantic)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('notifies change when removing GeospatialCoordinates semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'string' })
+    const semantic = { id: SemanticType.GeospatialCoordinates }
+    property.addSemantic(semantic)
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    property.removeSemantic(SemanticType.GeospatialCoordinates)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})

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

@@ -70,13 +70,13 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     entity1.addProperty({ key: 'p1', type: 'string', info: { name: 'property1' } })
     entity1.addProperty({ key: 'p2', type: 'string', primary: true, info: { name: 'property2' } })
     const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity2' } })
-    const p3e2 = entity2.addProperty({ key: 'p3', type: 'number', info: { name: 'property3' } })
+    const p3e2 = entity2.addProperty({ key: 'p3', type: 'datetime', info: { name: 'property3' } })
     entity2.addProperty({ key: 'p4', type: 'string', primary: true, info: { name: 'property4' } })
-    const p5e2 = entity2.addProperty({ key: 'p5', type: 'number', info: { name: 'property5' } })
-    const p6e2 = entity2.addProperty({ key: 'p6', type: 'number', info: { name: 'property6' } })
+    const p5e2 = entity2.addProperty({ key: 'p5', type: 'datetime', info: { name: 'property5' } })
+    const p6e2 = entity2.addProperty({ key: 'p6', type: 'datetime', info: { name: 'property6' } })
     entity1.addAssociation({ key: entity2.key }, { info: { name: 'name' } })
-    const p3e1 = entity1.addProperty({ type: 'number', info: { name: 'p3e1' } })
-    const p4e1 = entity1.addProperty({ type: 'number', info: { name: 'p4e1' } })
+    const p3e1 = entity1.addProperty({ type: 'datetime', info: { name: 'p3e1' } })
+    const p4e1 = entity1.addProperty({ type: 'datetime', info: { name: 'p4e1' } })
     const p5e1 = entity1.addProperty({ type: 'boolean', info: { name: 'p5e1' } })
 
     entity1.addSemantic({ id: SemanticType.User })