Migrate to a monorepo structure (#2909)

packages/twenty-front/src/utils/__tests__/cast-as-integer-or-null.test.ts

@@ -0,0 +1,72 @@
+import {
+  canBeCastAsIntegerOrNull,
+  castAsIntegerOrNull,
+} from '../cast-as-integer-or-null';
+
+describe('canBeCastAsIntegerOrNull', () => {
+  it(`should return true if null`, () => {
+    expect(canBeCastAsIntegerOrNull(null)).toBeTruthy();
+  });
+
+  it(`should return true if number`, () => {
+    expect(canBeCastAsIntegerOrNull(9)).toBeTruthy();
+  });
+
+  it(`should return true if empty string`, () => {
+    expect(canBeCastAsIntegerOrNull('')).toBeTruthy();
+  });
+
+  it(`should return true if integer string`, () => {
+    expect(canBeCastAsIntegerOrNull('9')).toBeTruthy();
+  });
+
+  it(`should return false if undefined`, () => {
+    expect(canBeCastAsIntegerOrNull(undefined)).toBeFalsy();
+  });
+
+  it(`should return false if non numeric string`, () => {
+    expect(canBeCastAsIntegerOrNull('9a')).toBeFalsy();
+  });
+
+  it(`should return false if non numeric string #2`, () => {
+    expect(canBeCastAsIntegerOrNull('a9a')).toBeFalsy();
+  });
+
+  it(`should return false if float`, () => {
+    expect(canBeCastAsIntegerOrNull(0.9)).toBeFalsy();
+  });
+
+  it(`should return false if float string`, () => {
+    expect(canBeCastAsIntegerOrNull('0.9')).toBeFalsy();
+  });
+});
+
+describe('castAsIntegerOrNull', () => {
+  it(`should cast null to null`, () => {
+    expect(castAsIntegerOrNull(null)).toBe(null);
+  });
+
+  it(`should cast empty string to null`, () => {
+    expect(castAsIntegerOrNull('')).toBe(null);
+  });
+
+  it(`should cast an integer to an integer`, () => {
+    expect(castAsIntegerOrNull(9)).toBe(9);
+  });
+
+  it(`should cast an integer string to an integer`, () => {
+    expect(castAsIntegerOrNull('9')).toBe(9);
+  });
+
+  it(`should throw if trying to cast a float string to an integer`, () => {
+    expect(() => castAsIntegerOrNull('9.9')).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast a non numeric string to an integer`, () => {
+    expect(() => castAsIntegerOrNull('9.9a')).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast an undefined to an integer`, () => {
+    expect(() => castAsIntegerOrNull(undefined)).toThrow(Error);
+  });
+});

packages/twenty-front/src/utils/__tests__/cast-as-positive-integer-or-null.test.ts

@@ -0,0 +1,116 @@
+import {
+  canBeCastAsPositiveIntegerOrNull,
+  castAsPositiveIntegerOrNull,
+} from '~/utils/cast-as-positive-integer-or-null';
+
+describe('canBeCastAsPositiveIntegerOrNull', () => {
+  it(`should return true if null`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(null)).toBeTruthy();
+  });
+
+  it(`should return true if positive number`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(9)).toBeTruthy();
+  });
+
+  it(`should return false if negative number`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(-9)).toBeFalsy();
+  });
+
+  it(`should return true if zero`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(0)).toBeTruthy();
+  });
+
+  it(`should return true if string 0`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('0')).toBeTruthy();
+  });
+
+  it(`should return false if negative float`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(-1.22)).toBeFalsy();
+  });
+
+  it(`should return false if positive float`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(1.22)).toBeFalsy();
+  });
+
+  it(`should return false if positive float string`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('0.9')).toBeFalsy();
+  });
+
+  it(`should return false if negative float string`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('-0.9')).toBeFalsy();
+  });
+
+  it(`should return false if less than 1`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(0.22)).toBeFalsy();
+  });
+
+  it(`should return true if empty string`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('')).toBeTruthy();
+  });
+
+  it(`should return true if integer string`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('9')).toBeTruthy();
+  });
+
+  it(`should return false if undefined`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull(undefined)).toBeFalsy();
+  });
+
+  it(`should return false if non numeric string`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('9a')).toBeFalsy();
+  });
+
+  it(`should return false if non numeric string #2`, () => {
+    expect(canBeCastAsPositiveIntegerOrNull('a9a')).toBeFalsy();
+  });
+});
+
+describe('castAsPositiveIntegerOrNull', () => {
+  it(`should cast null to null`, () => {
+    expect(castAsPositiveIntegerOrNull(null)).toBe(null);
+  });
+
+  it(`should cast empty string to null`, () => {
+    expect(castAsPositiveIntegerOrNull('')).toBe(null);
+  });
+
+  it(`should cast an integer to positive integer`, () => {
+    expect(castAsPositiveIntegerOrNull(9)).toBe(9);
+  });
+
+  it(`should cast an integer string to positive integer`, () => {
+    expect(castAsPositiveIntegerOrNull('9')).toBe(9);
+  });
+
+  it(`should cast an integer to zero integer`, () => {
+    expect(castAsPositiveIntegerOrNull(0)).toBe(0);
+  });
+
+  it(`should cast an integer string to zero integer`, () => {
+    expect(castAsPositiveIntegerOrNull('0')).toBe(0);
+  });
+
+  it(`should throw if trying to cast a positive float string to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull('9.9')).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast a negative float string to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull('-9.9')).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast a positive float to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull(9.9)).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast a negative float to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull(-9.9)).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast a non numeric string to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull('9.9a')).toThrow(Error);
+  });
+
+  it(`should throw if trying to cast an undefined to positive integer`, () => {
+    expect(() => castAsPositiveIntegerOrNull(undefined)).toThrow(Error);
+  });
+});

packages/twenty-front/src/utils/__tests__/date-utils.test.ts

@@ -0,0 +1,297 @@
+import { formatDistanceToNow } from 'date-fns';
+import { DateTime } from 'luxon';
+
+import {
+  beautifyDateDiff,
+  beautifyExactDate,
+  beautifyExactDateTime,
+  beautifyPastDateAbsolute,
+  beautifyPastDateRelativeToNow,
+  DEFAULT_DATE_LOCALE,
+  hasDatePassed,
+  parseDate,
+} from '../date-utils';
+import { logError } from '../logError';
+
+jest.mock('~/utils/logError');
+jest.useFakeTimers().setSystemTime(new Date('2024-01-01T00:00:00.000Z'));
+
+describe('beautifyExactDateTime', () => {
+  it('should return the date in the correct format with time', () => {
+    const mockDate = '2023-01-01T12:13:24';
+    const actualDate = new Date(mockDate);
+    const expected = DateTime.fromJSDate(actualDate)
+      .setLocale(DEFAULT_DATE_LOCALE)
+      .toFormat('DD · T');
+
+    const result = beautifyExactDateTime(mockDate);
+    expect(result).toEqual(expected);
+  });
+  it('should return the time in the correct format for a datetime that is today', () => {
+    const todayString = DateTime.local().toISODate();
+    const mockDate = `${todayString}T12:13:24`;
+    const actualDate = new Date(mockDate);
+    const expected = DateTime.fromJSDate(actualDate)
+      .setLocale(DEFAULT_DATE_LOCALE)
+      .toFormat('T');
+
+    const result = beautifyExactDateTime(mockDate);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('beautifyExactDate', () => {
+  it('should return the past date in the correct format without time', () => {
+    const mockDate = '2023-01-01T12:13:24';
+    const actualDate = new Date(mockDate);
+    const expected = DateTime.fromJSDate(actualDate)
+      .setLocale(DEFAULT_DATE_LOCALE)
+      .toFormat('DD');
+
+    const result = beautifyExactDate(mockDate);
+    expect(result).toEqual(expected);
+  });
+  it('should return "Today" if the date is today', () => {
+    const todayString = DateTime.local().toISODate();
+    const mockDate = `${todayString}T12:13:24`;
+    const expected = 'Today';
+
+    const result = beautifyExactDate(mockDate);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('parseDate', () => {
+  it('should log an error and return empty string when passed an invalid date string', () => {
+    expect(() => {
+      parseDate('invalid-date-string');
+    }).toThrow(
+      Error('Invalid date passed to formatPastDate: "invalid-date-string"'),
+    );
+  });
+
+  it('should log an error and return empty string when passed NaN', () => {
+    expect(() => {
+      parseDate(NaN);
+    }).toThrow(Error('Invalid date passed to formatPastDate: "NaN"'));
+  });
+
+  it('should log an error and return empty string when passed invalid Date object', () => {
+    expect(() => {
+      parseDate(new Date(NaN));
+    }).toThrow(Error('Invalid date passed to formatPastDate: "Invalid Date"'));
+  });
+});
+
+describe('beautifyPastDateRelativeToNow', () => {
+  it('should return the correct relative date', () => {
+    const mockDate = '2023-01-01';
+    const actualDate = new Date(mockDate);
+    const expected = formatDistanceToNow(actualDate, { addSuffix: true });
+
+    const result = beautifyPastDateRelativeToNow(mockDate);
+    expect(result).toEqual(expected);
+  });
+
+  it('should log an error and return empty string when passed an invalid date string', () => {
+    const result = beautifyPastDateRelativeToNow('invalid-date-string');
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "invalid-date-string"'),
+    );
+    expect(result).toEqual('');
+  });
+
+  it('should log an error and return empty string when passed NaN', () => {
+    const result = beautifyPastDateRelativeToNow(NaN);
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "NaN"'),
+    );
+    expect(result).toEqual('');
+  });
+
+  it('should log an error and return empty string when passed invalid Date object', () => {
+    const result = beautifyPastDateRelativeToNow(
+      new Date('invalid-date-asdasd'),
+    );
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "Invalid Date"'),
+    );
+    expect(result).toEqual('');
+  });
+});
+
+describe('beautifyPastDateAbsolute', () => {
+  it('should log an error and return empty string when passed an invalid date string', () => {
+    const result = beautifyPastDateAbsolute('invalid-date-string');
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "invalid-date-string"'),
+    );
+    expect(result).toEqual('');
+  });
+
+  it('should log an error and return empty string when passed NaN', () => {
+    const result = beautifyPastDateAbsolute(NaN);
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "NaN"'),
+    );
+    expect(result).toEqual('');
+  });
+
+  it('should log an error and return empty string when passed invalid Date object', () => {
+    const result = beautifyPastDateAbsolute(new Date(NaN));
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "Invalid Date"'),
+    );
+    expect(result).toEqual('');
+  });
+
+  it('should return the correct format when the date difference is less than 24 hours', () => {
+    const now = DateTime.local();
+    const pastDate = now.minus({ hours: 23 });
+    const expected = pastDate.toFormat('HH:mm');
+
+    const result = beautifyPastDateAbsolute(pastDate.toJSDate());
+    expect(result).toEqual(expected);
+  });
+
+  it('should return the correct format when the date difference is less than 7 days', () => {
+    const now = DateTime.local();
+    const pastDate = now.minus({ days: 6 });
+    const expected = pastDate.toFormat('cccc - HH:mm');
+
+    const result = beautifyPastDateAbsolute(pastDate.toJSDate());
+    expect(result).toEqual(expected);
+  });
+
+  it('should return the correct format when the date difference is less than 365 days', () => {
+    const now = DateTime.local();
+    const pastDate = now.minus({ days: 364 });
+    const expected = pastDate.toFormat('MMMM d - HH:mm');
+
+    const result = beautifyPastDateAbsolute(pastDate.toJSDate());
+    expect(result).toEqual(expected);
+  });
+
+  it('should return the correct format when the date difference is more than 365 days', () => {
+    const now = DateTime.local();
+    const pastDate = now.minus({ days: 366 });
+    const expected = pastDate.toFormat('dd/MM/yyyy - HH:mm');
+
+    const result = beautifyPastDateAbsolute(pastDate.toJSDate());
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('hasDatePassed', () => {
+  it('should log an error and return false when passed an invalid date string', () => {
+    const result = hasDatePassed('invalid-date-string');
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "invalid-date-string"'),
+    );
+    expect(result).toEqual(false);
+  });
+
+  it('should log an error and return false when passed NaN', () => {
+    const result = hasDatePassed(NaN);
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "NaN"'),
+    );
+    expect(result).toEqual(false);
+  });
+
+  it('should log an error and return false when passed invalid Date object', () => {
+    const result = hasDatePassed(new Date(NaN));
+
+    expect(logError).toHaveBeenCalledWith(
+      Error('Invalid date passed to formatPastDate: "Invalid Date"'),
+    );
+    expect(result).toEqual(false);
+  });
+
+  it('should return true when passed past date', () => {
+    const now = DateTime.local();
+    const pastDate = now.minus({ day: 1 });
+
+    const result = hasDatePassed(pastDate.toJSDate());
+    expect(result).toEqual(true);
+  });
+
+  it('should return false when passed future date', () => {
+    const now = DateTime.local();
+    const futureDate = now.plus({ days: 1 });
+
+    const result = hasDatePassed(futureDate.toJSDate());
+    expect(result).toEqual(false);
+  });
+
+  it('should return false when passed current date', () => {
+    const now = DateTime.local();
+
+    const result = hasDatePassed(now.toJSDate());
+    expect(result).toEqual(false);
+  });
+});
+
+describe('beautifyDateDiff', () => {
+  it('should return the correct date diff', () => {
+    const date = '2023-11-05T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('4 days');
+  });
+  it('should return the correct date diff for large diff', () => {
+    const date = '2033-11-05T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('10 years and 4 days');
+  });
+  it('should return the correct date for negative diff', () => {
+    const date = '2013-11-05T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('-9 years and -361 days');
+  });
+  it('should return the correct date diff for large diff', () => {
+    const date = '2033-11-01T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('10 years');
+  });
+  it('should return the proper english date diff', () => {
+    const date = '2024-11-02T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('1 year and 1 day');
+  });
+  it('should round date diff', () => {
+    const date = '2024-11-03T14:04:43.421Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith);
+    expect(result).toEqual('1 year and 2 days');
+  });
+  it('should compare to now', () => {
+    const date = '2027-01-10T00:00:00.000Z';
+    const result = beautifyDateDiff(date);
+    expect(result).toEqual('3 years and 9 days');
+  });
+  it('should return short version', () => {
+    const date = '2033-11-05T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith, true);
+    expect(result).toEqual('10 years');
+  });
+  it('should return short version for short differences', () => {
+    const date = '2023-11-05T00:00:00.000Z';
+    const dateToCompareWith = '2023-11-01T00:00:00.000Z';
+    const result = beautifyDateDiff(date, dateToCompareWith, true);
+    expect(result).toEqual('4 days');
+  });
+});

packages/twenty-front/src/utils/__tests__/is-domain.test.ts

@@ -0,0 +1,35 @@
+import { isDomain } from '~/utils/is-domain';
+
+describe('isDomain', () => {
+  it(`should return false if null`, () => {
+    expect(isDomain(null)).toBeFalsy();
+  });
+
+  it(`should return false if undefined`, () => {
+    expect(isDomain(undefined)).toBeFalsy();
+  });
+
+  it(`should return true if string google`, () => {
+    expect(isDomain('google')).toBeFalsy();
+  });
+
+  it(`should return true if string google.com`, () => {
+    expect(isDomain('google.com')).toBeTruthy();
+  });
+
+  it(`should return true if string bbc.co.uk`, () => {
+    expect(isDomain('bbc.co.uk')).toBeTruthy();
+  });
+
+  it(`should return true if string web.io`, () => {
+    expect(isDomain('web.io')).toBeTruthy();
+  });
+
+  it(`should return true if string x.com`, () => {
+    expect(isDomain('x.com')).toBeTruthy();
+  });
+
+  it(`should return true if string 2.com`, () => {
+    expect(isDomain('2.com')).toBeTruthy();
+  });
+});

packages/twenty-front/src/utils/__tests__/is-url.test.ts

@@ -0,0 +1,62 @@
+import { isURL } from '~/utils/is-url';
+
+describe('isURL', () => {
+  it(`should return false if null`, () => {
+    expect(isURL(null)).toBeFalsy();
+  });
+
+  it(`should return false if undefined`, () => {
+    expect(isURL(undefined)).toBeFalsy();
+  });
+
+  it(`should return true if string google`, () => {
+    expect(isURL('google')).toBeFalsy();
+  });
+
+  it(`should return true if string google.com`, () => {
+    expect(isURL('google.com')).toBeTruthy();
+  });
+
+  it(`should return true if string bbc.co.uk`, () => {
+    expect(isURL('bbc.co.uk')).toBeTruthy();
+  });
+
+  it(`should return true if string web.io`, () => {
+    expect(isURL('web.io')).toBeTruthy();
+  });
+
+  it(`should return true if string x.com`, () => {
+    expect(isURL('x.com')).toBeTruthy();
+  });
+
+  it(`should return true if string 2.com`, () => {
+    expect(isURL('2.com')).toBeTruthy();
+  });
+
+  it(`should return true if string https://2.com/test/`, () => {
+    expect(isURL('https://2.com/test/')).toBeTruthy();
+  });
+
+  it(`should return true if string is https://www.linkedin.com/company/b%C3%B6ke-&-partner-sdft-partmbb/`, () => {
+    expect(
+      isURL(
+        'https://www.linkedin.com/company/b%C3%B6ke-&-partner-sdft-partmbb/',
+      ),
+    ).toBeTruthy();
+  });
+
+  it('should return true if the TLD is long', () => {
+    expect(isURL('https://example.travelinsurance')).toBeTruthy();
+  });
+
+  it('should return true if the TLD is internationalized', () => {
+    // The longest TLD as of now
+    // https://stackoverflow.com/questions/9238640/how-long-can-a-tld-possibly-be
+    // curl -s http://data.iana.org/TLD/tlds-alpha-by-domain.txt \
+    //   | tail -n+2 \
+    //   | awk '{ print length, $0 }' \
+    //   | sort --numeric-sort --reverse \
+    //   | head -n 5
+    expect(isURL('https://example.xn--vermgensberatung-pwb')).toBeTruthy();
+  });
+});

packages/twenty-front/src/utils/__tests__/utils.test.ts

@@ -0,0 +1,49 @@
+import { getLogoUrlFromDomainName, sanitizeURL } from '..';
+
+describe('sanitizeURL', () => {
+  test('should sanitize the URL correctly', () => {
+    expect(sanitizeURL('http://example.com/')).toBe('example.com');
+    expect(sanitizeURL('https://www.example.com/')).toBe('example.com');
+    expect(sanitizeURL('www.example.com')).toBe('example.com');
+    expect(sanitizeURL('example.com')).toBe('example.com');
+    expect(sanitizeURL('example.com/')).toBe('example.com');
+  });
+
+  test('should handle undefined input', () => {
+    expect(sanitizeURL(undefined)).toBe('');
+  });
+});
+
+describe('getLogoUrlFromDomainName', () => {
+  test('should return the correct logo URL for a given domain', () => {
+    expect(getLogoUrlFromDomainName('example.com')).toBe(
+      'https://favicon.twenty.com/example.com',
+    );
+
+    expect(getLogoUrlFromDomainName('http://example.com/')).toBe(
+      'https://favicon.twenty.com/example.com',
+    );
+
+    expect(getLogoUrlFromDomainName('https://www.example.com/')).toBe(
+      'https://favicon.twenty.com/example.com',
+    );
+
+    expect(getLogoUrlFromDomainName('www.example.com')).toBe(
+      'https://favicon.twenty.com/example.com',
+    );
+
+    expect(getLogoUrlFromDomainName('example.com/')).toBe(
+      'https://favicon.twenty.com/example.com',
+    );
+
+    expect(getLogoUrlFromDomainName('apple.com')).toBe(
+      'https://favicon.twenty.com/apple.com',
+    );
+  });
+
+  test('should handle undefined input', () => {
+    expect(getLogoUrlFromDomainName(undefined)).toBe(
+      'https://favicon.twenty.com/',
+    );
+  });
+});