63ed3aef-04ec-416c-af7d-d56de15ebe3e

Committed 17 Mar 2026 03:48PM UTC coverage: 10.613% (-0.2%) from 10.79%

Build # 63ed3aef-04ec-416c-af7d-d56de15ebe3e

Build Type

Pull #437

circleci

Committed by

web-flow

Commit Message

Merge pull request #458 from inclusion-numerique/fix/admin-stats-min-date

fix(admin): allow filtering statistics from January 2020

Pull Request Pull Request #437: release

Coverage Stats

685 of 10426 branches covered (6.57%)

Branch coverage included in aggregate %.

34 of 590 new or added lines in 86 files covered. (5.76%)

23 existing lines in 20 files now uncovered.

2130 of 16099 relevant lines covered (13.23%)

2.0 hits per line

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

36.84

/apps/web/src/auth/getSessionUserFromSessionToken.ts

import { serializePrismaSessionUser } from '@app/web/auth/serializePrismaSessionUser'
import type { SessionUser } from '@app/web/auth/sessionUser'
import { prismaClient } from '@app/web/prismaClient'
import { registerLastSeen } from '@app/web/security/registerLastSeen'
import type { Prisma } from '@prisma/client'

export const sessionUserSelect = {
  id: true,
  email: true,
  phone: true,
  siret: true,
  firstName: true,
  lastName: true,
  name: true,
  emailVerified: true,
  image: true,
  title: true,
  location: true,
  description: true,
  created: true,
  updated: true,
  role: true,
  isFixture: true,
  profilInscription: true,
  acceptationCgu: true,
  hasSeenOnboarding: true,
  structureEmployeuseRenseignee: true,
  lieuxActiviteRenseignes: true,
  inscriptionValidee: true,
  featureFlags: true,
  timezone: true,
  isConseillerNumerique: true,
  lastSeen: true,
  emplois: {
    select: {
      id: true,
      structure: {
        select: {
          id: true,
          nom: true,
          codePostal: true,
          codeInsee: true,
          commune: true,
          modification: true,
        },
      },
    },
    where: {
      suppression: null,
      fin: null,
    },
    orderBy: {
      debut: 'desc',
    },
  },
  mediateur: {
    select: {
      id: true,
      isVisible: true,
      coordinations: {
        select: {
          coordinateur: {
            select: {
              id: true,
              mediateursCoordonnes: {
                select: {
                  id: true,
                  mediateurId: true,
                  suppression: true,
                },
                where: {
                  suppression: null,
                },
              },
              user: {
                select: {
                  name: true,
                },
              },
            },
          },
        },
      },
      _count: {
        select: {
          enActivite: { where: { suppression: null, fin: null } },
        },
      },
    },
  },
  coordinateur: {
    select: {
      id: true,
      mediateursCoordonnes: {
        select: {
          mediateurId: true,
          suppression: true,
        },
      },
    },
  },
  rdvAccount: {
    select: {
      id: true,
      created: true,
      updated: true,
      lastSynced: true,
      accessToken: true,
      refreshToken: true,
      error: true,
      syncFrom: true,
      includeRdvsInActivitesList: true,
      organisations: {
        select: {
          organisation: {
            select: {
              id: true,
              name: true,
              email: true,
            },
          },
        },
      },
      invalidWebhookOrganisationIds: true,
    },
  },
} satisfies Prisma.UserSelect

const querySessionUser = async (sessionToken: string) =>
  prismaClient.session.findFirst({
    where: {
      sessionToken,
      expires: { gt: new Date() },
      user: {
        deleted: null,
      },
    },
    include: {
      usurper: {
        select: {
          id: true,
        },
      },
      user: {
        select: sessionUserSelect,
      },
    },
  })

export type PrismaSession = Exclude<
  Awaited<ReturnType<typeof querySessionUser>>,
  null
>

export type PrismaSessionUser = PrismaSession['user']
export type PrismaSessionUsupper = PrismaSession['usurper']

export const getSessionUserFromSessionToken = async (
  sessionToken: string | null,
): Promise<SessionUser | null> => {
  if (!sessionToken) {
    return null
  }

  const res = await querySessionUser(sessionToken)

  if (!res?.user) {
    return null
  }

  registerLastSeen({ userId: res.user.id, currentLastSeen: res.user.lastSeen })

  return serializePrismaSessionUser(res.user, res.usurper)
}

export const getSessionUserFromId = async (
  userId: string,
): Promise<SessionUser> => {
  const prismaSessionUser = await prismaClient.user.findUniqueOrThrow({
    where: {
      id: userId,
    },
    select: sessionUserSelect,
  })

  return serializePrismaSessionUser(prismaSessionUser, null)
}

1	import { serializePrismaSessionUser } from '@app/web/auth/serializePrismaSessionUser'	11✔
2	import type { SessionUser } from '@app/web/auth/sessionUser'
3	import { prismaClient } from '@app/web/prismaClient'	11✔
4	import { registerLastSeen } from '@app/web/security/registerLastSeen'	11✔
5	import type { Prisma } from '@prisma/client'
6
7	export const sessionUserSelect = {	94✔
8	id: true,
9	email: true,
10	phone: true,
11	siret: true,
12	firstName: true,
13	lastName: true,
14	name: true,
15	emailVerified: true,
16	image: true,
17	title: true,
18	location: true,
19	description: true,
20	created: true,
21	updated: true,
22	role: true,
23	isFixture: true,
24	profilInscription: true,
25	acceptationCgu: true,
26	hasSeenOnboarding: true,
27	structureEmployeuseRenseignee: true,
28	lieuxActiviteRenseignes: true,
29	inscriptionValidee: true,
30	featureFlags: true,
31	timezone: true,
32	isConseillerNumerique: true,
33	lastSeen: true,
34	emplois: {
35	select: {
36	id: true,
37	structure: {
38	select: {
39	id: true,
40	nom: true,
41	codePostal: true,
42	codeInsee: true,
43	commune: true,
44	modification: true,
45	},
46	},
47	},
48	where: {
49	suppression: null,
50	fin: null,
51	},
52	orderBy: {
53	debut: 'desc',
54	},
55	},
56	mediateur: {
57	select: {
58	id: true,
59	isVisible: true,
60	coordinations: {
61	select: {
62	coordinateur: {
63	select: {
64	id: true,
65	mediateursCoordonnes: {
66	select: {
67	id: true,
68	mediateurId: true,
69	suppression: true,
70	},
71	where: {
72	suppression: null,
73	},
74	},
75	user: {
76	select: {
77	name: true,
78	},
79	},
80	},
81	},
82	},
83	},
84	_count: {
85	select: {
86	enActivite: { where: { suppression: null, fin: null } },
87	},
88	},
89	},
90	},
91	coordinateur: {
92	select: {
93	id: true,
94	mediateursCoordonnes: {
95	select: {
96	mediateurId: true,
97	suppression: true,
98	},
99	},
100	},
101	},
102	rdvAccount: {
103	select: {
104	id: true,
105	created: true,
106	updated: true,
107	lastSynced: true,
108	accessToken: true,
109	refreshToken: true,
110	error: true,
111	syncFrom: true,
112	includeRdvsInActivitesList: true,
113	organisations: {
114	select: {
115	organisation: {
116	select: {
117	id: true,
118	name: true,
119	email: true,
120	},
121	},
122	},
123	},
124	invalidWebhookOrganisationIds: true,
125	},
126	},
127	} satisfies Prisma.UserSelect
128
129	const querySessionUser = async (sessionToken: string) =>	11✔
130	prismaClient.session.findFirst({	×
131	where: {
132	sessionToken,
133	expires: { gt: new Date() },
134	user: {
135	deleted: null,
136	},
137	},
138	include: {
139	usurper: {
140	select: {
141	id: true,
142	},
143	},
144	user: {
145	select: sessionUserSelect,
146	},
147	},
148	})
149
150	export type PrismaSession = Exclude<
151	Awaited<ReturnType<typeof querySessionUser>>,
152	null
153	>
154
155	export type PrismaSessionUser = PrismaSession['user']
156	export type PrismaSessionUsupper = PrismaSession['usurper']
157
158	export const getSessionUserFromSessionToken = async (	11✔
159	sessionToken: string \| null,
160	): Promise<SessionUser \| null> => {
161	if (!sessionToken) {	×
162	return null	×
163	}
164
165	const res = await querySessionUser(sessionToken)	×
166
167	if (!res?.user) {	×
168	return null	×
169	}
170
NEW 171	registerLastSeen({ userId: res.user.id, currentLastSeen: res.user.lastSeen })	×
172
UNCOV 173	return serializePrismaSessionUser(res.user, res.usurper)	×
174	}
175
176	export const getSessionUserFromId = async (	11✔
177	userId: string,
178	): Promise<SessionUser> => {
179	const prismaSessionUser = await prismaClient.user.findUniqueOrThrow({	×
180	where: {
181	id: userId,
182	},
183	select: sessionUserSelect,
184	})
185
186	return serializePrismaSessionUser(prismaSessionUser, null)	×
187	}

inclusion-numerique / coop-mediation-numerique / 63ed3aef-04ec-416c-af7d-d56de15ebe3e

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