@wisemen/address 0.1.1

package/lib/is-address.validator.ts

@@ -0,0 +1,82 @@
+import { Validate, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments, ValidationOptions, IsObject, ValidateNested } from 'class-validator'
+import { applyDecorators } from '@nestjs/common'
+import { Type } from 'class-transformer'
+import { AddressCommand } from './address-command.js'
+
+export interface IsAddressValidationOptions extends ValidationOptions {
+  countryRequired?: boolean
+  cityRequired?: boolean
+  postalCodeRequired?: boolean
+  streetNameRequired?: boolean
+  streetNumberRequired?: boolean
+  unitRequired?: boolean
+  coordinatesRequired?: boolean
+}
+
+export function IsAddress (
+  validationOptions?: IsAddressValidationOptions
+): PropertyDecorator {
+  return applyDecorators(
+    ValidateNested(validationOptions),
+    Type(() => AddressCommand),
+    IsObject(validationOptions),
+    Validate(
+      IsAddressValidator,
+      [{
+        countryRequired: validationOptions?.countryRequired ?? false,
+        cityRequired: validationOptions?.cityRequired ?? false,
+        postalCodeRequired: validationOptions?.postalCodeRequired ?? false,
+        streetNameRequired: validationOptions?.streetNameRequired ?? false,
+        streetNumberRequired: validationOptions?.streetNumberRequired ?? false,
+        unitRequired: validationOptions?.unitRequired ?? false,
+        coordinatesRequired: validationOptions?.coordinatesRequired ?? false
+      }],
+      validationOptions
+    )
+  )
+}
+
+interface ValidatorConstraints {
+  countryRequired: boolean
+  cityRequired: boolean
+  postalCodeRequired: boolean
+  streetNameRequired: boolean
+  streetNumberRequired: boolean
+  unitRequired: boolean
+  coordinatesRequired: boolean
+}
+
+@ValidatorConstraint({ name: 'isAddress', async: false })
+class IsAddressValidator implements ValidatorConstraintInterface {
+  validate (address: unknown, args: ValidationArguments): boolean {
+    if (!(address instanceof AddressCommand)) {
+      return false
+    }
+
+    const constraints = args.constraints[0] as ValidatorConstraints
+
+    return this.isAddressValid(address, constraints)
+  }
+
+  private isAddressValid (address: AddressCommand, constraints: ValidatorConstraints): boolean {
+    return (!constraints.countryRequired || address.country != null)
+      && (!constraints.cityRequired || address.city != null)
+      && (!constraints.postalCodeRequired || address.postalCode != null)
+      && (!constraints.streetNameRequired || address.streetName != null)
+      && (!constraints.streetNumberRequired || address.streetNumber != null)
+      && (!constraints.unitRequired || address.unit != null)
+  }
+
+  defaultMessage (args: ValidationArguments): string {
+    const constraints = args.constraints[0] as ValidatorConstraints
+    const requiredProperties: string[] = []
+
+    for (const key of Object.keys(constraints)) {
+      if (constraints[key] === true) {
+        requiredProperties.push(key)
+      }
+    }
+
+    return `${args.property}: missing ${requiredProperties.join(', ')}`
+  }
+}

package/lib/tests/address-column.integration.test.ts

@@ -0,0 +1,163 @@
+import { after, before, describe, it } from 'node:test'
+import { expect } from 'expect'
+import { Coordinates } from '@wisemen/coordinates'
+import { AddressBuilder } from '../address.builder.js'
+import { dataSource } from './sql/datasource.js'
+import { AddressTest } from './sql/address-test.entity.js'
+
+describe('AddressColumn', () => {
+  before(async () => {
+    await dataSource.initialize()
+    await dataSource.synchronize(true)
+  })
+
+  after(async () => {
+    await dataSource.destroy()
+  })
+
+  describe('serialization and deserialization', () => {
+    it('stores and retrieves a complete address with all fields', async () => {
+      const address = new AddressBuilder()
+        .withPlaceName('Main Office')
+        .withPlaceId('place123')
+        .withCountry('Belgium')
+        .withCity('Brussels')
+        .withPostalCode('1000')
+        .withStreetName('Grand Place')
+        .withStreetNumber('1')
+        .withUnit('A')
+        .withCoordinates(new Coordinates(50.8503, 4.3517))
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 1, address },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 1 })
+
+      expect(test.address).not.toBeNull()
+      expect(test.address?.placeName).toBe('Main Office')
+      expect(test.address?.placeId).toBe('place123')
+      expect(test.address?.country).toBe('Belgium')
+      expect(test.address?.city).toBe('Brussels')
+      expect(test.address?.postalCode).toBe('1000')
+      expect(test.address?.streetName).toBe('Grand Place')
+      expect(test.address?.streetNumber).toBe('1')
+      expect(test.address?.unit).toBe('A')
+      expect(test.address?.coordinates?.latitude).toBe(50.8503)
+      expect(test.address?.coordinates?.longitude).toBe(4.3517)
+    })
+
+    it('stores and retrieves an address with partial fields', async () => {
+      const address = new AddressBuilder()
+        .withCountry('Belgium')
+        .withCity('Antwerp')
+        .withPostalCode('2000')
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 2, address },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 2 })
+
+      expect(test.address).not.toBeNull()
+      expect(test.address?.country).toBe('Belgium')
+      expect(test.address?.city).toBe('Antwerp')
+      expect(test.address?.postalCode).toBe('2000')
+      expect(test.address?.streetName).toBeUndefined()
+      expect(test.address?.streetNumber).toBeUndefined()
+      expect(test.address?.unit).toBeUndefined()
+      expect(test.address?.coordinates).toBeUndefined()
+    })
+
+    it('stores and retrieves an address with coordinates only', async () => {
+      const address = new AddressBuilder()
+        .withCoordinates(new Coordinates(51.2194, 4.4025))
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 3, address },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 3 })
+
+      expect(test.address).not.toBeNull()
+      expect(test.address?.coordinates?.latitude).toBe(51.2194)
+      expect(test.address?.coordinates?.longitude).toBe(4.4025)
+      expect(test.address?.country).toBeUndefined()
+      expect(test.address?.city).toBeUndefined()
+    })
+
+    it('stores and retrieves a null address', async () => {
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 4, address: null },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 4 })
+
+      expect(test.address).toBeNull()
+    })
+
+    it('stores and retrieves an address with null coordinates', async () => {
+      const address = new AddressBuilder()
+        .withCountry('Netherlands')
+        .withCity('Amsterdam')
+        .withCoordinates(null)
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 5, address },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 5 })
+
+      expect(test.address).not.toBeNull()
+      expect(test.address?.country).toBe('Netherlands')
+      expect(test.address?.city).toBe('Amsterdam')
+      expect(test.address?.coordinates).toBeUndefined()
+    })
+
+    it('updates an existing address', async () => {
+      const initialAddress = new AddressBuilder()
+        .withCountry('France')
+        .withCity('Paris')
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 6, address: initialAddress },
+        { conflictPaths: { id: true } }
+      )
+
+      const updatedAddress = new AddressBuilder()
+        .withCountry('France')
+        .withCity('Lyon')
+        .withPostalCode('69000')
+        .build()
+
+      await dataSource.manager.upsert(
+        AddressTest,
+        { id: 6, address: updatedAddress },
+        { conflictPaths: { id: true } }
+      )
+
+      const test = await dataSource.manager.findOneByOrFail(AddressTest, { id: 6 })
+
+      expect(test.address).not.toBeNull()
+      expect(test.address?.country).toBe('France')
+      expect(test.address?.city).toBe('Lyon')
+      expect(test.address?.postalCode).toBe('69000')
+    })
+  })
+})

package/lib/tests/is-address.validator.unit.test.ts

@@ -0,0 +1,144 @@
+import { describe, it } from 'node:test'
+import { validate } from 'class-validator'
+import { expect } from 'expect'
+import { plainToInstance } from 'class-transformer'
+import { AddressCommand } from '../address-command.js'
+import { IsAddress } from '../is-address.validator.js'
+
+class TestClass {
+  @IsAddress()
+  address: AddressCommand
+}
+
+class TestClassWithRequiredFields {
+  @IsAddress({
+    countryRequired: true,
+    cityRequired: true,
+    postalCodeRequired: true,
+    streetNameRequired: true
+  })
+  address: AddressCommand
+}
+
+describe('IsAddress decorator test', () => {
+  it('should pass validation when the address has all fields', async () => {
+    const testInstance = new TestClass()
+    const addressCommand = new AddressCommand()
+
+    addressCommand.country = 'Belgium'
+    addressCommand.city = 'Brussels'
+    addressCommand.postalCode = '1000'
+    addressCommand.streetName = 'Main Street'
+    addressCommand.streetNumber = '123'
+    addressCommand.unit = null
+    addressCommand.placeName = null
+    addressCommand.placeId = null
+    addressCommand.coordinates = null
+
+    testInstance.address = addressCommand
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBe(0)
+  })
+
+  it('should pass validation when the address has only some fields', async () => {
+    const testInstance = new TestClass()
+    const addressCommand = new AddressCommand()
+
+    addressCommand.country = 'Belgium'
+    addressCommand.city = null
+    addressCommand.postalCode = null
+    addressCommand.streetName = null
+    addressCommand.streetNumber = null
+    addressCommand.unit = null
+    addressCommand.placeName = null
+    addressCommand.placeId = null
+    addressCommand.coordinates = null
+
+    testInstance.address = addressCommand
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBe(0)
+  })
+
+  it('should fail validation when required fields are missing', async () => {
+    const testInstance = new TestClassWithRequiredFields()
+    const addressCommand = new AddressCommand()
+
+    addressCommand.country = null
+    addressCommand.city = null
+    addressCommand.postalCode = null
+    addressCommand.streetName = null
+    addressCommand.streetNumber = null
+    addressCommand.unit = null
+    addressCommand.placeName = null
+    addressCommand.placeId = null
+    addressCommand.coordinates = null
+
+    testInstance.address = addressCommand
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBe(1)
+    expect(errors[0].constraints?.isAddress).toContain('countryRequired')
+    expect(errors[0].constraints?.isAddress).toContain('cityRequired')
+    expect(errors[0].constraints?.isAddress).toContain('postalCodeRequired')
+    expect(errors[0].constraints?.isAddress).toContain('streetNameRequired')
+  })
+
+  it('should pass validation when all required fields are provided', async () => {
+    const testInstance = new TestClassWithRequiredFields()
+    const addressCommand = new AddressCommand()
+
+    addressCommand.country = 'Belgium'
+    addressCommand.city = 'Brussels'
+    addressCommand.postalCode = '1000'
+    addressCommand.streetName = 'Main Street'
+    addressCommand.streetNumber = null
+    addressCommand.unit = null
+    addressCommand.placeName = null
+    addressCommand.placeId = null
+    addressCommand.coordinates = null
+
+    testInstance.address = addressCommand
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBe(0)
+  })
+
+  it('should fail validation when some required fields are missing', async () => {
+    const testInstance = new TestClassWithRequiredFields()
+    const addressCommand = new AddressCommand()
+
+    addressCommand.country = 'Belgium'
+    addressCommand.city = 'Brussels'
+    addressCommand.postalCode = null
+    addressCommand.streetName = null
+    addressCommand.streetNumber = null
+    addressCommand.unit = null
+    addressCommand.placeName = null
+    addressCommand.placeId = null
+    addressCommand.coordinates = null
+
+    testInstance.address = addressCommand
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBe(1)
+    expect(errors[0].constraints?.isAddress).toContain('postalCodeRequired')
+    expect(errors[0].constraints?.isAddress).toContain('streetNameRequired')
+  })
+
+  it('should fail validation when the address is not an AddressCommand instance', async () => {
+    const testInstance = new TestClass()
+
+    testInstance.address = plainToInstance(AddressCommand, { country: 'Belgium' })
+
+    const errors = await validate(testInstance)
+
+    expect(errors.length).toBeGreaterThan(0)
+  })
+})

package/lib/tests/sql/address-test.entity.ts

@@ -0,0 +1,12 @@
+import { Entity, PrimaryColumn } from 'typeorm'
+import { AddressColumn } from '../../address-column.js'
+import { Address } from '../../address.js'
+
+@Entity()
+export class AddressTest {
+  @PrimaryColumn()
+  id: number
+
+  @AddressColumn({nullable: true})
+  address: Address | null
+}

package/lib/tests/sql/datasource.ts

@@ -0,0 +1,15 @@
+import { DataSource } from 'typeorm'
+
+export const dataSource = new DataSource({
+  name: 'default',
+  type: 'postgres',
+  url: process.env.DATABASE_URI,
+  ssl: false,
+  extra: { max: 50 },
+  logging: true,
+  synchronize: false,
+  migrationsRun: true,
+  entities: [
+    'dist/**/*.entity.js'
+  ]
+})

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@wisemen/address",
+  "version": "0.1.1",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.ts"
+  },
+  "imports": {
+    "#*": "./lib/*"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.12",
+    "@nestjs/swagger": "^11.2.5",
+    "@wisemen/coordinates": "0.0.17",
+    "@wisemen/validators": "^0.0.19",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
+    "typeorm": "^0.3.28"
+  },
+  "devDependencies": {
+    "@wisemen/eslint-config-nestjs": "^0.2.7",
+    "eslint": "9.39.2",
+    "eslint-plugin-import-typescript": "^0.0.4",
+    "eslint-plugin-unicorn": "62.0.0",
+    "expect": "30.2.0",
+    "typescript": "^5.9.3"
+  },
+  "author": "Kobe Kwanten",
+  "license": "GPL",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:wisemen-digital/node-core.git"
+  },
+  "scripts": {
+    "prebuild": "rm -rf ./dist",
+    "clean": "rm -rf ./dist",
+    "build": "tsc",
+    "pretest": "npm run clean && npm run build",
+    "test": "node --env-file=.env.test --test ./**/*.test.js",
+    "lint": "eslint --cache",
+    "prerelease": "npm run build",
+    "release": "pnpx release-it"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "declaration": true,
+    "target": "esnext",
+    "module": "NodeNext",
+    "types": [
+      "node",
+    ],
+    "moduleResolution": "nodenext",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "strictNullChecks": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "./index.ts",
+    "./lib/**/*.ts"
+  ],
+  "exclude": [
+    "./lib/test-utils.ts",
+    "./lib/**/*.spec.ts"
+  ],
+  "ts-node": {
+    "transpileOnly": true
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./index.ts",
+      "./lib"
+    ],
+    "entryPointStrategy": "expand",
+    "out": "../../documentation/client"
+  }
+}
+