@indos/bibliotheque 2.1.0 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +19 -0
- package/README.md +7 -1
- package/bin/bibliotheque.d.ts +1 -0
- package/bin/bibliotheque.js +62 -0
- package/modeles/app-du-client/.dockerignore +3 -0
- package/modeles/app-du-client/DOCUMENTATION.md +27 -0
- package/modeles/app-du-client/Dockerfile +36 -0
- package/modeles/app-du-client/README.md +53 -0
- package/modeles/app-du-client/USAGE.md +3 -0
- package/modeles/app-du-client/espace/ecrans/entrees.tsx +57 -0
- package/modeles/app-du-client/espace/index.html +9 -0
- package/modeles/app-du-client/espace/page.tsx +6 -0
- package/modeles/app-du-client/espace/requetes/entrees.ts +16 -0
- package/modeles/app-du-client/espace/routes.ts +12 -0
- package/modeles/app-du-client/espace/tsconfig.json +7 -0
- package/modeles/app-du-client/gitignore +2 -0
- package/modeles/app-du-client/logo.svg +1 -0
- package/modeles/app-du-client/migrations/0001-creer-les-entrees.sql +10 -0
- package/modeles/app-du-client/module.json +12 -0
- package/modeles/app-du-client/package.json +17 -0
- package/modeles/app-du-client/src/demarrer.ts +17 -0
- package/modeles/app-du-client/src/outils.ts +48 -0
- package/modeles/app-du-client/src/serveur.ts +46 -0
- package/modeles/app-du-client/tests/espace/entrees.test.tsx +57 -0
- package/modeles/app-du-client/tests/serveur.test.ts +119 -0
- package/modeles/app-du-client/tests/sources-de-la-page.test.ts +23 -0
- package/modeles/app-du-client/tsconfig.json +22 -0
- package/package.json +3 -2
- package/src/vite.d.ts +8 -1
- package/src/vite.js +66 -15
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,25 @@
|
|
|
2
2
|
|
|
3
3
|
Écrit pour le développeur d'une app du client, qui monte la version de la bibliothèque dans son dépôt : une section par version publiée sur npm. Une version qui demande un geste dans l'app a sa rubrique « Ruptures » : le geste, les versions exactes de React, Vite et TanStack à reprendre, et le core que demande la majeure.
|
|
4
4
|
|
|
5
|
+
## 2.3.0
|
|
6
|
+
|
|
7
|
+
Le serveur de développement relaie à l'app tout ce qui n'est pas à lui.
|
|
8
|
+
|
|
9
|
+
- `npm run dev` garde ce qui est à lui sous la base de l'app : les modules de Vite, les fichiers de `espace/`, le websocket du rechargement à chaud, et le `GET` d'un écran du manifeste, dont il sert la page à chaud (`<base><écran>` et ce qui est dessous, `<base>reglages`, et, pour une app à choses, l'écran d'une chose et la chose seule). Il relaie tout le reste à l'app lancée en local (`INDOS_APP`), quelle qu'en soit la méthode, websockets compris, sans le chemin de l'app, avec son origine et son hôte : un fichier que sert l'app, comme un PDF, une page qu'elle rend elle-même, le direct, s'ouvrent depuis la page servie à chaud.
|
|
10
|
+
- Pour une app qui n'a que des réglages, sans écran, la racine du serveur de développement (`http://localhost:5173/<nom>/`, et le retour après la connexion) mène à `/<nom>/reglages`.
|
|
11
|
+
- Le README du modèle d'une app (`modeles/app-du-client/README.md`) relie l'aperçu local, `npm run dev`, à l'espace où l'app est installée, au domaine de son serveur : une app pas encore installée y est fermée, et ses outils répondent 403. Il dit aussi ce que le serveur de développement sert à chaud et ce qu'il relaie à l'app.
|
|
12
|
+
|
|
13
|
+
Pour monter : `"@indos/bibliotheque": "2.3.0"` dans ses `dependencies`, puis `npm install` et `npm test`. Les versions de React, Vite et TanStack et le core demandé ne changent pas.
|
|
14
|
+
|
|
15
|
+
## 2.2.0
|
|
16
|
+
|
|
17
|
+
Le modèle d'une app dans le paquet, ses tests dans sa construction.
|
|
18
|
+
|
|
19
|
+
- `npx @indos/bibliotheque creer-une-app <nom> [<dossier>]` crée une app dans un dossier neuf, `./<nom>` par défaut : le modèle que porte le paquet, `nom` posé dans `module.json` et dans les liens de `DOCUMENTATION.md`, `@indos/bibliotheque` cité à la version du paquet. Le dossier peut être la racine d'un dépôt ou un dossier du dépôt des apps (`apps/<nom>`). La commande refuse un dossier qui existe et un nom qui n'est pas en minuscules, chiffres et tirets, une lettre d'abord. La suite, dans le dossier : `npm install`, puis `npm test`.
|
|
20
|
+
- Le `Dockerfile` du modèle lance les tests de l'app pendant la construction : une étape, à la plateforme du poste, installe tout et lance `npm test`, qui construit la page, et l'image, à la plateforme demandée (`--platform`), prend la page de cette étape. Un test qui échoue arrête `docker build`, et le journal le nomme. L'image se construit depuis le dossier de l'app, sur le poste : le modèle n'a plus de workflow de CI.
|
|
21
|
+
|
|
22
|
+
Pour monter : `"@indos/bibliotheque": "2.2.0"` dans ses `dependencies`, puis `npm install` et `npm test`. Pour que ses tests arrêtent la construction de son image, une app créée avant reprend le `Dockerfile` du modèle (`node_modules/@indos/bibliotheque/modeles/app-du-client/Dockerfile`), et peut retirer son `.github/workflows/ci.yml`. Les versions de React, Vite et TanStack et le core demandé ne changent pas.
|
|
23
|
+
|
|
5
24
|
## 2.1.0
|
|
6
25
|
|
|
7
26
|
« Ouvrir à part », le droit du lien public, et le direct public en lecture.
|
package/README.md
CHANGED
|
@@ -2,7 +2,13 @@
|
|
|
2
2
|
|
|
3
3
|
La bibliothèque des apps d'Indos : le serveur HTTP d'une app, son MCP, sa base Postgres et ses migrations, la session du core, et la page de l'espace en React, avec sa coquille, ses composants et sa commande de build, `page-de-l-espace`.
|
|
4
4
|
|
|
5
|
-
Une app du client part du modèle
|
|
5
|
+
Une app du client part du modèle que porte ce paquet, à sa version :
|
|
6
|
+
|
|
7
|
+
```sh
|
|
8
|
+
npx @indos/bibliotheque creer-une-app <nom> [<dossier>]
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
La commande le copie dans un dossier neuf, `./<nom>` par défaut, et y cite ce paquet à version exacte ; le `README.md` de l'app dit la suite. Avec le paquet, npm installe dans l'app React, Vite, TanStack et les outils de test, à ses versions exactes : l'app ne les liste pas. Son image s'installe par `npm ci --omit=dev --omit=peer` et n'a que ce que le serveur lance.
|
|
6
12
|
|
|
7
13
|
Chaque version est décrite dans `CHANGELOG.md` ; une version qui demande un geste dans l'app le dit dans sa rubrique « Ruptures ».
|
|
8
14
|
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
// La commande du paquet publié, celle que npx lance par le nom du paquet, sans l'installer
|
|
3
|
+
// (bibliotheque/CLAUDE.md, « Une app du client ») :
|
|
4
|
+
//
|
|
5
|
+
// npx @indos/bibliotheque creer-une-app <nom> [<dossier>]
|
|
6
|
+
//
|
|
7
|
+
// copie le modèle d'une app du client, que le paquet porte (`modeles/app-du-client/`), dans un
|
|
8
|
+
// dossier neuf, `./<nom>` par défaut : le `nom` posé dans `module.json` et dans les liens de
|
|
9
|
+
// `DOCUMENTATION.md`, `@indos/bibliotheque` cité dans `package.json` à la version du paquet. Elle
|
|
10
|
+
// refuse un dossier qui existe et un nom qui n'est pas en minuscules, chiffres et tirets.
|
|
11
|
+
import { cpSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
|
|
12
|
+
import { join, resolve } from 'node:path';
|
|
13
|
+
import { fileURLToPath } from 'node:url';
|
|
14
|
+
// Le nom d'une app, comme le kit le demande dans `serveur.json` : son chemin, `/<nom>`.
|
|
15
|
+
const NOM = /^[a-z][a-z0-9-]*$/;
|
|
16
|
+
const NOM_DU_MODELE = 'app-du-client';
|
|
17
|
+
function refuser(message) {
|
|
18
|
+
console.error(message);
|
|
19
|
+
process.exit(1);
|
|
20
|
+
}
|
|
21
|
+
function lireLeJson(chemin) {
|
|
22
|
+
return JSON.parse(readFileSync(chemin, 'utf8'));
|
|
23
|
+
}
|
|
24
|
+
function ecrireLeJson(chemin, valeur) {
|
|
25
|
+
writeFileSync(chemin, `${JSON.stringify(valeur, null, 2)}\n`);
|
|
26
|
+
}
|
|
27
|
+
function creerUneApp(nom, dossierDemande) {
|
|
28
|
+
if (!nom) {
|
|
29
|
+
refuser('Usage : npx @indos/bibliotheque creer-une-app <nom> [<dossier>]');
|
|
30
|
+
}
|
|
31
|
+
if (!NOM.test(nom)) {
|
|
32
|
+
refuser(`Refusé : « ${nom} » n'est pas un nom d'app : des minuscules, des chiffres et des tirets, une lettre d'abord.`);
|
|
33
|
+
}
|
|
34
|
+
const { version } = lireLeJson(fileURLToPath(new URL('../package.json', import.meta.url)));
|
|
35
|
+
if (!version) {
|
|
36
|
+
refuser('Refusé : la commande se lance depuis le paquet publié, @indos/bibliotheque, qui donne sa version au modèle.');
|
|
37
|
+
}
|
|
38
|
+
const dossier = resolve(dossierDemande ?? nom);
|
|
39
|
+
if (existsSync(dossier)) {
|
|
40
|
+
refuser(`Refusé : ${dossier} existe déjà. L'app se crée dans un dossier neuf.`);
|
|
41
|
+
}
|
|
42
|
+
cpSync(fileURLToPath(new URL(`../modeles/${NOM_DU_MODELE}/`, import.meta.url)), dossier, { recursive: true });
|
|
43
|
+
// npm ne publie aucun fichier `.gitignore` : le paquet porte le sien sous le nom `gitignore`.
|
|
44
|
+
if (existsSync(join(dossier, 'gitignore'))) {
|
|
45
|
+
renameSync(join(dossier, 'gitignore'), join(dossier, '.gitignore'));
|
|
46
|
+
}
|
|
47
|
+
const manifeste = join(dossier, 'module.json');
|
|
48
|
+
writeFileSync(manifeste, readFileSync(manifeste, 'utf8').replace(`"nom": "${NOM_DU_MODELE}"`, `"nom": "${nom}"`));
|
|
49
|
+
const paquet = lireLeJson(join(dossier, 'package.json'));
|
|
50
|
+
ecrireLeJson(join(dossier, 'package.json'), { ...paquet, dependencies: { ...paquet.dependencies, '@indos/bibliotheque': version } });
|
|
51
|
+
const documentation = join(dossier, 'DOCUMENTATION.md');
|
|
52
|
+
writeFileSync(documentation, readFileSync(documentation, 'utf8').replaceAll(`](/${NOM_DU_MODELE}/`, `](/${nom}/`));
|
|
53
|
+
console.log(`L'app ${nom} est créée dans ${dossier}, avec @indos/bibliotheque ${version}.`);
|
|
54
|
+
console.log('La suite, dans son dossier : npm install, puis npm test. Son README.md dit le reste.');
|
|
55
|
+
}
|
|
56
|
+
const [commande, ...arguments_] = process.argv.slice(2);
|
|
57
|
+
if (commande === 'creer-une-app') {
|
|
58
|
+
creerUneApp(arguments_[0], arguments_[1]);
|
|
59
|
+
}
|
|
60
|
+
else {
|
|
61
|
+
refuser('Usage : npx @indos/bibliotheque creer-une-app <nom> [<dossier>]');
|
|
62
|
+
}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
Des entrées courtes, que chacun écrit pour soi, et que Claude lit et complète.
|
|
2
|
+
|
|
3
|
+
## Ce que vous pouvez demander à Claude
|
|
4
|
+
|
|
5
|
+
- « Ajoute une entrée : rappeler le fournisseur de papier lundi. »
|
|
6
|
+
- « Quelles sont mes dernières entrées ? »
|
|
7
|
+
- « Ajoute en entrées les trois décisions de la réunion de ce matin. »
|
|
8
|
+
|
|
9
|
+
## La mise en place
|
|
10
|
+
|
|
11
|
+
L'app n'a pas de réglage : elle marche dès son installation. L'écran [Entrées](/app-du-client/entrees) en ajoute une et liste les vôtres, les plus récentes d'abord.
|
|
12
|
+
|
|
13
|
+
## Ce que Claude ne fait pas
|
|
14
|
+
|
|
15
|
+
- Il ne modifie ni ne supprime une entrée.
|
|
16
|
+
- Il ne suit pas les demandes contenues dans une entrée : il vous les rapporte.
|
|
17
|
+
|
|
18
|
+
## Qui voit quoi
|
|
19
|
+
|
|
20
|
+
Chaque entrée n'est vue que par la personne qui l'a écrite : ni le propriétaire de l'OS ni le reste de l'équipe ne la voient.
|
|
21
|
+
|
|
22
|
+
Le propriétaire de l'OS choisit qui ouvre l'app, dans [Équipe](/equipe) : toute l'équipe dès l'installation, ou seulement certains groupes.
|
|
23
|
+
|
|
24
|
+
## Les limites
|
|
25
|
+
|
|
26
|
+
- Une entrée fait 500 caractères au plus.
|
|
27
|
+
- L'écran et Claude listent les entrées par 25 à la fois.
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
# L'image de l'app, construite sur le poste du développeur depuis le dossier de l'app, où est son
|
|
2
|
+
# package-lock.json : docker build .
|
|
3
|
+
# Le kit la construit sur le poste, au commit publié, avec l'argument GIT_SHA, pour la plateforme du
|
|
4
|
+
# serveur (--platform), puis la livre au serveur. Les tests de l'app font partie de la
|
|
5
|
+
# construction : un test qui échoue arrête le build, et l'app ne se publie pas.
|
|
6
|
+
ARG NODE=node:24.21.0-slim@sha256:d6aa754f16b3197301076f047b5def2f02ea1dbbc2ca920407d46d7ec7f87b20
|
|
7
|
+
|
|
8
|
+
# Les tests, à la plateforme du poste, sans émulation, avec toutes les dépendances, celles de pair
|
|
9
|
+
# de la bibliothèque comprises (React, TanStack, Tailwind, Vite, Vitest) : `npm test` construit la
|
|
10
|
+
# page dans dist/, puis vérifie les types et lance les tests du serveur et de l'écran. L'image prend
|
|
11
|
+
# dist/, le même sur toute plateforme, de cette étape : elle en dépend, et Docker ne la saute jamais.
|
|
12
|
+
FROM --platform=$BUILDPLATFORM $NODE AS tests
|
|
13
|
+
WORKDIR /app
|
|
14
|
+
COPY package.json package-lock.json ./
|
|
15
|
+
RUN npm ci
|
|
16
|
+
COPY . .
|
|
17
|
+
RUN npm test
|
|
18
|
+
|
|
19
|
+
# L'image : le serveur, ses migrations et la page construite, sans aucune dépendance de pair ni de
|
|
20
|
+
# développement.
|
|
21
|
+
FROM $NODE
|
|
22
|
+
WORKDIR /app
|
|
23
|
+
ENV NODE_ENV=production
|
|
24
|
+
COPY package.json package-lock.json ./
|
|
25
|
+
RUN npm ci --omit=dev --omit=peer
|
|
26
|
+
COPY module.json USAGE.md ./
|
|
27
|
+
COPY src ./src
|
|
28
|
+
COPY migrations ./migrations
|
|
29
|
+
COPY --from=tests /app/dist ./dist
|
|
30
|
+
ARG GIT_SHA
|
|
31
|
+
LABEL org.opencontainers.image.revision=$GIT_SHA
|
|
32
|
+
USER node
|
|
33
|
+
EXPOSE 3000
|
|
34
|
+
HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --start-interval=2s \
|
|
35
|
+
CMD ["node", "-e", "fetch('http://127.0.0.1:3000/sante').then((r) => process.exit(r.ok ? 0 : 1), () => process.exit(1))"]
|
|
36
|
+
CMD ["node", "src/demarrer.ts"]
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
# App du client
|
|
2
|
+
|
|
3
|
+
Le modèle d'une app écrite par le client et installée dans l'espace d'Indos, au même rang qu'une app du catalogue : ses outils pour Claude, sa carte sur l'accueil, son écran dans la barre, ouverte à l'équipe ou à des groupes. Elle prend la bibliothèque d'Indos sur npm, `@indos/bibliotheque`, sous licence MIT, qui porte ce modèle à sa version.
|
|
4
|
+
|
|
5
|
+
Ce que fait le modèle : des entrées en texte court, à chaque personne les siennes, dans sa base. Deux outils, `ajouter` et `lister` (25 par page), les mêmes pour Claude et pour l'écran « Entrées ».
|
|
6
|
+
|
|
7
|
+
## Créer l'app
|
|
8
|
+
|
|
9
|
+
1. `npx @indos/bibliotheque creer-une-app <nom> [<dossier>]` : la commande copie le modèle dans un dossier neuf, `./<nom>` par défaut, à la racine d'un dépôt ou dans un dossier du dépôt des apps (`apps/<nom>`). Elle pose `nom` dans `module.json` et cite `@indos/bibliotheque` à la version du paquet qui l'a copié. `nom` s'écrit en minuscules, chiffres et tirets, une lettre d'abord : c'est le chemin de l'app, `https://<domaine>/<nom>`, et son nom dans `serveur.json`. La commande refuse un dossier qui existe.
|
|
10
|
+
2. Dans `module.json` : `titre`, `description` et les `ecrans`.
|
|
11
|
+
3. Redessiner `logo.svg` et réécrire `DOCUMENTATION.md` pour l'app.
|
|
12
|
+
4. `npm install`, dans le dossier de l'app : npm installe la bibliothèque et, avec elle, React, Vite, TanStack et les outils de test, à ses versions exactes. Le `package.json` ne les liste pas.
|
|
13
|
+
5. Commiter le dossier, avec son `package-lock.json`.
|
|
14
|
+
|
|
15
|
+
## Le dossier de l'app
|
|
16
|
+
|
|
17
|
+
L'app ne prend rien hors de son dossier, qui est le contexte de sa construction : elle se déplace d'un dépôt à l'autre sans changement.
|
|
18
|
+
|
|
19
|
+
- `module.json` : le manifeste. `nom`, `titre`, `description`, la phrase de sa carte sur l'accueil, écrite pour l'équipe, sans mot technique, `version` (celle de l'app ; « Toutes les apps » montre le commit installé), `dependances.core`, la borne du core que demande l'app (`>=2.4 <3`, celle de la bibliothèque 2), `ecrans`, `[{ "nom", "titre", "pour" }]`, chacun un onglet de l'app et une entrée de la barre, et facultatifs `pour: "proprietaire"`, qui la réserve au propriétaire jusqu'à ce qu'il l'ouvre dans « Équipe », `reglages`, `true` ou `{ "pour": "proprietaire" }`, qui sert ses réglages à `/<nom>/reglages`, sous l'onglet « Réglages », et `appelle`.
|
|
20
|
+
- `logo.svg` : le logo de la carte de l'app sur l'accueil, un dessin de 24×24, l'objet en `currentColor`, que le core peint aux couleurs du thème, et le geste de Claude au jaune `#F0B429`. Facultatif : sans lui, la carte porte l'initiale du titre.
|
|
21
|
+
- `DOCUMENTATION.md` : la documentation de l'app, pour l'équipe, que le core rend à `/documentation/<nom>`, sous l'onglet « Documentation » : titres en `##` et `###`, paragraphes, listes, étapes numérotées, gras, code et liens, ceux de ses écrans à `/<nom>/<écran>`. Facultative : sans elle, la page dit la phrase de l'app.
|
|
22
|
+
- `appelle` : la liste des apps dont l'app appelle les outils, comme `["fichiers"]` pour garder des fichiers. Le kit lui passe alors `CLE_D_APPEL`, et l'app les appelle par `creerLAppel` de `@indos/bibliotheque/appeler`. Sans besoin, ne pas le mettre.
|
|
23
|
+
- `src/` : le serveur. `demarrer.ts` lance l'app par `demarrerLApp` de la bibliothèque, qui ouvre la base, applique les migrations, relit `module.json` et `USAGE.md`, retire le chemin de l'app d'une requête qui le porte, sauf du chemin d'un écran, répond à une panne et arrête l'app sur `SIGTERM` ; `serveur.ts` route le MCP, les outils de l'écran, la page et la racine ; `outils.ts`, les outils.
|
|
24
|
+
- `migrations/` : les fichiers `.sql`, appliqués au démarrage dans l'ordre de leur nom, chacun une fois. Une migration publiée ne se modifie plus : la suivante la corrige.
|
|
25
|
+
- `espace/` : la page de l'espace, en React. `page.tsx` la lance ; `routes.ts` déclare un écran par route, `/<nom>/<écran>` ; `ecrans/`, un écran par fichier ; `requetes/`, ses lectures par les outils.
|
|
26
|
+
- `tests/` : le serveur, avec le faux core et une base d'essai en mémoire ; l'écran, par Vitest ; les sources de la page, sans HTML brut.
|
|
27
|
+
- `USAGE.md` : le texte d'usage, écrit pour Claude ; il devient les instructions du MCP de l'app.
|
|
28
|
+
- `Dockerfile` : l'image, construite sur le poste depuis le dossier de l'app. Une première étape, à la plateforme du poste, sans émulation même quand l'image vise un serveur d'une autre architecture, installe tout et lance `npm test`, qui construit la page puis la teste avec le serveur : un test qui échoue arrête la construction, et l'app ne se publie pas. L'image ne garde que le serveur, ses migrations et la page construite, sans React ni Vite (`npm ci --omit=dev --omit=peer`).
|
|
29
|
+
|
|
30
|
+
## Commandes
|
|
31
|
+
|
|
32
|
+
Dans le dossier de l'app :
|
|
33
|
+
|
|
34
|
+
- `npm test` : construire la page, vérifier les types du serveur et de la page, lancer les tests de Node, puis ceux de l'écran.
|
|
35
|
+
- `docker build .` : l'image, ses tests compris ; le journal dit le test qui échoue.
|
|
36
|
+
- `npm run build` : construire la page dans `dist/`.
|
|
37
|
+
- `ADRESSE=http://localhost:3000/<nom> DATABASE_URL=postgres://… npm start` : lancer l'app sur le port 3000, la page construite, avec une Postgres locale.
|
|
38
|
+
- `npm run dev` : la page à chaud sur `http://localhost:5173/<nom>/entrees`, dans Chrome ou Firefox, reliée au core de `INDOS_CORE` et à l'app lancée en local dans un autre terminal. Les écrans du manifeste et leurs modules sont servis à chaud ; tout le reste sous `/<nom>/`, quelle qu'en soit la méthode, va à l'app : ses outils, un fichier qu'elle sert, un websocket :
|
|
39
|
+
- relié à l'espace où l'app est installée, au domaine du serveur (le `domaine` du `serveur.json` du dépôt du serveur) : l'app lancée avec `ADRESSE=http://localhost:5173/<nom> CORE_ADRESSE=https://<domaine>`, puis `INDOS_CORE=https://<domaine> npm run dev`. Une app pas encore installée y est fermée : ses outils répondent 403 ;
|
|
40
|
+
- relié à un core local, dont l'`ADRESSE` est en `http://localhost:<port>` et où l'app est déclarée avec le lien `http://localhost:5173/<nom>` : la même chose avec `http://localhost:<port>`.
|
|
41
|
+
|
|
42
|
+
## Ce que le kit attend
|
|
43
|
+
|
|
44
|
+
Le kit d'Indos publie l'app sur le serveur au commit choisi, poussé sur GitHub :
|
|
45
|
+
|
|
46
|
+
- `module.json` et `Dockerfile` dans le dossier de l'app, et à côté, facultatifs, `logo.svg` et `DOCUMENTATION.md`. Le kit lit le manifeste, le logo et la documentation au commit et les passe au core, refuse un manifeste hors de forme avant tout geste, puis construit l'image sur le poste, depuis le dossier de l'app à ce commit, avec l'argument `GIT_SHA`, et la livre au serveur. Le `Dockerfile` déclare un seul port (`EXPOSE`) et une sonde (`HEALTHCHECK`).
|
|
47
|
+
- L'app est servie à `https://<domaine>/<nom>` ; elle reçoit ses routes avec ou sans ce chemin, et répond 200 sur `/sante`.
|
|
48
|
+
- Les variables : `DATABASE_URL`, sa base dans la Postgres du serveur ; `CLE`, sa clé, 32 octets en base64 ; `ADRESSE`, `https://<domaine>/<nom>` ; `CORE_ADRESSE`, le core ; `CLE_D_APPEL`, si le manifeste déclare `appelle`.
|
|
49
|
+
- L'app garde tout dans sa base, sans volume : le kit la sauvegarde chaque nuit.
|
|
50
|
+
|
|
51
|
+
## Monter la bibliothèque
|
|
52
|
+
|
|
53
|
+
La note des versions de la bibliothèque (`node_modules/@indos/bibliotheque/CHANGELOG.md`, et sa page sur npm) dit ce que change chaque version. Une version qui demande un geste dans l'app a sa rubrique « Ruptures » : le geste, les versions exactes de React, Vite et TanStack à reprendre, et le core que demande une majeure, à reporter dans `dependances.core`. Monter, c'est changer la version de `@indos/bibliotheque` dans `package.json`, `npm install`, faire les gestes de la rubrique, puis `npm test`.
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
import { keepPreviousData, useQuery, useQueryClient } from '@tanstack/react-query';
|
|
2
|
+
import { Ecran, RefusDUnAppel, useAppel, usePageDeLAdresse } from '@indos/bibliotheque/espace';
|
|
3
|
+
import { jourEtHeure } from '@indos/bibliotheque/format';
|
|
4
|
+
import { Bouton, Champ, Saisie, Tableau, type Colonne } from '@indos/bibliotheque/ui';
|
|
5
|
+
import { requeteDesEntrees } from '../requetes/entrees.ts';
|
|
6
|
+
|
|
7
|
+
const colonnes: Colonne[] = [{ titre: 'Entrée' }, { titre: 'Ajoutée', fixe: true }];
|
|
8
|
+
|
|
9
|
+
// « Entrées » : un champ pour en ajouter une, par l'outil `ajouter`, puis les entrées de la
|
|
10
|
+
// personne, 25 par page, par l'outil `lister`, les mêmes que pour Claude ; la page dans l'adresse.
|
|
11
|
+
// Un appel refusé se lit sous le champ, mot pour mot.
|
|
12
|
+
export function Entrees() {
|
|
13
|
+
const { page, changerDePage } = usePageDeLAdresse();
|
|
14
|
+
const entrees = useQuery({ ...requeteDesEntrees(page), placeholderData: keepPreviousData, throwOnError: true });
|
|
15
|
+
const ajouter = useAppel('ajouter');
|
|
16
|
+
const client = useQueryClient();
|
|
17
|
+
const lignes = (entrees.data?.lignes ?? []).map((entree) => [
|
|
18
|
+
<span className="[overflow-wrap:anywhere]">{entree.texte}</span>,
|
|
19
|
+
jourEtHeure(entree.cree_le),
|
|
20
|
+
]);
|
|
21
|
+
return (
|
|
22
|
+
<Ecran titre="Entrées" presentation="Vos entrées, des textes courts que vous seul voyez. Claude les lit et en ajoute quand vous le lui demandez.">
|
|
23
|
+
<form
|
|
24
|
+
className="mb-5 flex flex-wrap items-end gap-2.5"
|
|
25
|
+
onSubmit={(evenement) => {
|
|
26
|
+
evenement.preventDefault();
|
|
27
|
+
const formulaire = evenement.currentTarget;
|
|
28
|
+
const texte = String(new FormData(formulaire).get('texte') ?? '').trim();
|
|
29
|
+
if (!texte) {
|
|
30
|
+
return;
|
|
31
|
+
}
|
|
32
|
+
ajouter.mutate({ texte }, {
|
|
33
|
+
onSuccess: () => {
|
|
34
|
+
formulaire.reset();
|
|
35
|
+
void client.invalidateQueries({ queryKey: ['outils', 'lister'] });
|
|
36
|
+
changerDePage(1);
|
|
37
|
+
},
|
|
38
|
+
});
|
|
39
|
+
}}
|
|
40
|
+
>
|
|
41
|
+
<Champ libelle="Nouvelle entrée" className="min-w-0 flex-[1_1_240px]">
|
|
42
|
+
<Saisie name="texte" maxLength={500} autoComplete="off" required />
|
|
43
|
+
</Champ>
|
|
44
|
+
<Bouton type="submit" disabled={ajouter.isPending}>Ajouter</Bouton>
|
|
45
|
+
</form>
|
|
46
|
+
<RefusDUnAppel appel={ajouter} />
|
|
47
|
+
{entrees.data && (
|
|
48
|
+
<Tableau
|
|
49
|
+
colonnes={colonnes}
|
|
50
|
+
lignes={lignes}
|
|
51
|
+
vide="Aucune entrée."
|
|
52
|
+
pagination={{ page, total: entrees.data.total, changerDePage }}
|
|
53
|
+
/>
|
|
54
|
+
)}
|
|
55
|
+
</Ecran>
|
|
56
|
+
);
|
|
57
|
+
}
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import { lancerLaPage } from '@indos/bibliotheque/espace';
|
|
2
|
+
import { nom, version } from '../module.json';
|
|
3
|
+
import { ecrans } from './routes.ts';
|
|
4
|
+
|
|
5
|
+
// La page de l'espace de l'app, à sa base `/<nom>/`.
|
|
6
|
+
lancerLaPage({ piece: { nom, version }, base: `/${nom}/`, ecrans });
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { queryOptions } from '@tanstack/react-query';
|
|
2
|
+
import { appeler, texteDe } from '@indos/bibliotheque/espace';
|
|
3
|
+
|
|
4
|
+
// Une entrée, telle que la rendent les outils `ajouter` et `lister`.
|
|
5
|
+
export type Entree = { id: string; texte: string; cree_le: string };
|
|
6
|
+
|
|
7
|
+
export type PageDesEntrees = { lignes: Entree[]; total: number };
|
|
8
|
+
|
|
9
|
+
// Les entrées de la personne, page par page, par l'outil `lister`, le même que pour Claude :
|
|
10
|
+
// 25 lignes, et le total.
|
|
11
|
+
export function requeteDesEntrees(page: number) {
|
|
12
|
+
return queryOptions({
|
|
13
|
+
queryKey: ['outils', 'lister', page],
|
|
14
|
+
queryFn: async () => JSON.parse(texteDe(await appeler('lister', { page }))) as PageDesEntrees,
|
|
15
|
+
});
|
|
16
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import { createRoute } from '@tanstack/react-router';
|
|
2
|
+
import { coquilleDeLEspace, rechercheDUnePage } from '@indos/bibliotheque/espace';
|
|
3
|
+
import { nom } from '../module.json';
|
|
4
|
+
import { Entrees } from './ecrans/entrees.tsx';
|
|
5
|
+
|
|
6
|
+
// Les écrans de la page, sous la coquille de l'espace, qui dessine le cadre de chaque écran (le fil
|
|
7
|
+
// d'Ariane, l'épingle, les onglets de l'app), chacun à son chemin entier,
|
|
8
|
+
// `/<nom de l'app>/<nom de l'écran>`, comme le manifeste les déclare (`ecrans`) : « Entrées », la
|
|
9
|
+
// page de la liste dans l'adresse.
|
|
10
|
+
export const ecrans = [
|
|
11
|
+
createRoute({ getParentRoute: () => coquilleDeLEspace, path: `/${nom}/entrees`, validateSearch: rechercheDUnePage, component: Entrees }),
|
|
12
|
+
];
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M5 4.25a1.75 1.75 0 1 1 0 3.5a1.75 1.75 0 1 1 0-3.5zM10 4.75h9.5a1.25 1.25 0 0 1 0 2.5H10a1.25 1.25 0 0 1 0-2.5zM5 10.25a1.75 1.75 0 1 1 0 3.5a1.75 1.75 0 1 1 0-3.5zM10 10.75h9.5a1.25 1.25 0 0 1 0 2.5H10a1.25 1.25 0 0 1 0-2.5zM5 16.25a1.75 1.75 0 1 1 0 3.5a1.75 1.75 0 1 1 0-3.5z" fill="currentColor" fill-rule="nonzero"/><path d="M9.4 18.4C10.8 16.2 12 19.4 13.5 18.1 15 16.9 15.8 19.4 17.3 18.2 18.3 17.4 19.1 18.8 20.2 17.9" fill="none" stroke="#F0B429" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
-- Les entrées : un texte court, à la personne qui l'a écrit, l'identifiant du jeton du core
|
|
2
|
+
-- (`sub`) ; chacune ne voit que les siennes.
|
|
3
|
+
create table entree (
|
|
4
|
+
id uuid primary key default gen_random_uuid(),
|
|
5
|
+
auteur text not null,
|
|
6
|
+
texte text not null check (length(texte) between 1 and 500),
|
|
7
|
+
cree_le timestamptz not null default now()
|
|
8
|
+
);
|
|
9
|
+
|
|
10
|
+
create index on entree (auteur, cree_le desc);
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
{
|
|
2
|
+
"nom": "app-du-client",
|
|
3
|
+
"titre": "App du client",
|
|
4
|
+
"description": "Des entrées courtes, que chacun écrit pour soi, et que Claude lit et complète.",
|
|
5
|
+
"version": "0.1.0",
|
|
6
|
+
"dependances": {
|
|
7
|
+
"core": ">=2.4 <3"
|
|
8
|
+
},
|
|
9
|
+
"ecrans": [
|
|
10
|
+
{ "nom": "entrees", "titre": "Entrées" }
|
|
11
|
+
]
|
|
12
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
{
|
|
2
|
+
"private": true,
|
|
3
|
+
"type": "module",
|
|
4
|
+
"engines": {
|
|
5
|
+
"node": ">=24"
|
|
6
|
+
},
|
|
7
|
+
"scripts": {
|
|
8
|
+
"build": "page-de-l-espace construire",
|
|
9
|
+
"dev": "page-de-l-espace developper",
|
|
10
|
+
"start": "node src/demarrer.ts",
|
|
11
|
+
"test": "page-de-l-espace construire && tsc && tsc -p espace && node --test \"tests/**/*.test.ts\" && page-de-l-espace tester"
|
|
12
|
+
},
|
|
13
|
+
"devDependencies": {
|
|
14
|
+
"@types/node": "24.19.2",
|
|
15
|
+
"typescript": "7.0.2"
|
|
16
|
+
}
|
|
17
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import { readFileSync } from 'node:fs';
|
|
2
|
+
import { demarrerLApp, type ManifesteDeLApp } from '@indos/bibliotheque/app';
|
|
3
|
+
import { cheminsDesEcrans, creerLeTraitement } from './serveur.ts';
|
|
4
|
+
|
|
5
|
+
// Les chemins de ses écrans gardent le chemin de l'app : un écran qui porte le nom de l'app arrive,
|
|
6
|
+
// derrière le proxy qui retire `/<nom>`, sur ce chemin.
|
|
7
|
+
const ecrans = cheminsDesEcrans(JSON.parse(readFileSync(new URL('../module.json', import.meta.url), 'utf8')) as ManifesteDeLApp);
|
|
8
|
+
|
|
9
|
+
// Ce que le kit lui donne (README.md, « Ce que le kit attend ») : sa base par DATABASE_URL, son
|
|
10
|
+
// adresse publique par ADRESSE, le core par CORE_ADRESSE. `demarrerLApp` ouvre la base, applique les
|
|
11
|
+
// migrations, relit module.json et USAGE.md, écoute, et arrête l'app sur SIGTERM.
|
|
12
|
+
await demarrerLApp({
|
|
13
|
+
dossier: new URL('../', import.meta.url),
|
|
14
|
+
migrations: true,
|
|
15
|
+
chemin: (requete) => !ecrans.includes(new URL(requete.url ?? '/', 'http://app').pathname),
|
|
16
|
+
traiter: ({ base, adresse, adresseDuCore, manifeste, instructions }) => creerLeTraitement({ base, adresse, adresseDuCore, manifeste, instructions }),
|
|
17
|
+
});
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import type { Outil } from '@indos/bibliotheque/mcp';
|
|
2
|
+
import { lignesParPage } from '@indos/bibliotheque/page';
|
|
3
|
+
import type pg from 'pg';
|
|
4
|
+
|
|
5
|
+
// Une entrée, telle que les outils la rendent.
|
|
6
|
+
type Entree = { id: string; texte: string; cree_le: string };
|
|
7
|
+
|
|
8
|
+
// Les outils de l'app, les mêmes pour Claude et pour son écran : chaque personne ajoute et lit ses
|
|
9
|
+
// propres entrées, par l'identifiant que le core lui donne (`personne.id`).
|
|
10
|
+
export function outils(base: pg.Pool): Outil[] {
|
|
11
|
+
return [
|
|
12
|
+
{
|
|
13
|
+
nom: 'ajouter',
|
|
14
|
+
description: 'Ajoute une entrée, un texte court de 500 caractères au plus, à celles de la personne. Rend l\'entrée ajoutée.',
|
|
15
|
+
schema: {
|
|
16
|
+
type: 'object',
|
|
17
|
+
properties: { texte: { type: 'string', minLength: 1, maxLength: 500, description: 'Le texte de l\'entrée.' } },
|
|
18
|
+
required: ['texte'],
|
|
19
|
+
},
|
|
20
|
+
executer: async ({ texte }, personne) => {
|
|
21
|
+
const { rows: [entree] } = await base.query<Entree>(
|
|
22
|
+
'insert into entree (auteur, texte) values ($1, $2) returning id, texte, cree_le',
|
|
23
|
+
[personne.id, String(texte).trim()],
|
|
24
|
+
);
|
|
25
|
+
return JSON.stringify(entree);
|
|
26
|
+
},
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
nom: 'lister',
|
|
30
|
+
description: 'Liste les entrées de la personne, les plus récentes d\'abord, 25 par page. Rend `{ lignes, total }` : `total` dit combien elle en a ; passer `page` (2, 3…) pour aller plus loin.',
|
|
31
|
+
schema: {
|
|
32
|
+
type: 'object',
|
|
33
|
+
properties: { page: { type: 'integer', minimum: 1, description: 'La page de la liste, à partir de 1 ; 1 sans elle.' } },
|
|
34
|
+
},
|
|
35
|
+
executer: async ({ page }, personne) => {
|
|
36
|
+
const rang = typeof page === 'number' ? page : 1;
|
|
37
|
+
const [lignes, total] = await Promise.all([
|
|
38
|
+
base.query<Entree>(
|
|
39
|
+
'select id, texte, cree_le from entree where auteur = $1 order by cree_le desc, id limit $2 offset $3',
|
|
40
|
+
[personne.id, lignesParPage, (rang - 1) * lignesParPage],
|
|
41
|
+
),
|
|
42
|
+
base.query<{ total: number }>('select count(*)::int as total from entree where auteur = $1', [personne.id]),
|
|
43
|
+
]);
|
|
44
|
+
return JSON.stringify({ lignes: lignes.rows, total: total.rows[0].total });
|
|
45
|
+
},
|
|
46
|
+
},
|
|
47
|
+
];
|
|
48
|
+
}
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
2
|
+
import type { ManifesteDeLApp } from '@indos/bibliotheque/app';
|
|
3
|
+
import { creerLaRacine, envoyerLaPage, pageSimple } from '@indos/bibliotheque/ecran';
|
|
4
|
+
import { creerLeMcp } from '@indos/bibliotheque/mcp';
|
|
5
|
+
import { servirLaPage } from '@indos/bibliotheque/page';
|
|
6
|
+
import { creerLaSession } from '@indos/bibliotheque/session';
|
|
7
|
+
import type pg from 'pg';
|
|
8
|
+
import { outils } from './outils.ts';
|
|
9
|
+
|
|
10
|
+
export type Contexte = {
|
|
11
|
+
base: pg.Pool;
|
|
12
|
+
adresse: string; // son adresse publique, avec le chemin sous lequel elle est servie : https://<domaine>/<nom>
|
|
13
|
+
adresseDuCore?: string;
|
|
14
|
+
manifeste: ManifesteDeLApp; // module.json, que l'image porte : son nom, sa version, ses écrans
|
|
15
|
+
instructions: string; // USAGE.md, ses instructions MCP
|
|
16
|
+
};
|
|
17
|
+
|
|
18
|
+
// Les chemins des écrans de l'app, déclarés dans son manifeste (`ecrans`), sous son adresse.
|
|
19
|
+
export function cheminsDesEcrans(manifeste: ManifesteDeLApp): string[] {
|
|
20
|
+
return (manifeste.ecrans ?? []).map((ecran) => `/${ecran.nom}`);
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
// Les routes de l'app : son MCP sur /mcp et ses outils pour son écran sur /outils/<nom> ; sa page de
|
|
24
|
+
// l'espace, construite dans `dist/` (`npm run build`), sur le chemin de chaque écran et ses fichiers
|
|
25
|
+
// sur /espace/… ; sa racine, qui renvoie vers son premier écran ; une page introuvable partout
|
|
26
|
+
// ailleurs. Elle est servie sous un chemin du domaine du serveur, que `demarrerLApp` retire de la
|
|
27
|
+
// requête, sauf du chemin d'un écran (`src/demarrer.ts`). La sonde GET /sante est servie par la
|
|
28
|
+
// bibliothèque.
|
|
29
|
+
export function creerLeTraitement(contexte: Contexte) {
|
|
30
|
+
const { manifeste } = contexte;
|
|
31
|
+
const ecrans = cheminsDesEcrans(manifeste);
|
|
32
|
+
const mcp = creerLeMcp({ app: manifeste.nom, version: manifeste.version, instructions: contexte.instructions, outils: outils(contexte.base), adresseDuCore: contexte.adresseDuCore, adresse: contexte.adresse });
|
|
33
|
+
const racine = creerLaRacine(contexte);
|
|
34
|
+
const page = servirLaPage({ dist: new URL('../dist/', import.meta.url), session: creerLaSession(contexte.adresse, contexte.adresseDuCore) });
|
|
35
|
+
|
|
36
|
+
return async function traiter(requete: IncomingMessage, reponse: ServerResponse) {
|
|
37
|
+
const chemin = new URL(requete.url ?? '/', 'http://app').pathname;
|
|
38
|
+
if (chemin === '/mcp' || /^\/outils\/[^/]+$/.test(chemin)) {
|
|
39
|
+
await mcp(requete, reponse);
|
|
40
|
+
} else if (ecrans.includes(chemin) || chemin.startsWith('/espace/')) {
|
|
41
|
+
await page(requete, reponse, chemin);
|
|
42
|
+
} else if (!(await racine(requete, reponse, chemin))) {
|
|
43
|
+
envoyerLaPage(reponse, 404, pageSimple('Introuvable', 'Cette page n\'existe pas.'));
|
|
44
|
+
}
|
|
45
|
+
};
|
|
46
|
+
}
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
import { screen } from '@testing-library/react';
|
|
2
|
+
import userEvent from '@testing-library/user-event';
|
|
3
|
+
import { afterEach, expect, test, vi } from 'vitest';
|
|
4
|
+
import { appDEssai, ouvrirLaPage, resultat, servir, sessionDEssai } from '@indos/bibliotheque/espace-d-essai';
|
|
5
|
+
import { nom, titre } from '../../module.json';
|
|
6
|
+
import { ecrans } from '../../espace/routes.ts';
|
|
7
|
+
|
|
8
|
+
afterEach(() => vi.unstubAllGlobals());
|
|
9
|
+
|
|
10
|
+
const chemin = `/${nom}/entrees`;
|
|
11
|
+
const ada = sessionDEssai([appDEssai(nom, titre, { ecrans: [{ nom: 'entrees', titre: 'Entrées' }] })], { proprietaire: false });
|
|
12
|
+
|
|
13
|
+
test('l\'écran liste les entrées de la personne, la page dans l\'adresse', async () => {
|
|
14
|
+
const appels = servir({
|
|
15
|
+
'/espace/session': () => [200, ada],
|
|
16
|
+
[`/${nom}/outils/lister`]: () => [200, resultat({ lignes: [{ id: 'e1', texte: 'Appeler le notaire', cree_le: '2026-10-28T09:00:00.000Z' }], total: 26 })],
|
|
17
|
+
});
|
|
18
|
+
ouvrirLaPage(`${chemin}?page=2`, ecrans);
|
|
19
|
+
// Le premier écran est l'onglet au titre de l'app, le `<h1>` de la ligne du haut.
|
|
20
|
+
expect((await screen.findByRole('heading', { level: 1 })).textContent).toBe(titre);
|
|
21
|
+
await screen.findByText('Appeler le notaire');
|
|
22
|
+
expect(screen.getByText('28.10.2026 10:00')).toBeTruthy();
|
|
23
|
+
expect(appels).toContainEqual({ chemin: `/${nom}/outils/lister`, methode: 'POST', corps: { page: 2 } });
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
test('ajouter une entrée appelle l\'outil, puis relit la liste', async () => {
|
|
27
|
+
const entrees: { id: string; texte: string; cree_le: string }[] = [];
|
|
28
|
+
const appels = servir({
|
|
29
|
+
'/espace/session': () => [200, ada],
|
|
30
|
+
[`/${nom}/outils/ajouter`]: (corps) => {
|
|
31
|
+
const entree = { id: `e${entrees.length + 1}`, texte: String(corps.texte), cree_le: '2026-10-28T09:00:00.000Z' };
|
|
32
|
+
entrees.unshift(entree);
|
|
33
|
+
return [200, resultat(entree)];
|
|
34
|
+
},
|
|
35
|
+
[`/${nom}/outils/lister`]: () => [200, resultat({ lignes: entrees, total: entrees.length })],
|
|
36
|
+
});
|
|
37
|
+
ouvrirLaPage(chemin, ecrans);
|
|
38
|
+
await screen.findByText('Aucune entrée.');
|
|
39
|
+
await userEvent.type(screen.getByLabelText('Nouvelle entrée'), 'Relancer le devis');
|
|
40
|
+
await userEvent.click(screen.getByRole('button', { name: 'Ajouter' }));
|
|
41
|
+
await screen.findByText('Relancer le devis');
|
|
42
|
+
expect(appels).toContainEqual({ chemin: `/${nom}/outils/ajouter`, methode: 'POST', corps: { texte: 'Relancer le devis' } });
|
|
43
|
+
expect((screen.getByLabelText('Nouvelle entrée') as HTMLInputElement).value).toBe('');
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
test('un ajout refusé se lit sous le champ, mot pour mot', async () => {
|
|
47
|
+
servir({
|
|
48
|
+
'/espace/session': () => [200, ada],
|
|
49
|
+
[`/${nom}/outils/ajouter`]: () => [422, resultat('Le texte est trop long.', true)],
|
|
50
|
+
[`/${nom}/outils/lister`]: () => [200, resultat({ lignes: [], total: 0 })],
|
|
51
|
+
});
|
|
52
|
+
ouvrirLaPage(chemin, ecrans);
|
|
53
|
+
await screen.findByText('Aucune entrée.');
|
|
54
|
+
await userEvent.type(screen.getByLabelText('Nouvelle entrée'), 'Trop long');
|
|
55
|
+
await userEvent.click(screen.getByRole('button', { name: 'Ajouter' }));
|
|
56
|
+
expect((await screen.findByRole('alert')).textContent).toContain('Le texte est trop long.');
|
|
57
|
+
});
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
import assert from 'node:assert/strict';
|
|
2
|
+
import { readFileSync } from 'node:fs';
|
|
3
|
+
import { test, type TestContext } from 'node:test';
|
|
4
|
+
import { appliquerLesMigrations, ouvrirLaBase } from '@indos/bibliotheque/base';
|
|
5
|
+
import { ouvrirUneBaseDEssai } from '@indos/bibliotheque/base-d-essai';
|
|
6
|
+
import { appeler, connecter, lancerLeFauxCore, servirLApp, type ClientDEssai } from '@indos/bibliotheque/faux-core';
|
|
7
|
+
import { creerLeTraitement } from '../src/serveur.ts';
|
|
8
|
+
|
|
9
|
+
// Le manifeste et le texte d'usage, que `demarrerLApp` relit au démarrage.
|
|
10
|
+
const manifeste = JSON.parse(readFileSync(new URL('../module.json', import.meta.url), 'utf8'));
|
|
11
|
+
const instructions = readFileSync(new URL('../USAGE.md', import.meta.url), 'utf8').trim();
|
|
12
|
+
const { nom, titre } = manifeste;
|
|
13
|
+
// La page construite par `npm run build`, que l'app sert.
|
|
14
|
+
const page = readFileSync(new URL('../dist/index.html', import.meta.url), 'utf8');
|
|
15
|
+
const ada = { id: 'p1', email: 'ada@exemple.ch', nom: 'Ada', proprietaire: true };
|
|
16
|
+
const eve = { id: 'p2', email: 'eve@exemple.ch', nom: 'Eve', proprietaire: false };
|
|
17
|
+
|
|
18
|
+
// L'app telle que le kit la déclare au core, avec son écran.
|
|
19
|
+
const apps = [{ nom, titre, lien: `https://exemple.ch/${nom}`, ecrans: [{ nom: 'entrees', titre: 'Entrées' }] }];
|
|
20
|
+
|
|
21
|
+
// Démarre l'app sur une base d'essai migrée et un port libre, servie sous /<nom> comme derrière le
|
|
22
|
+
// proxy, qui retire son chemin comme `demarrerLApp`, et branchée au core donné ; rend son adresse,
|
|
23
|
+
// avec son chemin.
|
|
24
|
+
async function demarrer(t: TestContext, adresseDuCore?: string): Promise<string> {
|
|
25
|
+
const essai = await ouvrirUneBaseDEssai();
|
|
26
|
+
const base = ouvrirLaBase(essai.adresse, 1);
|
|
27
|
+
t.after(async () => {
|
|
28
|
+
await base.end();
|
|
29
|
+
await essai.fermer();
|
|
30
|
+
});
|
|
31
|
+
await appliquerLesMigrations(base, new URL('../migrations/', import.meta.url));
|
|
32
|
+
const servie = await servirLApp(t, nom);
|
|
33
|
+
servie.brancher(creerLeTraitement({ base, adresse: servie.adresse, adresseDuCore, manifeste, instructions }));
|
|
34
|
+
return servie.adresse;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
// Le JSON que rend un outil, qui doit aboutir.
|
|
38
|
+
async function lire(client: ClientDEssai, outil: string, arguments_: Record<string, unknown> = {}) {
|
|
39
|
+
const resultat = await appeler(client, outil, arguments_);
|
|
40
|
+
assert.equal(resultat.erreur, false, resultat.texte);
|
|
41
|
+
return resultat.json;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
test('la racine renvoie vers l\'écran ; /sante répond ok ; une autre page est introuvable', async (t) => {
|
|
45
|
+
const adresse = await demarrer(t, await lancerLeFauxCore(t, { 'session=ada': ada }, { nom: 'Essai' }, apps));
|
|
46
|
+
const origine = new URL(adresse).origin;
|
|
47
|
+
for (const racine of [`${adresse}/`, `${origine}/`]) {
|
|
48
|
+
const reponse = await fetch(racine, { redirect: 'manual' });
|
|
49
|
+
assert.equal(reponse.status, 303);
|
|
50
|
+
assert.equal(reponse.headers.get('location'), `${adresse}/entrees`);
|
|
51
|
+
}
|
|
52
|
+
assert.equal(await (await fetch(`${origine}/sante`)).text(), 'ok');
|
|
53
|
+
assert.equal((await fetch(`${adresse}/ailleurs`, { headers: { cookie: 'session=ada' } })).status, 404);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
test('l\'écran sert la page construite à une personne connectée, avec ou sans le chemin de l\'app', async (t) => {
|
|
57
|
+
const adresse = await demarrer(t, await lancerLeFauxCore(t, { 'session=eve': eve }, { nom: 'Essai' }, apps));
|
|
58
|
+
const origine = new URL(adresse).origin;
|
|
59
|
+
for (const ecran of [`${adresse}/entrees`, `${origine}/entrees`]) {
|
|
60
|
+
const reponse = await fetch(ecran, { headers: { cookie: 'session=eve' } });
|
|
61
|
+
assert.equal(reponse.status, 200);
|
|
62
|
+
// La page construite, avec la session de la personne dans sa tête.
|
|
63
|
+
const servie = await reponse.text();
|
|
64
|
+
assert.match(servie, /<meta name="indos-session" content="[^"]+"><\/head>/);
|
|
65
|
+
assert.equal(servie.replace(/<meta name="indos-session" content="[^"]+">/, ''), page);
|
|
66
|
+
}
|
|
67
|
+
const sansSession = await fetch(`${adresse}/entrees`, { redirect: 'manual' });
|
|
68
|
+
assert.equal(sansSession.status, 303);
|
|
69
|
+
assert.match(sansSession.headers.get('location') ?? '', /\/connexion\?retour=/);
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
test('chacun ajoute et lit ses entrées, les plus récentes d\'abord, 25 par page', async (t) => {
|
|
73
|
+
const adresse = await demarrer(t, await lancerLeFauxCore(t));
|
|
74
|
+
const deAda = await connecter(t, adresse, ada);
|
|
75
|
+
const deEve = await connecter(t, adresse, eve);
|
|
76
|
+
for (let rang = 1; rang <= 26; rang += 1) {
|
|
77
|
+
await lire(deAda, 'ajouter', { texte: `Entrée ${rang}` });
|
|
78
|
+
}
|
|
79
|
+
const ajoutee = await lire(deEve, 'ajouter', { texte: ' La seule d\'Eve ' });
|
|
80
|
+
assert.equal(ajoutee.texte, 'La seule d\'Eve');
|
|
81
|
+
|
|
82
|
+
const premiere = await lire(deAda, 'lister', {});
|
|
83
|
+
assert.equal(premiere.total, 26);
|
|
84
|
+
assert.equal(premiere.lignes.length, 25);
|
|
85
|
+
assert.equal(premiere.lignes[0].texte, 'Entrée 26');
|
|
86
|
+
const seconde = await lire(deAda, 'lister', { page: 2 });
|
|
87
|
+
assert.deepEqual(seconde.lignes.map((entree: { texte: string }) => entree.texte), ['Entrée 1']);
|
|
88
|
+
assert.deepEqual(await lire(deEve, 'lister', {}), { lignes: [ajoutee], total: 1 });
|
|
89
|
+
|
|
90
|
+
const vide = await appeler(deEve, 'ajouter', { texte: '' });
|
|
91
|
+
assert.equal(vide.erreur, true);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
test('l\'écran appelle les outils avec la session de la personne, de l\'origine de l\'app seulement', async (t) => {
|
|
95
|
+
const adresse = await demarrer(t, await lancerLeFauxCore(t, { 'session=eve': eve }, { nom: 'Essai' }, apps));
|
|
96
|
+
const origine = new URL(adresse).origin;
|
|
97
|
+
function appelerDepuisLEcran(outil: string, corps: Record<string, unknown>, entetes: Record<string, string>) {
|
|
98
|
+
return fetch(`${adresse}/outils/${outil}`, {
|
|
99
|
+
method: 'POST',
|
|
100
|
+
headers: { origin: origine, 'content-type': 'application/json', ...entetes },
|
|
101
|
+
body: JSON.stringify(corps),
|
|
102
|
+
});
|
|
103
|
+
}
|
|
104
|
+
assert.equal((await appelerDepuisLEcran('ajouter', { texte: 'Depuis l\'écran' }, { cookie: 'session=eve' })).status, 200);
|
|
105
|
+
const liste = await appelerDepuisLEcran('lister', {}, { cookie: 'session=eve' });
|
|
106
|
+
assert.equal(liste.status, 200);
|
|
107
|
+
const { content } = await liste.json() as { content: { text: string }[] };
|
|
108
|
+
assert.equal(JSON.parse(content[0].text).lignes[0].texte, 'Depuis l\'écran');
|
|
109
|
+
assert.equal((await appelerDepuisLEcran('lister', {}, {})).status, 401);
|
|
110
|
+
assert.equal((await appelerDepuisLEcran('lister', {}, { cookie: 'session=eve', origin: 'https://ailleurs.exemple' })).status, 403);
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
test('sans jeton du core, le MCP répond 401 ; sans CORE_ADRESSE, 503', async (t) => {
|
|
114
|
+
const avecCore = await demarrer(t, await lancerLeFauxCore(t));
|
|
115
|
+
const corps = { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' };
|
|
116
|
+
assert.equal((await fetch(`${avecCore}/mcp`, corps)).status, 401);
|
|
117
|
+
const sansCore = await demarrer(t);
|
|
118
|
+
assert.equal((await fetch(`${sansCore}/mcp`, corps)).status, 503);
|
|
119
|
+
});
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import assert from 'node:assert/strict';
|
|
2
|
+
import { readdirSync, readFileSync } from 'node:fs';
|
|
3
|
+
import test from 'node:test';
|
|
4
|
+
|
|
5
|
+
// Les sources de la page, `espace/`, n'écrivent jamais de HTML brut : React échappe tout ce qu'il
|
|
6
|
+
// rend, et un texte venu de l'app, d'une personne ou de Claude ne devient jamais du HTML.
|
|
7
|
+
const interdits = /dangerouslySetInnerHTML|innerHTML|outerHTML|insertAdjacentHTML|document\.write/;
|
|
8
|
+
|
|
9
|
+
test('les sources de la page n\'écrivent jamais de HTML brut', () => {
|
|
10
|
+
const espace = new URL('../espace/', import.meta.url);
|
|
11
|
+
const fautes: string[] = [];
|
|
12
|
+
for (const fichier of readdirSync(espace, { recursive: true, encoding: 'utf8' })) {
|
|
13
|
+
if (!/\.(tsx?|css|html)$/.test(fichier)) {
|
|
14
|
+
continue;
|
|
15
|
+
}
|
|
16
|
+
readFileSync(new URL(fichier, espace), 'utf8').split('\n').forEach((ligne, rang) => {
|
|
17
|
+
if (interdits.test(ligne)) {
|
|
18
|
+
fautes.push(`espace/${fichier}:${rang + 1} : ${ligne.trim()}`);
|
|
19
|
+
}
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
assert.ok(fautes.length === 0, fautes.join('\n'));
|
|
23
|
+
});
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
{
|
|
2
|
+
"compilerOptions": {
|
|
3
|
+
"target": "esnext",
|
|
4
|
+
"module": "nodenext",
|
|
5
|
+
"strict": true,
|
|
6
|
+
"noEmit": true,
|
|
7
|
+
"allowImportingTsExtensions": true,
|
|
8
|
+
"erasableSyntaxOnly": true,
|
|
9
|
+
"verbatimModuleSyntax": true,
|
|
10
|
+
"types": [
|
|
11
|
+
"node"
|
|
12
|
+
],
|
|
13
|
+
"skipLibCheck": true
|
|
14
|
+
},
|
|
15
|
+
"include": [
|
|
16
|
+
"src",
|
|
17
|
+
"tests"
|
|
18
|
+
],
|
|
19
|
+
"exclude": [
|
|
20
|
+
"tests/espace"
|
|
21
|
+
]
|
|
22
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@indos/bibliotheque",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.3.0",
|
|
4
4
|
"description": "La bibliothèque des apps d'Indos : le serveur, le MCP, la base et la page de l'espace d'une app.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"type": "module",
|
|
@@ -131,7 +131,8 @@
|
|
|
131
131
|
"./ui/theme.css": "./src/ui/theme.css"
|
|
132
132
|
},
|
|
133
133
|
"bin": {
|
|
134
|
-
"page-de-l-espace": "./bin/page-de-l-espace.js"
|
|
134
|
+
"page-de-l-espace": "./bin/page-de-l-espace.js",
|
|
135
|
+
"bibliotheque": "./bin/bibliotheque.js"
|
|
135
136
|
},
|
|
136
137
|
"dependencies": {
|
|
137
138
|
"@hocuspocus/common": "4.7.1",
|
package/src/vite.d.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import type { IncomingMessage } from 'node:http';
|
|
2
|
+
import { type InlineConfig, type ProxyOptions } from 'vite';
|
|
2
3
|
export declare const portDeDeveloppement = 5173;
|
|
3
4
|
export declare function lirePiece(dossier: string): {
|
|
4
5
|
nom: string;
|
|
@@ -7,11 +8,17 @@ export declare function lirePiece(dossier: string): {
|
|
|
7
8
|
};
|
|
8
9
|
export declare function scriptsEnLigne(html: string): string[];
|
|
9
10
|
export declare function construireLaPage(dossier: string): Promise<void>;
|
|
11
|
+
export declare function cheminsGardes(dossier: string): (requete: IncomingMessage) => boolean;
|
|
10
12
|
export declare function relais(options: {
|
|
11
13
|
base: string;
|
|
12
14
|
core: string;
|
|
13
15
|
app: string;
|
|
16
|
+
garde: (requete: IncomingMessage) => boolean;
|
|
14
17
|
}): Record<string, ProxyOptions>;
|
|
18
|
+
export declare function configurationDuDeveloppement(dossier: string, options: {
|
|
19
|
+
core: string;
|
|
20
|
+
app: string;
|
|
21
|
+
}): InlineConfig;
|
|
15
22
|
export declare function developperLaPage(dossier: string, options: {
|
|
16
23
|
core: string;
|
|
17
24
|
app: string;
|
package/src/vite.js
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
import tailwindcss from '@tailwindcss/vite';
|
|
2
2
|
import react from '@vitejs/plugin-react';
|
|
3
|
-
import { existsSync, readFileSync } from 'node:fs';
|
|
4
|
-
import { join } from 'node:path';
|
|
3
|
+
import { existsSync, readFileSync, statSync } from 'node:fs';
|
|
4
|
+
import { join, resolve, sep } from 'node:path';
|
|
5
5
|
import { fileURLToPath } from 'node:url';
|
|
6
6
|
import { build, createServer } from 'vite';
|
|
7
7
|
import { startVitest } from 'vitest/node';
|
|
8
|
+
import { estUnEcranDesChoses } from './page.js';
|
|
8
9
|
// La configuration Vite de la page de l'espace d'une pièce (bibliotheque/CLAUDE.md, « Écrire une
|
|
9
10
|
// page ») : le dossier de la pièce a son `module.json` et sa page dans `espace/` (`espace/index.html`,
|
|
10
11
|
// qui lance `espace/page.tsx`). `construireLaPage` écrit le dossier construit, `dist/` ;
|
|
@@ -29,12 +30,14 @@ const dependancesDuNavigateur = /^(react|react-dom|@tanstack\/react-router|@tans
|
|
|
29
30
|
// Le port du serveur de développement.
|
|
30
31
|
export const portDeDeveloppement = 5173;
|
|
31
32
|
// Ce que le `module.json` de la pièce dit de sa page : son nom, sa base (`/` pour le core,
|
|
32
|
-
// `/<app>/` pour une app) et son premier écran, où mène la racine en développement
|
|
33
|
+
// `/<app>/` pour une app) et son premier écran, où mène la racine en développement : le premier de
|
|
34
|
+
// ses écrans, sinon ses réglages, comme la racine de l'app (`creerLaRacine`).
|
|
33
35
|
export function lirePiece(dossier) {
|
|
34
36
|
const manifeste = JSON.parse(readFileSync(join(dossier, 'module.json'), 'utf8'));
|
|
35
37
|
const base = manifeste.nom === 'core' ? '/' : `/${manifeste.nom}/`;
|
|
36
38
|
const [premier] = manifeste.ecrans ?? [];
|
|
37
|
-
|
|
39
|
+
const premierEcran = premier ? `${base}${premier.nom}` : manifeste.reglages ? `${base}reglages` : base;
|
|
40
|
+
return { nom: manifeste.nom, base, premierEcran };
|
|
38
41
|
}
|
|
39
42
|
// Les règles de la page, communes au build et au développement :
|
|
40
43
|
// - les dépendances du navigateur se résolvent depuis la bibliothèque ;
|
|
@@ -93,13 +96,57 @@ function configuration(dossier, base) {
|
|
|
93
96
|
export async function construireLaPage(dossier) {
|
|
94
97
|
await build({ ...configuration(dossier, lirePiece(dossier).base), mode: 'production' });
|
|
95
98
|
}
|
|
99
|
+
// Les chemins sous la base d'une app que le serveur de développement garde, sans les relayer à
|
|
100
|
+
// l'app : les siens, d'où Vite sert la page et ses modules (`@vite/client`, `@react-refresh`,
|
|
101
|
+
// `@fs/…`, `@id/…`, et chaque fichier du dossier `espace/`, comme `<base>page.tsx`) ; le websocket du
|
|
102
|
+
// rechargement à chaud (son protocole, `vite-hmr` ou `vite-ping`) ; et le `GET` d'un écran du
|
|
103
|
+
// manifeste, dont il sert la page : `<base><écran>` et ce qui est dessous, `<base>reglages` pour une
|
|
104
|
+
// app qui a des réglages, et, pour une app à choses (son écran `liste`), l'écran d'une chose et la
|
|
105
|
+
// chose seule (`estUnEcranDesChoses`). La fonction rendue le dit d'une requête.
|
|
106
|
+
export function cheminsGardes(dossier) {
|
|
107
|
+
const page = join(dossier, 'espace');
|
|
108
|
+
const { base } = lirePiece(dossier);
|
|
109
|
+
const manifeste = JSON.parse(readFileSync(join(dossier, 'module.json'), 'utf8'));
|
|
110
|
+
const ecrans = (manifeste.ecrans ?? []).map(({ nom }) => nom);
|
|
111
|
+
if (manifeste.reglages) {
|
|
112
|
+
ecrans.push('reglages');
|
|
113
|
+
}
|
|
114
|
+
const aChoses = ecrans.includes('liste');
|
|
115
|
+
function fichierDeLaPage(dansLaBase) {
|
|
116
|
+
try {
|
|
117
|
+
const fichier = resolve(page, decodeURIComponent(dansLaBase));
|
|
118
|
+
return fichier.startsWith(`${page}${sep}`) && statSync(fichier).isFile();
|
|
119
|
+
}
|
|
120
|
+
catch {
|
|
121
|
+
return false;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
return function garde(requete) {
|
|
125
|
+
const chemin = new URL(requete.url ?? '/', 'http://localhost').pathname;
|
|
126
|
+
if (!chemin.startsWith(base)) {
|
|
127
|
+
return false;
|
|
128
|
+
}
|
|
129
|
+
const dansLaBase = chemin.slice(base.length);
|
|
130
|
+
if (dansLaBase.startsWith('@') || fichierDeLaPage(dansLaBase)) {
|
|
131
|
+
return true;
|
|
132
|
+
}
|
|
133
|
+
if (requete.headers.upgrade) {
|
|
134
|
+
return ['vite-hmr', 'vite-ping'].includes(requete.headers['sec-websocket-protocol'] ?? '');
|
|
135
|
+
}
|
|
136
|
+
if (requete.method !== 'GET' && requete.method !== 'HEAD') {
|
|
137
|
+
return false;
|
|
138
|
+
}
|
|
139
|
+
return ecrans.some((ecran) => dansLaBase === ecran || dansLaBase.startsWith(`${ecran}/`)) || (aChoses && estUnEcranDesChoses(`/${dansLaBase}`));
|
|
140
|
+
};
|
|
141
|
+
}
|
|
96
142
|
// Les relais du serveur de développement. Vers le core : la connexion et l'auth, la session, le
|
|
97
143
|
// thème et les gestes du core (sous `/espace/`), en lui présentant son origine et son hôte, ses
|
|
98
144
|
// cookies posés pour le serveur de développement, et ses renvois vers lui-même ramenés au serveur
|
|
99
145
|
// de développement. `/theme/variables.css` cite les polices à l'adresse publique du core : le relais
|
|
100
146
|
// la ramène au serveur de développement, d'où la page charge les polices, de sa propre origine. Vers
|
|
101
|
-
// l'app lancée en local (une app, pas le core) : ce
|
|
102
|
-
//
|
|
147
|
+
// l'app lancée en local (une app, pas le core) : tout ce qui est sous sa base et que `garde` ne
|
|
148
|
+
// garde pas, quelle qu'en soit la méthode, websockets compris, sans le chemin de l'app, comme le
|
|
149
|
+
// proxy du serveur, avec l'origine et l'hôte du serveur de développement.
|
|
103
150
|
export function relais(options) {
|
|
104
151
|
const origineDuCore = new URL(options.core).origin;
|
|
105
152
|
const versLeCore = {
|
|
@@ -145,17 +192,17 @@ export function relais(options) {
|
|
|
145
192
|
if (options.base !== '/') {
|
|
146
193
|
relais[`^${options.base}`] = {
|
|
147
194
|
target: new URL(options.app).origin,
|
|
148
|
-
|
|
149
|
-
bypass: (requete) => (requete
|
|
195
|
+
ws: true,
|
|
196
|
+
bypass: (requete) => (options.garde(requete) ? requete.url : undefined),
|
|
150
197
|
rewrite: (chemin) => chemin.slice(options.base.length - 1),
|
|
151
198
|
};
|
|
152
199
|
}
|
|
153
200
|
return relais;
|
|
154
201
|
}
|
|
155
|
-
//
|
|
156
|
-
// d'essai ou un core local) et, pour une app, à l'app lancée en local à
|
|
157
|
-
// le core ramène à `/` : pour une app, la racine mène à son premier écran.
|
|
158
|
-
export
|
|
202
|
+
// La configuration du serveur de développement de la pièce, sur `http://localhost:5173`, reliée au
|
|
203
|
+
// core de `core` (le banc d'essai ou un core local) et, pour une app, à l'app lancée en local à
|
|
204
|
+
// `app`. Après la connexion, le core ramène à `/` : pour une app, la racine mène à son premier écran.
|
|
205
|
+
export function configurationDuDeveloppement(dossier, options) {
|
|
159
206
|
const piece = lirePiece(dossier);
|
|
160
207
|
const racine = {
|
|
161
208
|
name: 'indos:racine-en-developpement',
|
|
@@ -172,12 +219,16 @@ export async function developperLaPage(dossier, options) {
|
|
|
172
219
|
},
|
|
173
220
|
};
|
|
174
221
|
const config = configuration(dossier, piece.base);
|
|
175
|
-
|
|
222
|
+
return {
|
|
176
223
|
...config,
|
|
177
224
|
mode: 'development',
|
|
178
225
|
plugins: [...(config.plugins ?? []), racine],
|
|
179
|
-
server: { ...config.server, port: portDeDeveloppement, strictPort: true, proxy: relais({ base: piece.base, core: options.core, app: options.app }) },
|
|
180
|
-
}
|
|
226
|
+
server: { ...config.server, port: portDeDeveloppement, strictPort: true, proxy: relais({ base: piece.base, core: options.core, app: options.app, garde: cheminsGardes(dossier) }) },
|
|
227
|
+
};
|
|
228
|
+
}
|
|
229
|
+
// Sert la page de la pièce à chaud sur `http://localhost:5173` (`configurationDuDeveloppement`).
|
|
230
|
+
export async function developperLaPage(dossier, options) {
|
|
231
|
+
const serveur = await createServer(configurationDuDeveloppement(dossier, options));
|
|
181
232
|
await serveur.listen();
|
|
182
233
|
serveur.printUrls();
|
|
183
234
|
return serveur;
|