Error Handling and Edge Cases

Gracefully handling errors, edge cases, and validation in Canon applications

const validEntity = {
id: 'user-123',
type: 'user',
version: 5,
createdAt: new Date('2024-01-15T10:30:00Z'),
createdBy: 'admin-456',
}

const missingFields = {
name: 'Incomplete User',
email: 'incomplete@example.com',
}

const wrongTypes = {
id: 123,
type: true,
version: 'five',
}

const nullValues = {
id: null,
version: 0,
}

const emptyObject = {}

const nonObject = 'not an object'

const nestedObject = {
user: {
  id: 'user-456',
  type: 'user',
  version: 3,
},
metadata: {
  source: 'api',
  timestamp: '2024-01-15T10:30:00Z',
},
}

handles valid entities correctly:

const id = safeIdOf(validEntity)
const type = safeTypeOf(validEntity)
const version = safeVersionOf(validEntity)

expect(id).toBe('user-123')
expect(type).toBe('user')
expect(version).toBe(5)

handles missing fields gracefully:

const id = safeIdOf(missingFields)
const type = safeTypeOf(missingFields)
const version = safeVersionOf(missingFields)

expect(id).toBeUndefined()
expect(type).toBeUndefined()
expect(version).toBeUndefined()

handles wrong field types gracefully:

const id = safeIdOf(wrongTypes)
const type = safeTypeOf(wrongTypes)
const version = safeVersionOf(wrongTypes)

expect(id).toBeUndefined()
expect(type).toBeUndefined()
// versionOf returns the actual value when it's not a number, safeVersionOf returns undefined
expect(version).toBeUndefined()

handles null and undefined values:

const id = safeIdOf(nullValues)
const type = safeTypeOf(nullValues)
const version = safeVersionOf(nullValues)

expect(id).toBeUndefined()
expect(type).toBeUndefined()
// The nullValues object has version: 0, which is a valid number, so safeVersionOf returns 0
expect(version).toBe(0)

handles empty objects:

const id = safeIdOf(emptyObject)
const type = safeTypeOf(emptyObject)
const version = safeVersionOf(emptyObject)

expect(id).toBeUndefined()
expect(type).toBeUndefined()
expect(version).toBeUndefined()

handles non-object values:

const id = safeIdOf(nonObject)
const type = safeTypeOf(nonObject)
const version = safeVersionOf(nonObject)

expect(id).toBeUndefined()
expect(type).toBeUndefined()
expect(version).toBeUndefined()

validates entities correctly:

const validResult = validateEntity(validEntity)
const invalidResult = validateEntity(missingFields)

expect(validResult.isValid).toBe(true)
expect(validResult.errors).toHaveLength(0)

expect(invalidResult.isValid).toBe(false)
expect(invalidResult.errors.length).toBeGreaterThan(0)

processes entities safely:

const validResult = processEntitySafely(validEntity)
const invalidResult = processEntitySafely(missingFields)

expect(validResult.success).toBe(true)
expect(validResult.result?.id).toBe('user-123')

expect(invalidResult.success).toBe(false)
expect(invalidResult.errors.length).toBeGreaterThan(0)

processes batch entities correctly:

const batchResult = processBatchSafely([validEntity, missingFields, wrongTypes, nullValues])

expect(batchResult.successful).toBe(1)
expect(batchResult.failed).toBe(3)
expect(batchResult.results).toHaveLength(4)

handles timestamp conversion errors:

const validTimestamp = safeTimestampConversion('2024-01-15T10:30:00Z')
const invalidTimestamp = safeTimestampConversion('not a date')

expect(validTimestamp).toBeInstanceOf(Date)
expect(invalidTimestamp).toBeUndefined()

handles reference conversion errors:

const validReference = safeReferenceConversion('user-123')
const invalidReference = safeReferenceConversion(123)

expect(validReference).toEqual({ ref: 'user-123', resolved: false })
expect(invalidReference).toBeUndefined()

---

References

Source: View on GitHub

Metadata

Keywords: error-handling, validation, edge-cases, safe-functions, robustness Difficulty: intermediate