134f1cc8-b272-471e-be1c-25fe3b4baafa

Committed 17 Mar 2026 04:15PM UTC coverage: 6.94% (-3.9%) from 10.79%

Build # 134f1cc8-b272-471e-be1c-25fe3b4baafa

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #437 from inclusion-numerique/dev

release

Coverage Stats

470 of 10426 branches covered (4.51%)

Branch coverage included in aggregate %.

28 of 584 new or added lines in 86 files covered. (4.79%)

1348 existing lines in 161 files now uncovered.

1355 of 15871 relevant lines covered (8.54%)

37.74 hits per line

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

0.0

/apps/web/src/api-client/apiClient.ts

import { prismaClient } from '@app/web/prismaClient'
import { generateRandomSecret } from '@app/web/security/generateRandomSecret'
import { hashSecret, verifySecret } from '@app/web/security/hashSecret'
import { ApiClient, ApiClientScope } from '@prisma/client'

export type CreateApiClientInput = {
  id?: string
  name: string
  scopes: ApiClientScope[]
  validUntil?: Date
  validFrom?: Date
}

export const createApiClient = async ({
  id,
  name,
  scopes,
  validFrom,
  validUntil,
}: CreateApiClientInput): Promise<
  ApiClient & {
    secret: string
  }
> => {
  const secret = generateRandomSecret()
  const secretHash = hashSecret(secret)

  const apiClient = await prismaClient.apiClient.create({
    data: {
      id,
      name,
      secretHash, // Store the hashed secret in the database
      validFrom: validFrom ?? new Date(),
      validUntil,
      scopes,
    },
  })

  return {
    ...apiClient,
    secret,
    secretHash,
  }
}

export type CreateApiClientOutput = Awaited<ReturnType<typeof createApiClient>>

export const rotateApiClientSecret = async ({
  clientId,
}: {
  clientId: string
}) => {
  const secret = generateRandomSecret()
  const secretHash = hashSecret(secret)

  await prismaClient.apiClient.update({
    where: { id: clientId },
    data: {
      secretHash, // Store the hashed secret in the database
      updated: new Date(),
    },
  })

  return {
    clientId,
    secret,
    secretHash,
  }
}

export const changeApiClientScopes = async ({
  clientId,
  scopes,
}: {
  clientId: string
  scopes: ApiClientScope[]
}) => {
  const apiClient = await prismaClient.apiClient.findUnique({
    where: { id: clientId },
  })

  if (!apiClient) {
    throw new Error('Api client not found')
  }

  await prismaClient.apiClient.update({
    where: { id: clientId },
    data: {
      scopes,
      updated: new Date(),
    },
  })
}

export const authenticateApiCient = async (
  clientId: string,
  clientSecret: string,
): Promise<ApiClient | null> => {
  // Ensure that clientId is a uuid v4 using regex
  if (!/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/.test(clientId)) return null

  const apiClient = await prismaClient.apiClient.findUnique({
    where: { id: clientId },
  })

  if (!apiClient) return null

  const isValid = verifySecret(clientSecret, apiClient.secretHash)

  if (!isValid) return null

  const now = new Date()

  if (apiClient.validFrom > now) return null

  if (!!apiClient.validUntil && apiClient.validUntil < now) {
    return null
  }

  return apiClient
}

1	import { prismaClient } from '@app/web/prismaClient'
2	import { generateRandomSecret } from '@app/web/security/generateRandomSecret'
3	import { hashSecret, verifySecret } from '@app/web/security/hashSecret'
4	import { ApiClient, ApiClientScope } from '@prisma/client'
5
6	export type CreateApiClientInput = {
7	id?: string
8	name: string
9	scopes: ApiClientScope[]
10	validUntil?: Date
11	validFrom?: Date
12	}
13
UNCOV 14	export const createApiClient = async ({	×
15	id,
16	name,
17	scopes,
18	validFrom,
19	validUntil,
20	}: CreateApiClientInput): Promise<
21	ApiClient & {
22	secret: string
23	}
24	> => {
UNCOV 25	const secret = generateRandomSecret()	×
UNCOV 26	const secretHash = hashSecret(secret)	×
27
UNCOV 28	const apiClient = await prismaClient.apiClient.create({	×
29	data: {
30	id,
31	name,
32	secretHash, // Store the hashed secret in the database
33	validFrom: validFrom ?? new Date(),	×
34	validUntil,
35	scopes,
36	},
37	})
38
UNCOV 39	return {	×
40	...apiClient,
41	secret,
42	secretHash,
43	}
44	}
45
46	export type CreateApiClientOutput = Awaited<ReturnType<typeof createApiClient>>
47
UNCOV 48	export const rotateApiClientSecret = async ({	×
49	clientId,
50	}: {
51	clientId: string
52	}) => {
UNCOV 53	const secret = generateRandomSecret()	×
UNCOV 54	const secretHash = hashSecret(secret)	×
55
UNCOV 56	await prismaClient.apiClient.update({	×
57	where: { id: clientId },
58	data: {
59	secretHash, // Store the hashed secret in the database
60	updated: new Date(),
61	},
62	})
63
UNCOV 64	return {	×
65	clientId,
66	secret,
67	secretHash,
68	}
69	}
70
UNCOV 71	export const changeApiClientScopes = async ({	×
72	clientId,
73	scopes,
74	}: {
75	clientId: string
76	scopes: ApiClientScope[]
77	}) => {
78	const apiClient = await prismaClient.apiClient.findUnique({	×
79	where: { id: clientId },
80	})
81
82	if (!apiClient) {	×
83	throw new Error('Api client not found')	×
84	}
85
86	await prismaClient.apiClient.update({	×
87	where: { id: clientId },
88	data: {
89	scopes,
90	updated: new Date(),
91	},
92	})
93	}
94
UNCOV 95	export const authenticateApiCient = async (	×
96	clientId: string,
97	clientSecret: string,
98	): Promise<ApiClient \| null> => {
99	// Ensure that clientId is a uuid v4 using regex
UNCOV 100	if (!/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/.test(clientId)) return null	×
101
UNCOV 102	const apiClient = await prismaClient.apiClient.findUnique({	×
103	where: { id: clientId },
104	})
105
UNCOV 106	if (!apiClient) return null	×
107
UNCOV 108	const isValid = verifySecret(clientSecret, apiClient.secretHash)	×
109
UNCOV 110	if (!isValid) return null	×
111
UNCOV 112	const now = new Date()	×
113
UNCOV 114	if (apiClient.validFrom > now) return null	×
115
UNCOV 116	if (!!apiClient.validUntil && apiClient.validUntil < now) {	×
UNCOV 117	return null	×
118	}
119
UNCOV 120	return apiClient	×
121	}

inclusion-numerique / coop-mediation-numerique / 134f1cc8-b272-471e-be1c-25fe3b4baafa

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