1b4c3b93-e3aa-4c01-adf3-472ef826aedd

Committed 31 Mar 2026 03:49PM UTC coverage: 10.62% (-0.07%) from 10.692%

Build # 1b4c3b93-e3aa-4c01-adf3-472ef826aedd

Build Type

Pull #467

circleci

Committed by

marc-gavanier

Commit Message

refactor(inscription): extract ajouterLieuxActivite into modular use-case

Refactor 174 lines of mixed logic into composable, testable functions:

- domain/types.ts: Pure type definitions
- domain/classifyLieu.ts: Pure classification logic (4 cases)
- domain/filterAlreadyLinked.ts: Pure filtering logic
- dependencies/types.ts: Injectable dependency contracts
- dependencies/prisma.ts: Production implementations
- dependencies/inMemory.ts: Test implementations (no mocks)
- strategies/processClassifiedLieu.ts: Case execution
- ajouterLieuxActivite.ts: Orchestration (~40 lines)

23 unit tests with real in-memory implementations.
Fixes issue where structures from API Entreprise were not being created.

Pull Request Pull Request #467: refactor(inscription): extract ajouterLieuxActivite into modular use-case

Coverage Stats

700 of 10544 branches covered (6.64%)

Branch coverage included in aggregate %.

0 of 161 new or added lines in 14 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

2166 of 16443 relevant lines covered (13.17%)

1.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

57.69

/apps/web/src/features/structures/findOrCreateStructure.ts

import { searchAdresse } from '@app/web/external-apis/apiAdresse'
import { banFeatureToAdresseBanData } from '@app/web/external-apis/ban/banFeatureToAdresseBanData'
import { prismaClient } from '@app/web/prismaClient'
import { toStructureFromCartoStructure } from '@app/web/structure/toStructureFromCartoStructure'
import { v4 } from 'uuid'

export type StructureInput = {
  coopId?: string | null
  siret: string | null
  nom: string
  adresse: string
  codePostal: string
  codeInsee: string
  commune: string
  // Optional fields
  nomReferent?: string | null
  courrielReferent?: string | null
  telephoneReferent?: string | null
  creationParId?: string | null
}

const undeleteStructureIfDeleted = async ({
  id,
  suppression,
}: {
  id: string
  suppression: Date | null
}) => {
  if (suppression) {
    await prismaClient.structure.update({
      where: { id },
      data: {
        suppression: null,
        suppressionParId: null,
      },
    })
  }
}

/**
 * Generic helper to find or create a structure following this hierarchy:
 * 1. Find existing Structure by SIRET + nom
 * 2. Find StructureCartographieNationale by pivot (SIRET) → create Structure from it
 * 3. Fallback: Geocode via searchAdresse (BAN API) and create
 *
 * This is reusable for both V1 imports and Dataspace imports.
 */
export const findOrCreateStructure = async ({
  coopId,
  siret,
  nom,
  adresse,
  codePostal,
  codeInsee,
  commune,
  nomReferent,
  courrielReferent,
  telephoneReferent,
  creationParId,
}: StructureInput): Promise<{ id: string }> => {
  // If coopId is provided, it is the surest way to find the structure
  if (coopId) {
    const existingStructure = await prismaClient.structure.findFirst({
      where: {
        id: coopId,
      },
      select: {
        id: true,
        suppression: true,
      },
    })
    if (existingStructure) {
      await undeleteStructureIfDeleted(existingStructure)
      return existingStructure
    }
  }

  // Step 1: Find existing Structure by SIRET + nom (only if siret is provided)
  if (siret) {
    const existingStructure = await prismaClient.structure.findFirst({
      where: {
        siret,
        codeInsee,
        suppression: null,
      },
      select: {
        id: true,
        suppression: true,
      },
      orderBy: [
        {
          suppression: {
            sort: 'desc',
            nulls: 'last',
          },
        },
        {
          creation: 'desc',
        },
      ],
    })

    if (existingStructure) {
      await undeleteStructureIfDeleted(existingStructure)
      return existingStructure
    }
  }

  // Step 2: Find StructureCartographieNationale by pivot (SIRET) - only if siret is provided
  if (siret) {
    const cartoStructure =
      await prismaClient.structureCartographieNationale.findFirst({
        where: {
          pivot: siret,
        },
      })

    if (cartoStructure) {
      // Create structure from cartographie nationale data (has coordinates)
      const structureData = toStructureFromCartoStructure(cartoStructure)

      // Override with referent info if provided
      const createdStructure = await prismaClient.structure.create({
        data: {
          ...structureData,
          nomReferent: nomReferent ?? null,
          courrielReferent: courrielReferent ?? structureData.courriels?.at(0),
          telephoneReferent: telephoneReferent ?? structureData.telephone,
          creationParId,
        },
        select: {
          id: true,
        },
      })

      return createdStructure
    }
  }

  // Step 2b: Try to find existing structure by nom if no siret
  if (!siret) {
    const existingByNom = await prismaClient.structure.findFirst({
      where: {
        nom,
        codeInsee,
      },
      select: {
        id: true,
        suppression: true,
      },
      orderBy: [
        {
          suppression: {
            sort: 'desc',
            nulls: 'last',
          },
        },
        {
          creation: 'desc',
        },
      ],
    })

    if (existingByNom) {
      await undeleteStructureIfDeleted(existingByNom)
      return existingByNom
    }
  }

  // Step 3: Fallback - geocode via BAN API and create
  const fullAdresse = `${adresse}, ${codePostal} ${commune}`
  const adresseResult = await searchAdresse(fullAdresse)

  if (adresseResult) {
    const banData = banFeatureToAdresseBanData(adresseResult)

    return prismaClient.structure.create({
      data: {
        id: v4(),
        siret,
        nom,
        adresse: banData.nom,
        commune: banData.commune,
        codePostal: banData.codePostal,
        codeInsee: banData.codeInsee,
        latitude: banData.latitude,
        longitude: banData.longitude,
        nomReferent,
        courrielReferent,
        telephoneReferent,
        creationParId,
      },
      select: {
        id: true,
      },
    })
  }

  // No geocoding result - create without coordinates
  return prismaClient.structure.create({
    data: {
      id: v4(),
      siret,
      nom,
      adresse,
      commune,
      codePostal,
      codeInsee,
      nomReferent,
      courrielReferent,
      telephoneReferent,
      creationParId,
    },
    select: {
      id: true,
    },
  })
}

1	import { searchAdresse } from '@app/web/external-apis/apiAdresse'	1✔
2	import { banFeatureToAdresseBanData } from '@app/web/external-apis/ban/banFeatureToAdresseBanData'	1✔
3	import { prismaClient } from '@app/web/prismaClient'	1✔
4	import { toStructureFromCartoStructure } from '@app/web/structure/toStructureFromCartoStructure'	1✔
5	import { v4 } from 'uuid'	1✔
6
7	export type StructureInput = {
8	coopId?: string \| null
9	siret: string \| null
10	nom: string
11	adresse: string
12	codePostal: string
13	codeInsee: string
14	commune: string
15	// Optional fields
16	nomReferent?: string \| null
17	courrielReferent?: string \| null
18	telephoneReferent?: string \| null
19	creationParId?: string \| null
20	}
21
22	const undeleteStructureIfDeleted = async ({	1✔
23	id,
24	suppression,
25	}: {
26	id: string
27	suppression: Date \| null
28	}) => {
29	if (suppression) {	7!
30	await prismaClient.structure.update({	×
31	where: { id },
32	data: {
33	suppression: null,
34	suppressionParId: null,
35	},
36	})
37	}
38	}
39
40	/**
41	* Generic helper to find or create a structure following this hierarchy:
42	* 1. Find existing Structure by SIRET + nom
43	* 2. Find StructureCartographieNationale by pivot (SIRET) → create Structure from it
44	* 3. Fallback: Geocode via searchAdresse (BAN API) and create
45	*
46	* This is reusable for both V1 imports and Dataspace imports.
47	*/
48	export const findOrCreateStructure = async ({	33✔
49	coopId,
50	siret,
51	nom,
52	adresse,
53	codePostal,
54	codeInsee,
55	commune,
56	nomReferent,
57	courrielReferent,
58	telephoneReferent,
59	creationParId,
60	}: StructureInput): Promise<{ id: string }> => {
61	// If coopId is provided, it is the surest way to find the structure
62	if (coopId) {	33✔
63	const existingStructure = await prismaClient.structure.findFirst({	31✔
64	where: {
65	id: coopId,
66	},
67	select: {
68	id: true,
69	suppression: true,
70	},
71	})
72	if (existingStructure) {	31!
73	await undeleteStructureIfDeleted(existingStructure)	×
74	return existingStructure	×
75	}
76	}
77
78	// Step 1: Find existing Structure by SIRET + nom (only if siret is provided)
79	if (siret) {	33✔
80	const existingStructure = await prismaClient.structure.findFirst({	33✔
81	where: {
82	siret,
83	codeInsee,
84	suppression: null,
85	},
86	select: {
87	id: true,
88	suppression: true,
89	},
90	orderBy: [
91	{
92	suppression: {
93	sort: 'desc',
94	nulls: 'last',
95	},
96	},
97	{
98	creation: 'desc',
99	},
100	],
101	})
102
103	if (existingStructure) {	33✔
104	await undeleteStructureIfDeleted(existingStructure)	7✔
105	return existingStructure	7✔
106	}
107	}
108
109	// Step 2: Find StructureCartographieNationale by pivot (SIRET) - only if siret is provided
110	if (siret) {	26✔
111	const cartoStructure =
112	await prismaClient.structureCartographieNationale.findFirst({	26✔
113	where: {
114	pivot: siret,
115	},
116	})
117
118	if (cartoStructure) {	26!
119	// Create structure from cartographie nationale data (has coordinates)
120	const structureData = toStructureFromCartoStructure(cartoStructure)	×
121
122	// Override with referent info if provided
123	const createdStructure = await prismaClient.structure.create({	×
124	data: {
125	...structureData,
126	nomReferent: nomReferent ?? null,	×
127	courrielReferent: courrielReferent ?? structureData.courriels?.at(0),	×
128	telephoneReferent: telephoneReferent ?? structureData.telephone,	×
129	creationParId,
130	},
131	select: {
132	id: true,
133	},
134	})
135
136	return createdStructure	×
137	}
138	}
139
140	// Step 2b: Try to find existing structure by nom if no siret
141	if (!siret) {	26!
142	const existingByNom = await prismaClient.structure.findFirst({	×
143	where: {
144	nom,
145	codeInsee,
146	},
147	select: {
148	id: true,
149	suppression: true,
150	},
151	orderBy: [
152	{
153	suppression: {
154	sort: 'desc',
155	nulls: 'last',
156	},
157	},
158	{
159	creation: 'desc',
160	},
161	],
162	})
163
164	if (existingByNom) {	×
165	await undeleteStructureIfDeleted(existingByNom)	×
166	return existingByNom	×
167	}
168	}
169
170	// Step 3: Fallback - geocode via BAN API and create
171	const fullAdresse = `${adresse}, ${codePostal} ${commune}`	26✔
172	const adresseResult = await searchAdresse(fullAdresse)	26✔
173
174	if (adresseResult) {	26✔
175	const banData = banFeatureToAdresseBanData(adresseResult)	26✔
176
177	return prismaClient.structure.create({	26✔
178	data: {
179	id: v4(),
180	siret,
181	nom,
182	adresse: banData.nom,
183	commune: banData.commune,
184	codePostal: banData.codePostal,
185	codeInsee: banData.codeInsee,
186	latitude: banData.latitude,
187	longitude: banData.longitude,
188	nomReferent,
189	courrielReferent,
190	telephoneReferent,
191	creationParId,
192	},
193	select: {
194	id: true,
195	},
196	})
197	}
198
199	// No geocoding result - create without coordinates
UNCOV 200	return prismaClient.structure.create({	×
201	data: {
202	id: v4(),
203	siret,
204	nom,
205	adresse,
206	commune,
207	codePostal,
208	codeInsee,
209	nomReferent,
210	courrielReferent,
211	telephoneReferent,
212	creationParId,
213	},
214	select: {
215	id: true,
216	},
217	})
218	}

inclusion-numerique / coop-mediation-numerique / 1b4c3b93-e3aa-4c01-adf3-472ef826aedd

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous