@tndhuy/create-app 1.0.0

package/templates/postgres/src/shared/valueobjects/date.valueobject.spec.ts

@@ -0,0 +1,40 @@
+import { DateValueObject } from './date.valueobject';
+
+describe('DateValueObject', () => {
+  it('should store and return a valid Date', () => {
+    const date = new Date('2024-01-15T10:00:00Z');
+    const vo = new DateValueObject(date);
+    expect(vo.value).toEqual(date);
+  });
+
+  it('should throw when constructed with an invalid Date (NaN time)', () => {
+    expect(() => new DateValueObject(new Date('invalid'))).toThrow(
+      'Date value must be a valid Date',
+    );
+  });
+
+  it('should throw when constructed with a non-Date value', () => {
+    expect(() => new DateValueObject('2024-01-01' as any)).toThrow(
+      'Date value must be a valid Date',
+    );
+  });
+
+  it('should throw when constructed with null', () => {
+    expect(() => new DateValueObject(null as any)).toThrow(
+      'Date value must be a valid Date',
+    );
+  });
+
+  it('should be equal to another DateValueObject with the same date value', () => {
+    const date = new Date('2024-06-01T00:00:00Z');
+    const vo1 = new DateValueObject(date);
+    const vo2 = new DateValueObject(new Date('2024-06-01T00:00:00Z'));
+    expect(vo1.equals(vo2)).toBe(true);
+  });
+
+  it('should not be equal to a DateValueObject with a different date', () => {
+    const vo1 = new DateValueObject(new Date('2024-01-01'));
+    const vo2 = new DateValueObject(new Date('2024-12-31'));
+    expect(vo1.equals(vo2)).toBe(false);
+  });
+});

package/templates/postgres/src/shared/valueobjects/date.valueobject.ts

@@ -0,0 +1,14 @@
+import { ValueObject } from '../base/value-object';
+
+export class DateValueObject extends ValueObject<{ value: Date }> {
+  constructor(value: Date) {
+    if (!(value instanceof Date) || isNaN(value.getTime())) {
+      throw new Error('Date value must be a valid Date');
+    }
+    super({ value });
+  }
+
+  get value(): Date {
+    return this.props.value;
+  }
+}

package/templates/postgres/src/shared/valueobjects/id.valueobject.spec.ts

@@ -0,0 +1,28 @@
+import { IdValueObject } from './id.valueobject';
+
+describe('IdValueObject', () => {
+  it('should store and return the id value', () => {
+    const id = new IdValueObject('abc-123');
+    expect(id.value).toBe('abc-123');
+  });
+
+  it('should throw when constructed with an empty string', () => {
+    expect(() => new IdValueObject('')).toThrow('ID must not be empty');
+  });
+
+  it('should throw when constructed with whitespace-only string', () => {
+    expect(() => new IdValueObject('   ')).toThrow('ID must not be empty');
+  });
+
+  it('should be equal to another IdValueObject with the same value', () => {
+    const id1 = new IdValueObject('abc-123');
+    const id2 = new IdValueObject('abc-123');
+    expect(id1.equals(id2)).toBe(true);
+  });
+
+  it('should not be equal to another IdValueObject with a different value', () => {
+    const id1 = new IdValueObject('abc-123');
+    const id2 = new IdValueObject('xyz-456');
+    expect(id1.equals(id2)).toBe(false);
+  });
+});

package/templates/postgres/src/shared/valueobjects/id.valueobject.ts

@@ -0,0 +1,14 @@
+import { ValueObject } from '../base/value-object';
+
+export class IdValueObject extends ValueObject<{ value: string }> {
+  constructor(value: string) {
+    if (!value || value.trim().length === 0) {
+      throw new Error('ID must not be empty');
+    }
+    super({ value });
+  }
+
+  get value(): string {
+    return this.props.value;
+  }
+}

package/templates/postgres/src/shared/valueobjects/index.ts

@@ -0,0 +1,4 @@
+export { IdValueObject } from './id.valueobject';
+export { StringValueObject } from './string.valueobject';
+export { NumberValueObject } from './number.valueobject';
+export { DateValueObject } from './date.valueobject';

package/templates/postgres/src/shared/valueobjects/number.valueobject.spec.ts

@@ -0,0 +1,48 @@
+import { NumberValueObject } from './number.valueobject';
+
+describe('NumberValueObject', () => {
+  it('should store and return the numeric value', () => {
+    const vo = new NumberValueObject(42);
+    expect(vo.value).toBe(42);
+  });
+
+  it('should store zero as a valid value', () => {
+    const vo = new NumberValueObject(0);
+    expect(vo.value).toBe(0);
+  });
+
+  it('should store negative numbers', () => {
+    const vo = new NumberValueObject(-7);
+    expect(vo.value).toBe(-7);
+  });
+
+  it('should throw when constructed with NaN', () => {
+    expect(() => new NumberValueObject(NaN)).toThrow(
+      'Number value must be a finite number',
+    );
+  });
+
+  it('should throw when constructed with Infinity', () => {
+    expect(() => new NumberValueObject(Infinity)).toThrow(
+      'Number value must be a finite number',
+    );
+  });
+
+  it('should throw when constructed with negative Infinity', () => {
+    expect(() => new NumberValueObject(-Infinity)).toThrow(
+      'Number value must be a finite number',
+    );
+  });
+
+  it('should be equal to another NumberValueObject with the same value', () => {
+    const vo1 = new NumberValueObject(99);
+    const vo2 = new NumberValueObject(99);
+    expect(vo1.equals(vo2)).toBe(true);
+  });
+
+  it('should not be equal to a NumberValueObject with a different value', () => {
+    const vo1 = new NumberValueObject(1);
+    const vo2 = new NumberValueObject(2);
+    expect(vo1.equals(vo2)).toBe(false);
+  });
+});

package/templates/postgres/src/shared/valueobjects/number.valueobject.ts

@@ -0,0 +1,14 @@
+import { ValueObject } from '../base/value-object';
+
+export class NumberValueObject extends ValueObject<{ value: number }> {
+  constructor(value: number) {
+    if (!Number.isFinite(value)) {
+      throw new Error('Number value must be a finite number');
+    }
+    super({ value });
+  }
+
+  get value(): number {
+    return this.props.value;
+  }
+}

package/templates/postgres/src/shared/valueobjects/string.valueobject.spec.ts

@@ -0,0 +1,37 @@
+import { StringValueObject } from './string.valueobject';
+
+describe('StringValueObject', () => {
+  it('should store and return the string value', () => {
+    const vo = new StringValueObject('hello');
+    expect(vo.value).toBe('hello');
+  });
+
+  it('should throw when constructed with null', () => {
+    expect(() => new StringValueObject(null as any)).toThrow(
+      'String value must not be null or undefined',
+    );
+  });
+
+  it('should throw when constructed with undefined', () => {
+    expect(() => new StringValueObject(undefined as any)).toThrow(
+      'String value must not be null or undefined',
+    );
+  });
+
+  it('should be equal to another StringValueObject with the same value', () => {
+    const vo1 = new StringValueObject('hello');
+    const vo2 = new StringValueObject('hello');
+    expect(vo1.equals(vo2)).toBe(true);
+  });
+
+  it('should not be equal to a StringValueObject with a different value', () => {
+    const vo1 = new StringValueObject('hello');
+    const vo2 = new StringValueObject('world');
+    expect(vo1.equals(vo2)).toBe(false);
+  });
+
+  it('should allow empty strings (only null/undefined are rejected)', () => {
+    const vo = new StringValueObject('');
+    expect(vo.value).toBe('');
+  });
+});

package/templates/postgres/src/shared/valueobjects/string.valueobject.ts

@@ -0,0 +1,14 @@
+import { ValueObject } from '../base/value-object';
+
+export class StringValueObject extends ValueObject<{ value: string }> {
+  constructor(value: string) {
+    if (value === null || value === undefined) {
+      throw new Error('String value must not be null or undefined');
+    }
+    super({ value });
+  }
+
+  get value(): string {
+    return this.props.value;
+  }
+}

package/templates/postgres/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/templates/postgres/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "paths": {
+      "@shared/*": ["src/shared/*"]
+    },
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noImplicitAny": false
+  },
+  "exclude": ["node_modules", "dist", "test", "packages"]
+}