Skip to content

The open alternative to Salesforce, designed for AI.

Add Base Adresse Nationale as an address autocomplete driver (#26176)

FC Tempilob9d0f26691dd
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/address-autocomplete-driver.factory.ts b/packages/twenty-server/src/engine/core-modules/geo-map/address-autocomplete-driver.factory.ts
new file mode 100644
index 00000000000..2c42af60305
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/address-autocomplete-driver.factory.ts
@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { type AddressAutocompleteDriver } from 'src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type';
+
+import { AddressAutocompleteBanDriver } from 'src/engine/core-modules/geo-map/drivers/ban/address-autocomplete-ban.driver';
+import { AddressAutocompleteGooglePlacesDriver } from 'src/engine/core-modules/geo-map/drivers/google-places/address-autocomplete-google-places.driver';
+import { ADDRESS_AUTOCOMPLETE_DRIVER_TYPE } from 'src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant';
+import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';
+import { DriverFactoryBase } from 'src/engine/core-modules/twenty-config/dynamic-factory.base';
+import { ConfigGroupHashService } from 'src/engine/core-modules/twenty-config/services/config-group-hash.service';
+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+
+@Injectable()
+export class AddressAutocompleteDriverFactory extends DriverFactoryBase<AddressAutocompleteDriver | null> {
+ constructor(
+ twentyConfigService: TwentyConfigService,
+ configGroupHashService: ConfigGroupHashService,
+ private readonly secureHttpClientService: SecureHttpClientService,
+ ) {
+ super(twentyConfigService, configGroupHashService);
+ }
+
+ protected buildConfigKey(): string {
+ return [
+ this.twentyConfigService.get('ADDRESS_AUTOCOMPLETE_DRIVER'),
+ this.twentyConfigService.get('GOOGLE_MAP_API_KEY'),
+ ].join('|');
+ }
+
+ protected createDriver(): AddressAutocompleteDriver {
+ const driver = this.twentyConfigService.get('ADDRESS_AUTOCOMPLETE_DRIVER');
+ const httpClient = this.secureHttpClientService.getHttpClient();
+
+ switch (driver) {
+ case ADDRESS_AUTOCOMPLETE_DRIVER_TYPE.GOOGLE_PLACES:
+ return new AddressAutocompleteGooglePlacesDriver(
+ this.twentyConfigService.get('GOOGLE_MAP_API_KEY'),
+ httpClient,
+ );
+ case ADDRESS_AUTOCOMPLETE_DRIVER_TYPE.BASE_ADRESSE_NATIONALE:
+ return new AddressAutocompleteBanDriver(httpClient);
+ default:
+ throw new Error(`Invalid address autocomplete driver: ${driver}`);
+ }
+ }
+
+ getCurrentDriver(): AddressAutocompleteDriver | null {
+ const isEnabled = this.twentyConfigService.get(
+ 'IS_MAPS_AND_ADDRESS_AUTOCOMPLETE_ENABLED',
+ );
+ const isGooglePlacesWithoutApiKey =
+ this.twentyConfigService.get('ADDRESS_AUTOCOMPLETE_DRIVER') ===
+ ADDRESS_AUTOCOMPLETE_DRIVER_TYPE.GOOGLE_PLACES &&
+ !isNonEmptyString(this.twentyConfigService.get('GOOGLE_MAP_API_KEY'));
+
+ if (!isEnabled || isGooglePlacesWithoutApiKey) {
+ return null;
+ }
+
+ return super.getCurrentDriver();
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant.ts b/packages/twenty-server/src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant.ts
new file mode 100644
index 00000000000..b520200fafb
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant.ts
@@ -0,0 +1,4 @@
+export const ADDRESS_AUTOCOMPLETE_DRIVER_TYPE = {
+ GOOGLE_PLACES: 'GOOGLE_PLACES',
+ BASE_ADRESSE_NATIONALE: 'BASE_ADRESSE_NATIONALE',
+} as const;
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/address-autocomplete-ban.driver.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/address-autocomplete-ban.driver.ts
new file mode 100644
index 00000000000..7952c27df6e
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/address-autocomplete-ban.driver.ts
@@ -0,0 +1,85 @@
+import { type AxiosInstance } from 'axios';
+import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ADDRESS_AUTOCOMPLETE_BAN_COUNTRY_CODE } from 'src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-country-code.constant';
+import {
+ type AddressAutocompleteDetailsInput,
+ type AddressAutocompleteDriver,
+ type AddressAutocompleteSuggestionsInput,
+} from 'src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type';
+import { type AddressAutocompleteBanFeature } from 'src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type';
+import { parseAddressAutocompleteBanPlaceReference } from 'src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util';
+import { buildAddressAutocompleteBanSearchParams } from 'src/engine/core-modules/geo-map/drivers/ban/utils/build-address-autocomplete-ban-search-params.util';
+import { sanitizeAddressAutocompleteBanAddressDetails } from 'src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-address-details.util';
+import { sanitizeAddressAutocompleteBanSuggestions } from 'src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-suggestions.util';
+import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
+import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
+
+const ADDRESS_AUTOCOMPLETE_BAN_SEARCH_URL =
+ 'https://data.geopf.fr/geocodage/search';
+
+export class AddressAutocompleteBanDriver implements AddressAutocompleteDriver {
+ constructor(private readonly httpClient: AxiosInstance) {}
+
+ async getSuggestions({
+ query,
+ country,
+ isCityOnly,
+ }: AddressAutocompleteSuggestionsInput): Promise<
+ GeoMapAutocompleteSanitizedResult[]
+ > {
+ if (
+ isNonEmptyString(country) &&
+ country !== ADDRESS_AUTOCOMPLETE_BAN_COUNTRY_CODE
+ ) {
+ return [];
+ }
+
+ return sanitizeAddressAutocompleteBanSuggestions(
+ await this.search({ query, isCityOnly }),
+ );
+ }
+
+ async getAddressDetails({
+ placeId,
+ }: AddressAutocompleteDetailsInput): Promise<GeoMapAddressFields> {
+ const placeReference = parseAddressAutocompleteBanPlaceReference(placeId);
+
+ if (!isDefined(placeReference)) {
+ return {};
+ }
+
+ const features = await this.search({
+ query: placeReference.label,
+ citycode: placeReference.citycode,
+ type: placeReference.type,
+ });
+ const exactMatch = features.find(
+ ({ properties }) =>
+ properties.label === placeReference.label &&
+ (!isDefined(placeReference.citycode) ||
+ properties.citycode === placeReference.citycode),
+ );
+
+ return sanitizeAddressAutocompleteBanAddressDetails(
+ exactMatch ?? features[0],
+ );
+ }
+
+ private async search(
+ searchInput: Parameters<typeof buildAddressAutocompleteBanSearchParams>[0],
+ ): Promise<AddressAutocompleteBanFeature[]> {
+ const searchParams = buildAddressAutocompleteBanSearchParams(searchInput);
+
+ if (!isDefined(searchParams)) {
+ return [];
+ }
+
+ const result = await this.httpClient.get(
+ `${ADDRESS_AUTOCOMPLETE_BAN_SEARCH_URL}?${searchParams.toString()}`,
+ );
+
+ return result.data?.features ?? [];
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-country-code.constant.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-country-code.constant.ts
new file mode 100644
index 00000000000..c597e0c06f6
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-country-code.constant.ts
@@ -0,0 +1 @@
+export const ADDRESS_AUTOCOMPLETE_BAN_COUNTRY_CODE = 'FR';
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-feature-types.constant.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-feature-types.constant.ts
new file mode 100644
index 00000000000..8a736b332dd
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-feature-types.constant.ts
@@ -0,0 +1,6 @@
+export const ADDRESS_AUTOCOMPLETE_BAN_FEATURE_TYPES = [
+ 'housenumber',
+ 'street',
+ 'locality',
+ 'municipality',
+];
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type.ts
new file mode 100644
index 00000000000..744a83ebe54
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type.ts
@@ -0,0 +1,15 @@
+export type AddressAutocompleteBanFeature = {
+ geometry?: {
+ coordinates?: [number, number];
+ };
+ properties: {
+ id: string;
+ label: string;
+ type: string;
+ name?: string;
+ postcode?: string;
+ citycode?: string;
+ city?: string;
+ context?: string;
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-place-reference.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-place-reference.type.ts
new file mode 100644
index 00000000000..07906ef07ed
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-place-reference.type.ts
@@ -0,0 +1,5 @@
+export type AddressAutocompleteBanPlaceReference = {
+ label: string;
+ citycode?: string;
+ type?: string;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/build-address-autocomplete-ban-search-params.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/build-address-autocomplete-ban-search-params.util.spec.ts
new file mode 100644
index 00000000000..89b5f9eeba0
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/build-address-autocomplete-ban-search-params.util.spec.ts
@@ -0,0 +1,52 @@
+import { buildAddressAutocompleteBanSearchParams } from 'src/engine/core-modules/geo-map/drivers/ban/utils/build-address-autocomplete-ban-search-params.util';
+
+describe('buildAddressAutocompleteBanSearchParams', () => {
+ it('builds a trimmed, limited query', () => {
+ expect(
+ buildAddressAutocompleteBanSearchParams({
+ query: ' 8 bd du port ',
+ })?.toString(),
+ ).toBe('q=8+bd+du+port&limit=5');
+ });
+
+ it('restricts results to municipalities for city fields', () => {
+ expect(
+ buildAddressAutocompleteBanSearchParams({
+ query: 'Lyo',
+ isCityOnly: true,
+ })?.get('type'),
+ ).toBe('municipality');
+ });
+
+ it.each(['', 'ab', ' ab ', '-rue de Rivoli', '"Paris'])(
+ 'skips queries the API would reject: %p',
+ (query) => {
+ expect(buildAddressAutocompleteBanSearchParams({ query })).toBeNull();
+ },
+ );
+
+ it('accepts accented first letters', () => {
+ expect(
+ buildAddressAutocompleteBanSearchParams({ query: 'Évry' })?.get('q'),
+ ).toBe('Évry');
+ });
+
+ it('caps the query at 200 characters', () => {
+ expect(
+ buildAddressAutocompleteBanSearchParams({ query: 'a'.repeat(250) })?.get(
+ 'q',
+ ),
+ ).toHaveLength(200);
+ });
+
+ it('narrows the search to one city and result type', () => {
+ const searchParams = buildAddressAutocompleteBanSearchParams({
+ query: 'Saint-Denis',
+ citycode: '93066',
+ type: 'municipality',
+ });
+
+ expect(searchParams?.get('citycode')).toBe('93066');
+ expect(searchParams?.get('type')).toBe('municipality');
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/parse-address-autocomplete-ban-place-reference.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/parse-address-autocomplete-ban-place-reference.util.spec.ts
new file mode 100644
index 00000000000..9a0230e5729
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/parse-address-autocomplete-ban-place-reference.util.spec.ts
@@ -0,0 +1,37 @@
+import { parseAddressAutocompleteBanPlaceReference } from 'src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util';
+
+describe('parseAddressAutocompleteBanPlaceReference', () => {
+ it('reads the label, city code and type', () => {
+ expect(
+ parseAddressAutocompleteBanPlaceReference(
+ 'label=Saint-Denis&citycode=93066&type=municipality',
+ ),
+ ).toEqual({
+ label: 'Saint-Denis',
+ citycode: '93066',
+ type: 'municipality',
+ });
+ });
+
+ it('accepts Corsican city codes', () => {
+ expect(
+ parseAddressAutocompleteBanPlaceReference('label=Ajaccio&citycode=2A004')
+ ?.citycode,
+ ).toBe('2A004');
+ });
+
+ it('drops a city code or type it does not recognise', () => {
+ expect(
+ parseAddressAutocompleteBanPlaceReference(
+ 'label=Paris&citycode=75056%26limit%3D100&type=anything',
+ ),
+ ).toEqual({ label: 'Paris' });
+ });
+
+ it('returns null without a label', () => {
+ expect(
+ parseAddressAutocompleteBanPlaceReference('citycode=93066'),
+ ).toBeNull();
+ expect(parseAddressAutocompleteBanPlaceReference('')).toBeNull();
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-address-details.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-address-details.util.spec.ts
new file mode 100644
index 00000000000..12b6dfcd788
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-address-details.util.spec.ts
@@ -0,0 +1,71 @@
+import { sanitizeAddressAutocompleteBanAddressDetails } from 'src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-address-details.util';
+
+const HOUSENUMBER_FEATURE = {
+ geometry: { coordinates: [2.290084, 49.897442] as [number, number] },
+ properties: {
+ id: '80021_6590_00008',
+ label: '8 Boulevard du Port 80000 Amiens',
+ type: 'housenumber',
+ name: '8 Boulevard du Port',
+ postcode: '80000',
+ city: 'Amiens',
+ context: '80, Somme, Hauts-de-France',
+ },
+};
+
+const MUNICIPALITY_FEATURE = {
+ geometry: { coordinates: [2.292605, 49.903041] as [number, number] },
+ properties: {
+ id: '80021',
+ label: 'Amiens',
+ type: 'municipality',
+ name: 'Amiens',
+ postcode: '80000',
+ city: 'Amiens',
+ context: '80, Somme, Hauts-de-France',
+ },
+};
+
+describe('sanitizeAddressAutocompleteBanAddressDetails', () => {
+ it('should return empty object when no feature is given', () => {
+ expect(sanitizeAddressAutocompleteBanAddressDetails(undefined)).toEqual({});
+ });
+
+ it('should map a housenumber feature to address fields', () => {
+ expect(
+ sanitizeAddressAutocompleteBanAddressDetails(HOUSENUMBER_FEATURE),
+ ).toEqual({
+ street: '8 Boulevard du Port',
+ city: 'Amiens',
+ postcode: '80000',
+ state: 'Hauts-de-France',
+ country: 'FR',
+ location: { lat: 49.897442, lng: 2.290084 },
+ });
+ });
+
+ it('should leave street empty for a municipality feature', () => {
+ const result =
+ sanitizeAddressAutocompleteBanAddressDetails(MUNICIPALITY_FEATURE);
+
+ expect(result.street).toBeUndefined();
+ expect(result.city).toBe('Amiens');
+ expect(result.postcode).toBe('80000');
+ expect(result.state).toBe('Hauts-de-France');
+ });
+
+ it('should omit location and state when the feature lacks them', () => {
+ const result = sanitizeAddressAutocompleteBanAddressDetails({
+ properties: {
+ id: '80021_6590_00008',
+ label: '8 Boulevard du Port 80000 Amiens',
+ type: 'housenumber',
+ name: '8 Boulevard du Port',
+ },
+ });
+
+ expect(result.location).toBeUndefined();
+ expect(result.state).toBeUndefined();
+ expect(result.country).toBe('FR');
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-suggestions.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-suggestions.util.spec.ts
new file mode 100644
index 00000000000..a6819d709a2
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/__tests__/sanitize-address-autocomplete-ban-suggestions.util.spec.ts
@@ -0,0 +1,59 @@
+import { parseAddressAutocompleteBanPlaceReference } from 'src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util';
+import { sanitizeAddressAutocompleteBanSuggestions } from 'src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-suggestions.util';
+
+const BAN_FEATURES = [
+ {
+ geometry: { coordinates: [2.290084, 49.897442] as [number, number] },
+ properties: {
+ id: '80021_6590_00008',
+ citycode: '80021',
+ label: '8 Boulevard du Port 80000 Amiens',
+ type: 'housenumber',
+ name: '8 Boulevard du Port',
+ postcode: '80000',
+ city: 'Amiens',
+ context: '80, Somme, Hauts-de-France',
+ },
+ },
+ {
+ geometry: { coordinates: [2.292605, 49.903041] as [number, number] },
+ properties: {
+ id: '80021',
+ citycode: '80021',
+ label: 'Amiens',
+ type: 'municipality',
+ name: 'Amiens',
+ postcode: '80000',
+ city: 'Amiens',
+ context: '80, Somme, Hauts-de-France',
+ },
+ },
+];
+
+describe('sanitizeAddressAutocompleteBanSuggestions', () => {
+ it('should return empty array for empty input', () => {
+ expect(sanitizeAddressAutocompleteBanSuggestions([])).toEqual([]);
+ });
+
+ it('shows the label, prefixed with the postcode for municipalities', () => {
+ expect(
+ sanitizeAddressAutocompleteBanSuggestions(BAN_FEATURES).map(
+ ({ text }) => text,
+ ),
+ ).toEqual(['8 Boulevard du Port 80000 Amiens', '80000 Amiens']);
+ });
+
+ it('encodes a place reference that parses back to the same feature', () => {
+ const [street, municipality] =
+ sanitizeAddressAutocompleteBanSuggestions(BAN_FEATURES);
+
+ expect(parseAddressAutocompleteBanPlaceReference(street.placeId)).toEqual({
+ label: '8 Boulevard du Port 80000 Amiens',
+ citycode: '80021',
+ type: 'housenumber',
+ });
+ expect(
+ parseAddressAutocompleteBanPlaceReference(municipality.placeId),
+ ).toEqual({ label: 'Amiens', citycode: '80021', type: 'municipality' });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/build-address-autocomplete-ban-search-params.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/build-address-autocomplete-ban-search-params.util.ts
new file mode 100644
index 00000000000..7a3b349b50f
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/build-address-autocomplete-ban-search-params.util.ts
@@ -0,0 +1,46 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+const MINIMUM_QUERY_LENGTH = 3;
+const MAXIMUM_QUERY_LENGTH = 200;
+const RESULTS_LIMIT = 5;
+const QUERY_FIRST_CHARACTER_REGEX = /^[\p{L}\p{N}]/u;
+
+export const buildAddressAutocompleteBanSearchParams = ({
+ query,
+ isCityOnly,
+ citycode,
+ type,
+}: {
+ query: string;
+ isCityOnly?: boolean;
+ citycode?: string;
+ type?: string;
+}): URLSearchParams | null => {
+ const trimmedQuery = query.trim().slice(0, MAXIMUM_QUERY_LENGTH);
+
+ if (
+ trimmedQuery.length < MINIMUM_QUERY_LENGTH ||
+ !QUERY_FIRST_CHARACTER_REGEX.test(trimmedQuery)
+ ) {
+ return null;
+ }
+
+ const searchParams = new URLSearchParams({
+ q: trimmedQuery,
+ limit: String(RESULTS_LIMIT),
+ });
+
+ if (isCityOnly === true) {
+ searchParams.set('type', 'municipality');
+ }
+
+ if (isNonEmptyString(type)) {
+ searchParams.set('type', type);
+ }
+
+ if (isNonEmptyString(citycode)) {
+ searchParams.set('citycode', citycode);
+ }
+
+ return searchParams;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util.ts
new file mode 100644
index 00000000000..867fd8936c6
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/parse-address-autocomplete-ban-place-reference.util.ts
@@ -0,0 +1,28 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { ADDRESS_AUTOCOMPLETE_BAN_FEATURE_TYPES } from 'src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-feature-types.constant';
+import { type AddressAutocompleteBanPlaceReference } from 'src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-place-reference.type';
+
+const CITYCODE_REGEX = /^[0-9][0-9AB][0-9]{3}$/;
+
+export const parseAddressAutocompleteBanPlaceReference = (
+ placeId: string,
+): AddressAutocompleteBanPlaceReference | null => {
+ const searchParams = new URLSearchParams(placeId);
+ const label = searchParams.get('label');
+
+ if (!isNonEmptyString(label)) {
+ return null;
+ }
+
+ const citycode = searchParams.get('citycode');
+ const type = searchParams.get('type');
+
+ return {
+ label,
+ ...(isNonEmptyString(citycode) &&
+ CITYCODE_REGEX.test(citycode) && { citycode }),
+ ...(isNonEmptyString(type) &&
+ ADDRESS_AUTOCOMPLETE_BAN_FEATURE_TYPES.includes(type) && { type }),
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-address-details.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-address-details.util.ts
new file mode 100644
index 00000000000..20ccbe5824e
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-address-details.util.ts
@@ -0,0 +1,33 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ADDRESS_AUTOCOMPLETE_BAN_COUNTRY_CODE } from 'src/engine/core-modules/geo-map/drivers/ban/constants/address-autocomplete-ban-country-code.constant';
+import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
+import { type AddressAutocompleteBanFeature } from 'src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type';
+
+const getRegionFromContext = (context?: string): string | undefined => {
+ const contextParts = context?.split(',');
+ const region = contextParts?.[contextParts.length - 1]?.trim();
+
+ return isNonEmptyString(region) ? region : undefined;
+};
+
+export const sanitizeAddressAutocompleteBanAddressDetails = (
+ feature: AddressAutocompleteBanFeature | undefined,
+): GeoMapAddressFields => {
+ if (!isDefined(feature)) {
+ return {};
+ }
+
+ const { properties, geometry } = feature;
+ const [lng, lat] = geometry?.coordinates ?? [];
+
+ return {
+ street: properties.type === 'municipality' ? undefined : properties.name,
+ city: properties.city,
+ postcode: properties.postcode,
+ state: getRegionFromContext(properties.context),
+ country: ADDRESS_AUTOCOMPLETE_BAN_COUNTRY_CODE,
+ location: isDefined(lat) && isDefined(lng) ? { lat, lng } : undefined,
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-suggestions.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-suggestions.util.ts
new file mode 100644
index 00000000000..11e42c7bb94
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/sanitize-address-autocomplete-ban-suggestions.util.ts
@@ -0,0 +1,32 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { isNonEmptyArray } from 'twenty-shared/utils';
+
+import { type AddressAutocompleteBanFeature } from 'src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type';
+import { serializeAddressAutocompleteBanPlaceReference } from 'src/engine/core-modules/geo-map/drivers/ban/utils/serialize-address-autocomplete-ban-place-reference.util';
+import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
+
+const getSuggestionText = ({
+ properties,
+}: AddressAutocompleteBanFeature): string => {
+ const isMunicipalityWithPostcode =
+ properties.type === 'municipality' && isNonEmptyString(properties.postcode);
+
+ if (isMunicipalityWithPostcode) {
+ return `${properties.postcode} ${properties.label}`;
+ }
+
+ return properties.label;
+};
+
+export const sanitizeAddressAutocompleteBanSuggestions = (
+ features: AddressAutocompleteBanFeature[],
+): GeoMapAutocompleteSanitizedResult[] => {
+ if (!isNonEmptyArray(features)) {
+ return [];
+ }
+
+ return features.map((feature) => ({
+ text: getSuggestionText(feature),
+ placeId: serializeAddressAutocompleteBanPlaceReference(feature),
+ }));
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/serialize-address-autocomplete-ban-place-reference.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/serialize-address-autocomplete-ban-place-reference.util.ts
new file mode 100644
index 00000000000..7259cdae415
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/ban/utils/serialize-address-autocomplete-ban-place-reference.util.ts
@@ -0,0 +1,19 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { type AddressAutocompleteBanFeature } from 'src/engine/core-modules/geo-map/drivers/ban/types/address-autocomplete-ban-feature.type';
+
+export const serializeAddressAutocompleteBanPlaceReference = ({
+ properties,
+}: AddressAutocompleteBanFeature): string => {
+ const searchParams = new URLSearchParams({ label: properties.label });
+
+ if (isNonEmptyString(properties.citycode)) {
+ searchParams.set('citycode', properties.citycode);
+ }
+
+ if (isNonEmptyString(properties.type)) {
+ searchParams.set('type', properties.type);
+ }
+
+ return searchParams.toString();
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/address-autocomplete-google-places.driver.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/address-autocomplete-google-places.driver.ts
new file mode 100644
index 00000000000..c4aebafad49
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/address-autocomplete-google-places.driver.ts
@@ -0,0 +1,88 @@
+import { type AxiosInstance } from 'axios';
+import { isNonEmptyString } from '@sniptt/guards';
+
+import {
+ type AddressAutocompleteDetailsInput,
+ type AddressAutocompleteDriver,
+ type AddressAutocompleteSuggestionsInput,
+} from 'src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type';
+import { sanitizeAddressAutocompleteGooglePlacesAddressDetails } from 'src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-address-details.util';
+import { sanitizeAddressAutocompleteGooglePlacesSuggestions } from 'src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-suggestions.util';
+import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
+import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
+
+const ADDRESS_AUTOCOMPLETE_GOOGLE_PLACES_API_URL =
+ 'https://maps.googleapis.com/maps/api/place';
+
+export class AddressAutocompleteGooglePlacesDriver implements AddressAutocompleteDriver {
+ constructor(
+ private readonly apiKey: string,
+ private readonly httpClient: AxiosInstance,
+ ) {}
+
+ async getSuggestions({
+ query,
+ sessionToken,
+ country,
+ isCityOnly,
+ }: AddressAutocompleteSuggestionsInput): Promise<
+ GeoMapAutocompleteSanitizedResult[]
+ > {
+ const searchParams = new URLSearchParams({
+ input: query,
+ key: this.apiKey,
+ });
+
+ if (isNonEmptyString(sessionToken)) {
+ searchParams.set('sessiontoken', sessionToken);
+ }
+
+ if (isNonEmptyString(country)) {
+ searchParams.set('components', `country:${country}`);
+ }
+
+ if (isCityOnly === true) {
+ searchParams.set('types', '(cities)');
+ }
+
+ const result = await this.httpClient.get(
+ `${ADDRESS_AUTOCOMPLETE_GOOGLE_PLACES_API_URL}/autocomplete/json?${searchParams.toString()}`,
+ );
+
+ if (result.data.status !== 'OK') {
+ return [];
+ }
+
+ return sanitizeAddressAutocompleteGooglePlacesSuggestions(
+ result.data.predictions,
+ );
+ }
+
+ async getAddressDetails({
+ placeId,
+ sessionToken,
+ }: AddressAutocompleteDetailsInput): Promise<GeoMapAddressFields> {
+ const searchParams = new URLSearchParams({
+ place_id: placeId,
+ fields: 'address_components,geometry',
+ key: this.apiKey,
+ });
+
+ if (isNonEmptyString(sessionToken)) {
+ searchParams.set('sessiontoken', sessionToken);
+ }
+
+ const result = await this.httpClient.get(
+ `${ADDRESS_AUTOCOMPLETE_GOOGLE_PLACES_API_URL}/details/json?${searchParams.toString()}`,
+ );
+
+ if (result.data.status !== 'OK') {
+ return {};
+ }
+
+ return sanitizeAddressAutocompleteGooglePlacesAddressDetails({
+ addressComponents: result.data.result?.address_components,
+ location: result.data.result?.geometry?.location,
+ });
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-address-component.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-address-component.type.ts
similarity index 50%
rename from packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-address-component.type.ts
rename to packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-address-component.type.ts
index 69436e6c7f5..530512b251d 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-address-component.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-address-component.type.ts
@@ -1,4 +1,4 @@
-export type GeoMapAddressComponent = {
+export type AddressAutocompleteGooglePlacesAddressComponent = {
long_name: string;
short_name: string;
types: string[];
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-prediction.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-prediction.type.ts
new file mode 100644
index 00000000000..8717e674053
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-prediction.type.ts
@@ -0,0 +1,4 @@
+export type AddressAutocompleteGooglePlacesPrediction = {
+ description: string;
+ place_id: string;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-place-details-results.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-address-details.util.spec.ts
similarity index 70%
rename from packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-place-details-results.util.spec.ts
rename to packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-address-details.util.spec.ts
index 142de6d9b92..e62656b8f16 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-place-details-results.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-address-details.util.spec.ts
@@ -1,39 +1,40 @@
-import { type GeoMapAddressComponent } from 'src/engine/core-modules/geo-map/types/geo-map-address-component.type';
-import { sanitizePlaceDetailsResults } from 'src/engine/core-modules/geo-map/utils/sanitize-place-details-results.util';
+import { type AddressAutocompleteGooglePlacesAddressComponent } from 'src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-address-component.type';
+import { sanitizeAddressAutocompleteGooglePlacesAddressDetails } from 'src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-address-details.util';
// Real Google Places API response for "48 Pirrama Road, Pyrmont NSW 2009, Australia"
-const GOOGLE_OFFICE_SYDNEY: GeoMapAddressComponent[] = [
- { long_name: '48', short_name: '48', types: ['street_number'] },
- {
- long_name: 'Pirrama Road',
- short_name: 'Pirrama Rd',
- types: ['route'],
- },
- {
- long_name: 'Pyrmont',
- short_name: 'Pyrmont',
- types: ['locality', 'political'],
- },
- {
- long_name: 'City of Sydney',
- short_name: 'City of Sydney',
- types: ['administrative_area_level_2', 'political'],
- },
- {
- long_name: 'New South Wales',
- short_name: 'NSW',
- types: ['administrative_area_level_1', 'political'],
- },
- {
- long_name: 'Australia',
- short_name: 'AU',
- types: ['country', 'political'],
- },
- { long_name: '2009', short_name: '2009', types: ['postal_code'] },
-];
+const GOOGLE_OFFICE_SYDNEY: AddressAutocompleteGooglePlacesAddressComponent[] =
+ [
+ { long_name: '48', short_name: '48', types: ['street_number'] },
+ {
+ long_name: 'Pirrama Road',
+ short_name: 'Pirrama Rd',
+ types: ['route'],
+ },
+ {
+ long_name: 'Pyrmont',
+ short_name: 'Pyrmont',
+ types: ['locality', 'political'],
+ },
+ {
+ long_name: 'City of Sydney',
+ short_name: 'City of Sydney',
+ types: ['administrative_area_level_2', 'political'],
+ },
+ {
+ long_name: 'New South Wales',
+ short_name: 'NSW',
+ types: ['administrative_area_level_1', 'political'],
+ },
+ {
+ long_name: 'Australia',
+ short_name: 'AU',
+ types: ['country', 'political'],
+ },
+ { long_name: '2009', short_name: '2009', types: ['postal_code'] },
+ ];
// Real Google Places API response for "111 8th Avenue, New York, NY 10011, USA"
-const NYC_ADDRESS: GeoMapAddressComponent[] = [
+const NYC_ADDRESS: AddressAutocompleteGooglePlacesAddressComponent[] = [
{ long_name: '111', short_name: '111', types: ['street_number'] },
{
long_name: '8th Avenue',
@@ -69,7 +70,7 @@ const NYC_ADDRESS: GeoMapAddressComponent[] = [
];
// UK address using postal_town (London addresses often lack locality)
-const UK_ADDRESS: GeoMapAddressComponent[] = [
+const UK_ADDRESS: AddressAutocompleteGooglePlacesAddressComponent[] = [
{ long_name: '221B', short_name: '221B', types: ['street_number'] },
{
long_name: 'Baker Street',
@@ -100,7 +101,7 @@ const UK_ADDRESS: GeoMapAddressComponent[] = [
];
// Landmark without street_number or route
-const LANDMARK: GeoMapAddressComponent[] = [
+const LANDMARK: AddressAutocompleteGooglePlacesAddressComponent[] = [
{
long_name: 'Paris',
short_name: 'Paris',
@@ -124,13 +125,17 @@ const LANDMARK: GeoMapAddressComponent[] = [
{ long_name: '75007', short_name: '75007', types: ['postal_code'] },
];
-describe('sanitizePlaceDetailsResults', () => {
+describe('sanitizeAddressAutocompleteGooglePlacesAddressDetails', () => {
it('should return empty object for empty array', () => {
- expect(sanitizePlaceDetailsResults({ addressComponents: [] })).toEqual({});
+ expect(
+ sanitizeAddressAutocompleteGooglePlacesAddressDetails({
+ addressComponents: [],
+ }),
+ ).toEqual({});
});
it('should parse a full US address (Google Sydney office)', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: GOOGLE_OFFICE_SYDNEY,
location: { lat: -33.866489, lng: 151.1958561 },
});
@@ -146,7 +151,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should parse US address with postal_code_suffix', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: NYC_ADDRESS,
});
@@ -161,7 +166,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should use postal_town as city fallback (UK address)', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: UK_ADDRESS,
});
@@ -176,7 +181,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should not set street when no street_number or route', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: LANDMARK,
});
@@ -186,7 +191,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should set street with only route (no street_number)', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'Broadway',
@@ -200,7 +205,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should use administrative_area_level_2 as state fallback', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'Some County',
@@ -214,7 +219,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should prefer administrative_area_level_1 over level_2 for state', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'Some County',
@@ -233,7 +238,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should prefer locality over postal_town for city', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'Westminster',
@@ -252,7 +257,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should use administrative_area_level_3 as city fallback', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'Small Town',
@@ -266,7 +271,7 @@ describe('sanitizePlaceDetailsResults', () => {
});
it('should use short_name for country', () => {
- const result = sanitizePlaceDetailsResults({
+ const result = sanitizeAddressAutocompleteGooglePlacesAddressDetails({
addressComponents: [
{
long_name: 'United States',
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-autocomplete-results.util.spec.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-suggestions.util.spec.ts
similarity index 69%
rename from packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-autocomplete-results.util.spec.ts
rename to packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-suggestions.util.spec.ts
index a8d3b8a6e95..1cc15815293 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/utils/__tests__/sanitize-autocomplete-results.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/__tests__/sanitize-address-autocomplete-google-places-suggestions.util.spec.ts
@@ -1,4 +1,4 @@
-import { sanitizeAutocompleteResults } from 'src/engine/core-modules/geo-map/utils/sanitize-autocomplete-results.util';
+import { sanitizeAddressAutocompleteGooglePlacesSuggestions } from 'src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-suggestions.util';
// Real Google Places Autocomplete API prediction format
const GOOGLE_PREDICTIONS = [
@@ -16,13 +16,14 @@ const GOOGLE_PREDICTIONS = [
},
];
-describe('sanitizeAutocompleteResults', () => {
+describe('sanitizeAddressAutocompleteGooglePlacesSuggestions', () => {
it('should return empty array for empty input', () => {
- expect(sanitizeAutocompleteResults([])).toEqual([]);
+ expect(sanitizeAddressAutocompleteGooglePlacesSuggestions([])).toEqual([]);
});
it('should map predictions to text and placeId', () => {
- const result = sanitizeAutocompleteResults(GOOGLE_PREDICTIONS);
+ const result =
+ sanitizeAddressAutocompleteGooglePlacesSuggestions(GOOGLE_PREDICTIONS);
expect(result).toEqual([
{
@@ -41,7 +42,9 @@ describe('sanitizeAutocompleteResults', () => {
});
it('should map a single prediction', () => {
- const result = sanitizeAutocompleteResults([GOOGLE_PREDICTIONS[0]]);
+ const result = sanitizeAddressAutocompleteGooglePlacesSuggestions([
+ GOOGLE_PREDICTIONS[0],
+ ]);
expect(result).toHaveLength(1);
expect(result[0].text).toBe('48 Pirrama Road, Pyrmont NSW 2009, Australia');
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-place-details-results.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-address-details.util.ts
similarity index 83%
rename from packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-place-details-results.util.ts
rename to packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-address-details.util.ts
index ee8ebabc72d..b4d39229c69 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-place-details-results.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-address-details.util.ts
@@ -1,19 +1,19 @@
import { isNonEmptyArray } from 'twenty-shared/utils';
-import { type GeoMapAddressComponent } from 'src/engine/core-modules/geo-map/types/geo-map-address-component.type';
+import { type AddressAutocompleteGooglePlacesAddressComponent } from 'src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-address-component.type';
import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
import { type GeoMapLocationFields } from 'src/engine/core-modules/geo-map/types/geo-map-location-fields.type';
const hasType = (
- addressComponent: GeoMapAddressComponent,
+ addressComponent: AddressAutocompleteGooglePlacesAddressComponent,
type: string,
): boolean => addressComponent.types.includes(type);
-export const sanitizePlaceDetailsResults = ({
+export const sanitizeAddressAutocompleteGooglePlacesAddressDetails = ({
addressComponents,
location,
}: {
- addressComponents: GeoMapAddressComponent[];
+ addressComponents: AddressAutocompleteGooglePlacesAddressComponent[];
location?: GeoMapLocationFields;
}): GeoMapAddressFields => {
if (!isNonEmptyArray(addressComponents)) return {};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-autocomplete-results.util.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-suggestions.util.ts
similarity index 57%
rename from packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-autocomplete-results.util.ts
rename to packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-suggestions.util.ts
index 09b9fcabcfd..9af78037d1b 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/utils/sanitize-autocomplete-results.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/google-places/utils/sanitize-address-autocomplete-google-places-suggestions.util.ts
@@ -1,10 +1,10 @@
import { isNonEmptyArray } from 'twenty-shared/utils';
import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
-import { type GeoMapGooglePrediction } from 'src/engine/core-modules/geo-map/types/geo-map-google-prediction.type';
+import { type AddressAutocompleteGooglePlacesPrediction } from 'src/engine/core-modules/geo-map/drivers/google-places/types/address-autocomplete-google-places-prediction.type';
-export const sanitizeAutocompleteResults = (
- autocompleteResults: GeoMapGooglePrediction[],
+export const sanitizeAddressAutocompleteGooglePlacesSuggestions = (
+ autocompleteResults: AddressAutocompleteGooglePlacesPrediction[],
): GeoMapAutocompleteSanitizedResult[] => {
if (!isNonEmptyArray(autocompleteResults)) return [];
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type.ts
new file mode 100644
index 00000000000..ad6a7cedab6
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/drivers/types/address-autocomplete-driver.type.ts
@@ -0,0 +1,23 @@
+import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
+import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
+
+export type AddressAutocompleteSuggestionsInput = {
+ query: string;
+ sessionToken?: string;
+ country?: string;
+ isCityOnly?: boolean;
+};
+
+export type AddressAutocompleteDetailsInput = {
+ placeId: string;
+ sessionToken?: string;
+};
+
+export type AddressAutocompleteDriver = {
+ getSuggestions(
+ input: AddressAutocompleteSuggestionsInput,
+ ): Promise<GeoMapAutocompleteSanitizedResult[]>;
+ getAddressDetails(
+ input: AddressAutocompleteDetailsInput,
+ ): Promise<GeoMapAddressFields>;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/geo-map-module.ts b/packages/twenty-server/src/engine/core-modules/geo-map/geo-map-module.ts
index d64c1388096..8adc17ff5da 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/geo-map-module.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/geo-map-module.ts
@@ -1,14 +1,21 @@
import { Module } from '@nestjs/common';
import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
+import { AddressAutocompleteDriverFactory } from 'src/engine/core-modules/geo-map/address-autocomplete-driver.factory';
import { GeoMapResolver } from 'src/engine/core-modules/geo-map/resolver/geo-map.resolver';
import { GeoMapService } from 'src/engine/core-modules/geo-map/services/geo-map.service';
import { SecureHttpClientModule } from 'src/engine/core-modules/secure-http-client/secure-http-client.module';
+import { TwentyConfigModule } from 'src/engine/core-modules/twenty-config/twenty-config.module';
import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
@Module({
- imports: [WorkspaceCacheStorageModule, TokenModule, SecureHttpClientModule],
- providers: [GeoMapService, GeoMapResolver],
+ imports: [
+ WorkspaceCacheStorageModule,
+ TokenModule,
+ SecureHttpClientModule,
+ TwentyConfigModule,
+ ],
+ providers: [AddressAutocompleteDriverFactory, GeoMapService, GeoMapResolver],
exports: [],
})
export class GeoMapModule {}
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/services/geo-map.service.ts b/packages/twenty-server/src/engine/core-modules/geo-map/services/geo-map.service.ts
index d921cb22ec3..a372216bc80 100644
--- a/packages/twenty-server/src/engine/core-modules/geo-map/services/geo-map.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/services/geo-map.service.ts
@@ -3,77 +3,46 @@ import { Injectable } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
+import { AddressAutocompleteDriverFactory } from 'src/engine/core-modules/geo-map/address-autocomplete-driver.factory';
import { type GeoMapAddressFields } from 'src/engine/core-modules/geo-map/types/geo-map-address-fields.type';
import { type GeoMapAutocompleteSanitizedResult } from 'src/engine/core-modules/geo-map/types/geo-map-autocomplete-sanitized-result.type';
-import { sanitizeAutocompleteResults } from 'src/engine/core-modules/geo-map/utils/sanitize-autocomplete-results.util';
-import { sanitizePlaceDetailsResults } from 'src/engine/core-modules/geo-map/utils/sanitize-place-details-results.util';
-import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';
-import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
@Injectable()
export class GeoMapService {
- private apiMapKey: string | undefined;
constructor(
- private readonly twentyConfigService: TwentyConfigService,
- private readonly secureHttpClientService: SecureHttpClientService,
- ) {
- if (
- !this.twentyConfigService.get(
- 'IS_MAPS_AND_ADDRESS_AUTOCOMPLETE_ENABLED',
- ) ||
- !this.twentyConfigService.get('GOOGLE_MAP_API_KEY')
- ) {
- return;
- }
- this.apiMapKey = this.twentyConfigService.get('GOOGLE_MAP_API_KEY');
- }
+ private readonly addressAutocompleteDriverFactory: AddressAutocompleteDriverFactory,
+ ) {}
public async getAutoCompleteAddress(
address: string,
token: string,
country?: string,
isFieldCity?: boolean,
- ): Promise<GeoMapAutocompleteSanitizedResult[] | undefined> {
- if (!isNonEmptyString(address?.trim())) {
- return [];
- }
-
- let url = `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${encodeURIComponent(address)}&sessiontoken=${token}&key=${this.apiMapKey}`;
+ ): Promise<GeoMapAutocompleteSanitizedResult[]> {
+ const driver = this.addressAutocompleteDriverFactory.getCurrentDriver();
- if (isNonEmptyString(country)) {
- url += `&components=country:${country}`;
- }
- if (isDefined(isFieldCity) && isFieldCity === true) {
- url += `&types=(cities)`;
- }
- const httpClient = this.secureHttpClientService.getHttpClient();
-
- const result = await httpClient.get(url);
-
- if (result.data.status === 'OK') {
- return sanitizeAutocompleteResults(result.data.predictions);
+ if (!isDefined(driver) || !isNonEmptyString(address?.trim())) {
+ return [];
}
- return [];
+ return driver.getSuggestions({
+ query: address,
+ sessionToken: token,
+ country,
+ isCityOnly: isFieldCity,
+ });
}
public async getAddressDetails(
placeId: string,
token: string,
- ): Promise<GeoMapAddressFields | undefined> {
- const httpClient = this.secureHttpClientService.getHttpClient();
-
- const result = await httpClient.get(
- `https://maps.googleapis.com/maps/api/place/details/json?place_id=${placeId}&sessiontoken=${token}&fields=address_components%2Cgeometry&key=${this.apiMapKey}`,
- );
+ ): Promise<GeoMapAddressFields> {
+ const driver = this.addressAutocompleteDriverFactory.getCurrentDriver();
- if (result.data.status === 'OK') {
- return sanitizePlaceDetailsResults({
- addressComponents: result.data.result?.address_components,
- location: result.data.result?.geometry?.location,
- });
+ if (!isDefined(driver)) {
+ return {};
}
- return {};
+ return driver.getAddressDetails({ placeId, sessionToken: token });
}
}
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/types/address-autocomplete-driver-type.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/types/address-autocomplete-driver-type.type.ts
new file mode 100644
index 00000000000..406d33121a7
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/geo-map/types/address-autocomplete-driver-type.type.ts
@@ -0,0 +1,4 @@
+import { type ADDRESS_AUTOCOMPLETE_DRIVER_TYPE } from 'src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant';
+
+export type AddressAutocompleteDriverType =
+ (typeof ADDRESS_AUTOCOMPLETE_DRIVER_TYPE)[keyof typeof ADDRESS_AUTOCOMPLETE_DRIVER_TYPE];
diff --git a/packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-google-prediction.type.ts b/packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-google-prediction.type.ts
deleted file mode 100644
index ade50b1d625..00000000000
--- a/packages/twenty-server/src/engine/core-modules/geo-map/types/geo-map-google-prediction.type.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export type GeoMapGooglePrediction = {
- description: string;
- place_id: string;
-};
diff --git a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
index 785a6f5bb7d..798021c8f4c 100644
--- a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
+++ b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
@@ -35,6 +35,8 @@ import { EmailDriver } from 'src/engine/core-modules/email/enums/email-driver.en
import { EmailingDomainDriver } from 'src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-driver.type';
import { ExceptionHandlerDriver } from 'src/engine/core-modules/exception-handler/interfaces';
import { StorageDriverType } from 'src/engine/core-modules/file-storage/interfaces';
+import { ADDRESS_AUTOCOMPLETE_DRIVER_TYPE } from 'src/engine/core-modules/geo-map/constants/address-autocomplete-driver-type.constant';
+import { type AddressAutocompleteDriverType } from 'src/engine/core-modules/geo-map/types/address-autocomplete-driver-type.type';
import {
LoggerDriverType,
type TwentyLogLevel,
@@ -2237,19 +2239,38 @@ export class ConfigVariables {
@ConfigVariablesMetadata({
group: ConfigVariablesGroup.ADVANCED_SETTINGS,
- description: 'Enable or disable google map api usage',
+ description:
+ 'Enable or disable address autocomplete (see ADDRESS_AUTOCOMPLETE_DRIVER)',
type: ConfigVariableType.BOOLEAN,
})
@IsOptional()
IS_MAPS_AND_ADDRESS_AUTOCOMPLETE_ENABLED = false;
+ @ConfigVariablesMetadata({
+ group: ConfigVariablesGroup.ADVANCED_SETTINGS,
+ description:
+ 'Address autocomplete driver: GOOGLE_PLACES (worldwide, requires GOOGLE_MAP_API_KEY) or BASE_ADRESSE_NATIONALE (French national address database, France only, no key needed)',
+ type: ConfigVariableType.ENUM,
+ options: Object.values(ADDRESS_AUTOCOMPLETE_DRIVER_TYPE),
+ })
+ @IsOptional()
+ @CastToUpperSnakeCase()
+ @IsIn(Object.values(ADDRESS_AUTOCOMPLETE_DRIVER_TYPE))
+ ADDRESS_AUTOCOMPLETE_DRIVER: AddressAutocompleteDriverType =
+ ADDRESS_AUTOCOMPLETE_DRIVER_TYPE.GOOGLE_PLACES;
+
@ConfigVariablesMetadata({
group: ConfigVariablesGroup.ADVANCED_SETTINGS,
isSensitive: true,
description: 'Google map api key for places and map',
type: ConfigVariableType.STRING,
})
- @ValidateIf((env) => env.IS_MAPS_AND_ADDRESS_AUTOCOMPLETE_ENABLED)
+ @ValidateIf(
+ (env) =>
+ env.IS_MAPS_AND_ADDRESS_AUTOCOMPLETE_ENABLED &&
+ env.ADDRESS_AUTOCOMPLETE_DRIVER ===
+ ADDRESS_AUTOCOMPLETE_DRIVER_TYPE.GOOGLE_PLACES,
+ )
GOOGLE_MAP_API_KEY: string;
@ConfigVariablesMetadata({