@indos/bibliotheque 0.0.0-stage → 1.0.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 +31 -0
- package/LICENSE +21 -0
- package/README.md +8 -2
- package/bin/page-de-l-espace.d.ts +1 -0
- package/bin/page-de-l-espace.js +29 -0
- package/modeles/partage.sql +16 -0
- package/package.json +117 -4
- package/src/app.d.ts +3 -0
- package/src/app.js +30 -0
- package/src/appel-d-ecran.d.ts +18 -0
- package/src/appel-d-ecran.js +82 -0
- package/src/appeler.d.ts +13 -0
- package/src/appeler.js +33 -0
- package/src/base-d-essai.d.ts +4 -0
- package/src/base-d-essai.js +18 -0
- package/src/base.d.ts +3 -0
- package/src/base.js +49 -0
- package/src/compte.d.ts +53 -0
- package/src/compte.js +176 -0
- package/src/deriver.d.ts +2 -0
- package/src/deriver.js +28 -0
- package/src/description-des-comptes.d.ts +50 -0
- package/src/description-des-comptes.js +4 -0
- package/src/ecran.d.ts +90 -0
- package/src/ecran.js +139 -0
- package/src/espace/appel.d.ts +10 -0
- package/src/espace/appel.js +20 -0
- package/src/espace/appels.d.ts +23 -0
- package/src/espace/appels.js +81 -0
- package/src/espace/comptes.d.ts +1 -0
- package/src/espace/comptes.js +180 -0
- package/src/espace/contexte.d.ts +8 -0
- package/src/espace/contexte.js +6 -0
- package/src/espace/coquille.d.ts +2 -0
- package/src/espace/coquille.js +76 -0
- package/src/espace/ecran.d.ts +10 -0
- package/src/espace/ecran.js +23 -0
- package/src/espace/entree-active.d.ts +2 -0
- package/src/espace/entree-active.js +21 -0
- package/src/espace/erreur.d.ts +3 -0
- package/src/espace/erreur.js +23 -0
- package/src/espace/heure.d.ts +1 -0
- package/src/espace/heure.js +14 -0
- package/src/espace/index.d.ts +12 -0
- package/src/espace/index.js +13 -0
- package/src/espace/lancer.d.ts +3 -0
- package/src/espace/lancer.js +13 -0
- package/src/espace/lien.d.ts +6 -0
- package/src/espace/lien.js +43 -0
- package/src/espace/navigation.d.ts +1 -0
- package/src/espace/navigation.js +5 -0
- package/src/espace/page.d.ts +25 -0
- package/src/espace/page.js +51 -0
- package/src/espace/pagination.d.ts +8 -0
- package/src/espace/pagination.js +19 -0
- package/src/espace/session.d.ts +37 -0
- package/src/espace/session.js +13 -0
- package/src/faux-core.d.ts +29 -0
- package/src/faux-core.js +112 -0
- package/src/fichiers.d.ts +32 -0
- package/src/fichiers.js +97 -0
- package/src/jeton.d.ts +10 -0
- package/src/jeton.js +96 -0
- package/src/liens.d.ts +10 -0
- package/src/liens.js +52 -0
- package/src/mcp.d.ts +20 -0
- package/src/mcp.js +153 -0
- package/src/page.d.ts +17 -0
- package/src/page.js +127 -0
- package/src/pagination.d.ts +1 -0
- package/src/pagination.js +4 -0
- package/src/partage.d.ts +62 -0
- package/src/partage.js +248 -0
- package/src/session.d.ts +17 -0
- package/src/session.js +124 -0
- package/src/theme.d.ts +2 -0
- package/src/theme.js +52 -0
- package/src/type-de-fichier.d.ts +6 -0
- package/src/type-de-fichier.js +115 -0
- package/src/ui/annonce.d.ts +7 -0
- package/src/ui/annonce.js +18 -0
- package/src/ui/blocs.d.ts +44 -0
- package/src/ui/blocs.js +34 -0
- package/src/ui/bouton.d.ts +7 -0
- package/src/ui/bouton.js +13 -0
- package/src/ui/cases.d.ts +19 -0
- package/src/ui/cases.js +17 -0
- package/src/ui/champ.d.ts +21 -0
- package/src/ui/champ.js +25 -0
- package/src/ui/choix.d.ts +16 -0
- package/src/ui/choix.js +11 -0
- package/src/ui/classes.d.ts +2 -0
- package/src/ui/classes.js +7 -0
- package/src/ui/confirmation.d.ts +12 -0
- package/src/ui/confirmation.js +6 -0
- package/src/ui/fenetre.d.ts +13 -0
- package/src/ui/fenetre.js +40 -0
- package/src/ui/graphiques.d.ts +44 -0
- package/src/ui/graphiques.js +128 -0
- package/src/ui/index.d.ts +18 -0
- package/src/ui/index.js +20 -0
- package/src/ui/lien.d.ts +8 -0
- package/src/ui/lien.js +10 -0
- package/src/ui/menu.d.ts +8 -0
- package/src/ui/menu.js +20 -0
- package/src/ui/panneau.d.ts +12 -0
- package/src/ui/panneau.js +17 -0
- package/src/ui/repli.d.ts +12 -0
- package/src/ui/repli.js +6 -0
- package/src/ui/suggestions.d.ts +14 -0
- package/src/ui/suggestions.js +54 -0
- package/src/ui/tableau.d.ts +18 -0
- package/src/ui/tableau.js +28 -0
- package/src/ui/theme.css +112 -0
- package/src/ui/vues.d.ts +15 -0
- package/src/ui/vues.js +7 -0
- package/src/vite.d.ts +19 -0
- package/src/vite.js +195 -0
- package/tsconfig.page.json +30 -0
package/src/mcp.js
ADDED
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
import { toNodeHandler } from '@modelcontextprotocol/node';
|
|
2
|
+
import { createMcpHandler, Server } from '@modelcontextprotocol/server';
|
|
3
|
+
import { AjvJsonSchemaValidator } from '@modelcontextprotocol/server/validators/ajv';
|
|
4
|
+
import { creerLeVerificateur, JetonRefuse } from './jeton.js';
|
|
5
|
+
import { repondreEnJson, traiterUnAppelDEcran } from './appel-d-ecran.js';
|
|
6
|
+
import { creerLaSession } from './session.js';
|
|
7
|
+
// Le refus d'un outil (docs/architecture.md, « Les règles communes ») : l'outil ne fait pas ce
|
|
8
|
+
// qu'on lui demande, parce que l'accord de la personne manque (`confirmer`), qu'elle n'y a pas
|
|
9
|
+
// droit, ou que la donnée est refusée. Levé dans `executer`, il rend une erreur d'outil marquée
|
|
10
|
+
// `_meta['indos/refus']`, avec son texte tel quel : le core l'écrit refusée au journal.
|
|
11
|
+
export class Refus extends Error {
|
|
12
|
+
}
|
|
13
|
+
// Le MCP d'une app, sur /mcp : Streamable HTTP sans état, MCP standard, par le SDK officiel.
|
|
14
|
+
// Chaque requête porte le jeton court du core ; l'app ne montre et n'exécute que les outils
|
|
15
|
+
// auxquels la personne a droit (docs/architecture.md, « Le contrat entre le MCP et une app »).
|
|
16
|
+
// Les instructions sont le texte d'usage de l'app. Le même traitement sert les outils aux écrans
|
|
17
|
+
// de l'app, dans le navigateur, avec la session de la personne : `POST /outils/<nom>`. `adresse`
|
|
18
|
+
// est l'adresse publique de l'app (ADRESSE), dont l'origine est la seule que l'appel admet.
|
|
19
|
+
export function creerLeMcp(options) {
|
|
20
|
+
let verifier;
|
|
21
|
+
let session;
|
|
22
|
+
const validateur = new AjvJsonSchemaValidator();
|
|
23
|
+
// Le type du schéma d'outil du SDK et celui de son validateur diffèrent ; c'est le même JSON.
|
|
24
|
+
const validations = new Map(options.outils.map((outil) => [outil.nom, validateur.getValidator(outil.schema)]));
|
|
25
|
+
// L'appel d'un outil pour la personne, par Claude ou par un écran : le résultat tel que le MCP le
|
|
26
|
+
// rend, et le statut que l'écran en reçoit. Un outil inconnu (404) et un outil que la personne
|
|
27
|
+
// n'a pas le droit d'appeler (403) sont refusés du même texte.
|
|
28
|
+
async function appelerLOutil(nom, arguments_, personne) {
|
|
29
|
+
const outil = options.outils.find((candidat) => candidat.nom === nom);
|
|
30
|
+
if (!outil || (outil.pour && !outil.pour(personne))) {
|
|
31
|
+
return { statut: outil ? 403 : 404, resultat: resultatDuRefus(`L'outil ${nom} n'existe pas pour vous.`) };
|
|
32
|
+
}
|
|
33
|
+
const validation = validations.get(outil.nom)?.(arguments_);
|
|
34
|
+
if (validation && !validation.valid) {
|
|
35
|
+
return { statut: 400, resultat: erreurDOutil(`Les arguments de ${outil.nom} ne conviennent pas : ${validation.errorMessage}`) };
|
|
36
|
+
}
|
|
37
|
+
try {
|
|
38
|
+
return { statut: 200, resultat: { content: [{ type: 'text', text: await outil.executer(arguments_, personne) }] } };
|
|
39
|
+
}
|
|
40
|
+
catch (erreur) {
|
|
41
|
+
if (erreur instanceof Refus) {
|
|
42
|
+
return { statut: 422, resultat: resultatDuRefus(erreur.message) };
|
|
43
|
+
}
|
|
44
|
+
console.error(erreur);
|
|
45
|
+
return { statut: 500, resultat: erreurDOutil(`${outil.nom} a échoué : ${erreur.message}`) };
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
const traiterLeMcp = toNodeHandler(createMcpHandler((contexte) => {
|
|
49
|
+
const personne = contexte.authInfo?.extra?.personne;
|
|
50
|
+
const serveur = new Server({ name: options.app, version: options.version }, { capabilities: { tools: {} }, instructions: options.instructions });
|
|
51
|
+
serveur.setRequestHandler('tools/list', async () => ({
|
|
52
|
+
tools: options.outils
|
|
53
|
+
.filter((outil) => !outil.pour || outil.pour(personne))
|
|
54
|
+
.map((outil) => ({ name: outil.nom, description: outil.description, inputSchema: outil.schema })),
|
|
55
|
+
}));
|
|
56
|
+
serveur.setRequestHandler('tools/call', async (requete) => ((await appelerLOutil(requete.params.name, requete.params.arguments ?? {}, personne)).resultat));
|
|
57
|
+
return serveur;
|
|
58
|
+
}));
|
|
59
|
+
// `POST /outils/<nom>` : l'appel d'un outil par un écran de l'app, pour la personne connectée au
|
|
60
|
+
// core (docs/architecture.md, « L'espace et les réglages »), par les règles d'un geste d'écran
|
|
61
|
+
// (`traiterUnAppelDEcran`) : la méthode (405), l'origine de l'app, avant tout appel au core (403),
|
|
62
|
+
// la session (401), l'app ouverte à la personne, parmi les apps de sa session (403), un corps en
|
|
63
|
+
// JSON (415), de 4 Mio au plus (413), un objet (400) ; puis l'outil, avec ses droits et ses refus,
|
|
64
|
+
// comme pour Claude, son résultat MCP rendu tel quel. Un échec ne dit rien de sa cause. Le core ne
|
|
65
|
+
// voit que la question de la session : l'appel ne s'écrit pas au journal.
|
|
66
|
+
async function appelerDepuisUnEcran(requete, reponse, nom, adresse) {
|
|
67
|
+
if (!adresse && requete.method === 'POST') {
|
|
68
|
+
repondreEnJson(reponse, 503, { erreur: 'La variable ADRESSE manque : l\'adresse publique de l\'app vient du kit.' });
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
await traiterUnAppelDEcran(requete, reponse, {
|
|
72
|
+
origine: adresse ? new URL(adresse).origin : '',
|
|
73
|
+
async personneDe(requete) {
|
|
74
|
+
session ??= creerLaSession(adresse, options.adresseDuCore);
|
|
75
|
+
const lue = await session.lireLaSession(requete);
|
|
76
|
+
if (!lue) {
|
|
77
|
+
return undefined;
|
|
78
|
+
}
|
|
79
|
+
if (!lue.ouvre(options.app)) {
|
|
80
|
+
return 'fermee';
|
|
81
|
+
}
|
|
82
|
+
const { id, email, nom: nomDeLaPersonne, proprietaire, groupes } = lue.personne;
|
|
83
|
+
return { id, email, nom: nomDeLaPersonne, proprietaire, groupes };
|
|
84
|
+
},
|
|
85
|
+
textes: {
|
|
86
|
+
methode: 'Un outil s\'appelle en POST.',
|
|
87
|
+
type: 'Les arguments d\'un outil partent en JSON (Content-Type: application/json).',
|
|
88
|
+
taille: 'Les arguments dépassent 4 Mio.',
|
|
89
|
+
objet: 'Les arguments d\'un outil sont un objet JSON.',
|
|
90
|
+
},
|
|
91
|
+
async accepter(personne, arguments_) {
|
|
92
|
+
const { statut, resultat } = await appelerLOutil(nom, arguments_, personne);
|
|
93
|
+
return { statut, corps: statut === 500 ? erreurDOutil(`${nom} a échoué.`) : resultat };
|
|
94
|
+
},
|
|
95
|
+
});
|
|
96
|
+
}
|
|
97
|
+
// Le traitement de `/mcp` et de `/outils/<nom>`, que la requête arrive avec ou sans le chemin de
|
|
98
|
+
// l'app.
|
|
99
|
+
return async function traiter(requete, reponse) {
|
|
100
|
+
const adresse = options.adresse ?? process.env.ADRESSE;
|
|
101
|
+
const outil = /^\/outils\/([^/]+)$/.exec(cheminDansLApp(requete, adresse))?.[1];
|
|
102
|
+
if (outil) {
|
|
103
|
+
await appelerDepuisUnEcran(requete, reponse, outil, adresse);
|
|
104
|
+
return;
|
|
105
|
+
}
|
|
106
|
+
try {
|
|
107
|
+
verifier ??= creerLeVerificateur(options.app, options.adresseDuCore);
|
|
108
|
+
}
|
|
109
|
+
catch (erreur) {
|
|
110
|
+
envoyer(reponse, 503, { erreur: erreur.message });
|
|
111
|
+
return;
|
|
112
|
+
}
|
|
113
|
+
const jeton = /^Bearer (.+)$/.exec(requete.headers.authorization ?? '')?.[1];
|
|
114
|
+
let personne;
|
|
115
|
+
try {
|
|
116
|
+
if (!jeton) {
|
|
117
|
+
throw new JetonRefuse('Le jeton du core manque.');
|
|
118
|
+
}
|
|
119
|
+
personne = await verifier(jeton);
|
|
120
|
+
}
|
|
121
|
+
catch (erreur) {
|
|
122
|
+
if (erreur instanceof JetonRefuse) {
|
|
123
|
+
envoyer(reponse, 401, { erreur: erreur.message });
|
|
124
|
+
}
|
|
125
|
+
else {
|
|
126
|
+
envoyer(reponse, 503, { erreur: `Le core ne répond pas : ${erreur.message}` });
|
|
127
|
+
}
|
|
128
|
+
return;
|
|
129
|
+
}
|
|
130
|
+
// L'adaptateur du SDK passe `auth` au serveur de la requête, qui y lit la personne.
|
|
131
|
+
Object.assign(requete, { auth: { token: jeton, clientId: 'core', scopes: [], extra: { personne } } });
|
|
132
|
+
await traiterLeMcp(requete, reponse);
|
|
133
|
+
};
|
|
134
|
+
}
|
|
135
|
+
// Le chemin de la requête dans l'app : le proxy de Coolify retire le chemin de l'app, retiré ici
|
|
136
|
+
// s'il arrive quand même.
|
|
137
|
+
function cheminDansLApp(requete, adresse) {
|
|
138
|
+
const chemin = new URL(requete.url ?? '/', 'http://app').pathname;
|
|
139
|
+
const prefixe = adresse ? new URL(adresse).pathname.replace(/\/$/, '') : '';
|
|
140
|
+
return prefixe && chemin.startsWith(`${prefixe}/`) ? chemin.slice(prefixe.length) : chemin;
|
|
141
|
+
}
|
|
142
|
+
function erreurDOutil(texte) {
|
|
143
|
+
return { content: [{ type: 'text', text: texte }], isError: true };
|
|
144
|
+
}
|
|
145
|
+
// Un refus : une erreur d'outil marquée, que le core écrit refusée au journal et que l'app qui
|
|
146
|
+
// appelle reconnaît par `estUnRefus` (`@indos/bibliotheque/appeler`).
|
|
147
|
+
function resultatDuRefus(texte) {
|
|
148
|
+
return { ...erreurDOutil(texte), _meta: { 'indos/refus': true } };
|
|
149
|
+
}
|
|
150
|
+
function envoyer(reponse, statut, corps) {
|
|
151
|
+
reponse.writeHead(statut, { 'content-type': 'application/json; charset=utf-8' });
|
|
152
|
+
reponse.end(JSON.stringify(corps));
|
|
153
|
+
}
|
package/src/page.d.ts
ADDED
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
2
|
+
export { lignesParPage } from './pagination.ts';
|
|
3
|
+
export type SessionDeLaPage = {
|
|
4
|
+
personneDe: (requete: IncomingMessage) => Promise<unknown>;
|
|
5
|
+
envoyerALaConnexion: (requete: IncomingMessage, reponse: ServerResponse) => void;
|
|
6
|
+
};
|
|
7
|
+
export declare function servirLaPage(options: {
|
|
8
|
+
dist: string | URL;
|
|
9
|
+
session?: SessionDeLaPage;
|
|
10
|
+
cadre?: string;
|
|
11
|
+
entetes?: Record<string, string>;
|
|
12
|
+
}): (requete: IncomingMessage, reponse: ServerResponse, chemin: string) => Promise<void>;
|
|
13
|
+
export declare function traiterUnGesteDEcran<P>(requete: IncomingMessage, reponse: ServerResponse, options: {
|
|
14
|
+
origine: string;
|
|
15
|
+
personneDe: (requete: IncomingMessage) => Promise<P | 'fermee' | undefined>;
|
|
16
|
+
executer: (personne: P, corps: Record<string, unknown>, requete: IncomingMessage, reponse: ServerResponse) => Promise<unknown>;
|
|
17
|
+
}): Promise<void>;
|
package/src/page.js
ADDED
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
|
|
2
|
+
import { extname, join } from 'node:path';
|
|
3
|
+
import { fileURLToPath } from 'node:url';
|
|
4
|
+
import { traiterUnAppelDEcran } from './appel-d-ecran.js';
|
|
5
|
+
import { entetesDeLEspace, envoyerLaPage, pageSimple } from './ecran.js';
|
|
6
|
+
import { Refus } from './mcp.js';
|
|
7
|
+
import { creerLaSession } from './session.js';
|
|
8
|
+
// La page de l'espace d'une pièce, le core ou une app (docs/architecture.md, « L'espace et les
|
|
9
|
+
// réglages ») : une page en React, construite par Vite dans son dossier `dist/`, que sert la pièce
|
|
10
|
+
// elle-même. `dist/index.html` est la page ; ses fichiers, nommés par leur empreinte, sont sous
|
|
11
|
+
// `dist/espace/`, et la page les cite sous `<base>espace/…`.
|
|
12
|
+
// Le nombre de lignes d'une page d'une liste : un geste ou un outil paginé reçoit `page`, un entier
|
|
13
|
+
// à partir de 1, et rend `{ lignes, total }`.
|
|
14
|
+
export { lignesParPage } from './pagination.js';
|
|
15
|
+
// Les types des fichiers construits, par leur extension.
|
|
16
|
+
const types = {
|
|
17
|
+
'.js': 'text/javascript; charset=utf-8',
|
|
18
|
+
'.mjs': 'text/javascript; charset=utf-8',
|
|
19
|
+
'.css': 'text/css; charset=utf-8',
|
|
20
|
+
'.map': 'application/json; charset=utf-8',
|
|
21
|
+
'.json': 'application/json; charset=utf-8',
|
|
22
|
+
'.svg': 'image/svg+xml',
|
|
23
|
+
'.png': 'image/png',
|
|
24
|
+
'.jpg': 'image/jpeg',
|
|
25
|
+
'.jpeg': 'image/jpeg',
|
|
26
|
+
'.gif': 'image/gif',
|
|
27
|
+
'.webp': 'image/webp',
|
|
28
|
+
'.ico': 'image/x-icon',
|
|
29
|
+
'.woff': 'font/woff',
|
|
30
|
+
'.woff2': 'font/woff2',
|
|
31
|
+
'.txt': 'text/plain; charset=utf-8',
|
|
32
|
+
};
|
|
33
|
+
// Sert la page de l'espace d'une pièce, depuis son dossier construit, lu une fois, à la création.
|
|
34
|
+
// Il rend `traiter(requete, reponse, chemin)`, à qui la pièce confie les chemins de ses écrans et
|
|
35
|
+
// `/espace/…` ; `chemin` est celui de la requête dans la pièce, sans son préfixe.
|
|
36
|
+
// - `/espace/<fichier>` : un fichier construit, gardé un an par le navigateur (son nom change avec
|
|
37
|
+
// son contenu), sans question au core ; un fichier absent, la page simple en 404.
|
|
38
|
+
// - tout autre chemin : la page, pour la personne que rend `session.personneDe`, avec la politique
|
|
39
|
+
// de l'espace (`entetesDeLEspace(cadre)`) et `entetes` ; sinon `session.envoyerALaConnexion`.
|
|
40
|
+
// Seuls `GET` et `HEAD` sont servis. Sans `dist/index.html`, la pièce ne démarre pas.
|
|
41
|
+
export function servirLaPage(options) {
|
|
42
|
+
const dossier = typeof options.dist === 'string' ? options.dist : fileURLToPath(options.dist);
|
|
43
|
+
const index = join(dossier, 'index.html');
|
|
44
|
+
if (!existsSync(index)) {
|
|
45
|
+
throw new Error(`La page n'est pas construite : ${index} manque (npm run build).`);
|
|
46
|
+
}
|
|
47
|
+
const page = readFileSync(index);
|
|
48
|
+
const entetesDeLaPage = { ...entetesDeLEspace(options.cadre), ...options.entetes, 'content-length': String(page.length) };
|
|
49
|
+
const fichiers = lireLesFichiers(join(dossier, 'espace'));
|
|
50
|
+
const session = options.session ?? creerLaSession();
|
|
51
|
+
return async function traiter(requete, reponse, chemin) {
|
|
52
|
+
if (requete.method !== 'GET' && requete.method !== 'HEAD') {
|
|
53
|
+
reponse.writeHead(405, { allow: 'GET, HEAD', 'content-type': 'text/plain; charset=utf-8' });
|
|
54
|
+
reponse.end('Une page se lit en GET.');
|
|
55
|
+
return;
|
|
56
|
+
}
|
|
57
|
+
const lecture = requete.method === 'GET';
|
|
58
|
+
const demande = chemin.split('?')[0];
|
|
59
|
+
if (demande === '/espace' || demande.startsWith('/espace/')) {
|
|
60
|
+
const fichier = fichiers.get(demande.slice('/espace/'.length));
|
|
61
|
+
if (!fichier) {
|
|
62
|
+
envoyerLaPage(reponse, 404, pageSimple('Introuvable', 'Cette page n\'existe pas.'));
|
|
63
|
+
return;
|
|
64
|
+
}
|
|
65
|
+
reponse.writeHead(200, {
|
|
66
|
+
'content-type': fichier.type,
|
|
67
|
+
'content-length': String(fichier.octets.length),
|
|
68
|
+
'cache-control': 'public, max-age=31536000, immutable',
|
|
69
|
+
'x-content-type-options': 'nosniff',
|
|
70
|
+
});
|
|
71
|
+
reponse.end(lecture ? fichier.octets : undefined);
|
|
72
|
+
return;
|
|
73
|
+
}
|
|
74
|
+
if (!(await session.personneDe(requete))) {
|
|
75
|
+
session.envoyerALaConnexion(requete, reponse);
|
|
76
|
+
return;
|
|
77
|
+
}
|
|
78
|
+
reponse.writeHead(200, entetesDeLaPage);
|
|
79
|
+
reponse.end(lecture ? page : undefined);
|
|
80
|
+
};
|
|
81
|
+
}
|
|
82
|
+
// Les fichiers construits sous `dist/espace/`, par leur chemin sous ce dossier.
|
|
83
|
+
function lireLesFichiers(dossier) {
|
|
84
|
+
const fichiers = new Map();
|
|
85
|
+
if (!existsSync(dossier)) {
|
|
86
|
+
return fichiers;
|
|
87
|
+
}
|
|
88
|
+
for (const nom of readdirSync(dossier, { recursive: true, encoding: 'utf8' })) {
|
|
89
|
+
const chemin = join(dossier, nom);
|
|
90
|
+
if (statSync(chemin).isFile()) {
|
|
91
|
+
fichiers.set(nom.split('\\').join('/'), { octets: readFileSync(chemin), type: types[extname(nom).toLowerCase()] ?? 'application/octet-stream' });
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
return fichiers;
|
|
95
|
+
}
|
|
96
|
+
// Un geste d'écran : un appel de la page de l'espace à sa pièce, en JSON, pour un geste que Claude
|
|
97
|
+
// ne doit pas voir (docs/architecture.md, « Les règles communes »). Les règles d'un appel d'écran
|
|
98
|
+
// (`traiterUnAppelDEcran`) : `POST` (405), l'origine de la page, `origine` (403), la personne que
|
|
99
|
+
// rend `personneDe` (401, 403 pour une app fermée, 503 si le core ne répond pas), un objet JSON de
|
|
100
|
+
// 4 Mio au plus (415, 413, 400). Puis `executer` : sa valeur en 200 (`{}` pour rien) ; un `Refus`
|
|
101
|
+
// en 422, `{ erreur }`, son texte ; une autre erreur en 500, sans sa cause, écrite au journal de
|
|
102
|
+
// l'app. `executer` peut poser un cookie par `reponse.setHeader` ; il n'écrit jamais la réponse.
|
|
103
|
+
// Le geste ne passe pas par le core et ne s'écrit pas au journal.
|
|
104
|
+
export async function traiterUnGesteDEcran(requete, reponse, options) {
|
|
105
|
+
await traiterUnAppelDEcran(requete, reponse, {
|
|
106
|
+
origine: options.origine,
|
|
107
|
+
personneDe: options.personneDe,
|
|
108
|
+
textes: {
|
|
109
|
+
methode: 'Un geste s\'appelle en POST.',
|
|
110
|
+
type: 'Un geste part en JSON (Content-Type: application/json).',
|
|
111
|
+
taille: 'Le geste dépasse 4 Mio.',
|
|
112
|
+
objet: 'Un geste est un objet JSON.',
|
|
113
|
+
},
|
|
114
|
+
async accepter(personne, corps) {
|
|
115
|
+
try {
|
|
116
|
+
return { statut: 200, corps: (await options.executer(personne, corps, requete, reponse)) ?? {} };
|
|
117
|
+
}
|
|
118
|
+
catch (erreur) {
|
|
119
|
+
if (erreur instanceof Refus) {
|
|
120
|
+
return { statut: 422, corps: { erreur: erreur.message } };
|
|
121
|
+
}
|
|
122
|
+
console.error(erreur);
|
|
123
|
+
return { statut: 500, corps: { erreur: 'Le geste a échoué.' } };
|
|
124
|
+
}
|
|
125
|
+
},
|
|
126
|
+
});
|
|
127
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export declare const lignesParPage = 25;
|
|
@@ -0,0 +1,4 @@
|
|
|
1
|
+
// Le nombre de lignes d'une page d'une liste, le même partout : pour le geste ou l'outil paginé
|
|
2
|
+
// (`@indos/bibliotheque/page`) comme pour le tableau qui la montre (`@indos/bibliotheque/ui`). Sans
|
|
3
|
+
// rien de Node ni du navigateur, pour que les deux l'importent.
|
|
4
|
+
export const lignesParPage = 25;
|
package/src/partage.d.ts
ADDED
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
import type pg from 'pg';
|
|
2
|
+
import type { Personne } from './jeton.ts';
|
|
3
|
+
import { type Outil } from './mcp.ts';
|
|
4
|
+
export type Droit = 'lecture' | 'modification';
|
|
5
|
+
export type DroitSurLaChose = Droit | 'proprietaire';
|
|
6
|
+
export type PersonneDeLAnnuaire = {
|
|
7
|
+
id: string;
|
|
8
|
+
nom: string;
|
|
9
|
+
email: string;
|
|
10
|
+
active: boolean;
|
|
11
|
+
};
|
|
12
|
+
export type GroupeDeLAnnuaire = {
|
|
13
|
+
id: string;
|
|
14
|
+
nom: string;
|
|
15
|
+
membres: string[];
|
|
16
|
+
};
|
|
17
|
+
export type Annuaire = {
|
|
18
|
+
personnes: PersonneDeLAnnuaire[];
|
|
19
|
+
groupes: GroupeDeLAnnuaire[];
|
|
20
|
+
};
|
|
21
|
+
export type Ouverture = {
|
|
22
|
+
avec: 'equipe' | 'personne' | 'groupe';
|
|
23
|
+
nom: string;
|
|
24
|
+
email?: string;
|
|
25
|
+
droit: Droit;
|
|
26
|
+
};
|
|
27
|
+
type Base = Pick<pg.Pool, 'query'>;
|
|
28
|
+
type SchemaDUnArgument = NonNullable<Outil['schema']['properties']>[string];
|
|
29
|
+
export declare const dureeDeLAnnuaire = 5000;
|
|
30
|
+
export declare function suffit(droit: DroitSurLaChose | undefined, attendu: DroitSurLaChose): boolean;
|
|
31
|
+
export declare function ouverturesDe(personne: Personne): string[];
|
|
32
|
+
export declare function creerLAnnuaire(adresseDuCore?: string | undefined, horloge?: () => number): () => Promise<Annuaire>;
|
|
33
|
+
export declare function nomDe(annuaire: Annuaire, id: string): string;
|
|
34
|
+
export declare function partageePar(annuaire: Annuaire, proprietaire: string): string;
|
|
35
|
+
export declare function schemaDePartager(argument: string, schemaDeLaChose: SchemaDUnArgument): Outil['schema'];
|
|
36
|
+
export declare function schemaDeNePlusPartager(argument: string, schemaDeLaChose: SchemaDUnArgument): Outil['schema'];
|
|
37
|
+
export type OptionsDuPartage = {
|
|
38
|
+
base: Base;
|
|
39
|
+
chose: string;
|
|
40
|
+
table?: string;
|
|
41
|
+
proprietaire?: string;
|
|
42
|
+
partage?: string;
|
|
43
|
+
laChose: string;
|
|
44
|
+
absente: (id: string) => string;
|
|
45
|
+
adresseDuCore?: string;
|
|
46
|
+
};
|
|
47
|
+
export declare function creerLePartage(options: OptionsDuPartage): {
|
|
48
|
+
pourLaPersonne: (personne: Personne, { alias, depuis }?: {
|
|
49
|
+
alias?: string;
|
|
50
|
+
depuis?: number;
|
|
51
|
+
}) => {
|
|
52
|
+
ouverte: string;
|
|
53
|
+
droit: string;
|
|
54
|
+
valeurs: (string | string[])[];
|
|
55
|
+
};
|
|
56
|
+
droitSur: (personne: Personne, id: string) => Promise<DroitSurLaChose | undefined>;
|
|
57
|
+
lireLAnnuaire: () => Promise<Annuaire>;
|
|
58
|
+
partageDe(id: string): Promise<Ouverture[]>;
|
|
59
|
+
partager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<Ouverture[]>;
|
|
60
|
+
nePlusPartager(personne: Personne, id: string, arguments_: Record<string, unknown>): Promise<Ouverture[]>;
|
|
61
|
+
};
|
|
62
|
+
export {};
|
package/src/partage.js
ADDED
|
@@ -0,0 +1,248 @@
|
|
|
1
|
+
import { Refus } from './mcp.js';
|
|
2
|
+
// L'annuaire se garde quelques secondes : un partage qui suit un ajout à l'équipe le voit vite.
|
|
3
|
+
export const dureeDeLAnnuaire = 5_000;
|
|
4
|
+
const ordreDesDroits = { lecture: 1, modification: 2, proprietaire: 3 };
|
|
5
|
+
// Un droit suffit-il au geste ? La lecture est contenue dans la modification, et les deux dans la
|
|
6
|
+
// propriété. Aucun droit ne suffit à rien.
|
|
7
|
+
export function suffit(droit, attendu) {
|
|
8
|
+
return droit !== undefined && ordreDesDroits[droit] >= ordreDesDroits[attendu];
|
|
9
|
+
}
|
|
10
|
+
// Les valeurs de `avec` qui ouvrent une chose à la personne : elle, ses groupes, l'équipe.
|
|
11
|
+
export function ouverturesDe(personne) {
|
|
12
|
+
return ['equipe', `personne:${personne.id}`, ...(personne.groupes ?? []).map((groupe) => `groupe:${groupe}`)];
|
|
13
|
+
}
|
|
14
|
+
// Lit l'annuaire du core (`CORE_ADRESSE/annuaire`), gardé `dureeDeLAnnuaire`. Un core qui n'en a
|
|
15
|
+
// pas (d'avant 1.7, 404) rend un annuaire vide ; un core qui ne répond pas lève une erreur, qui
|
|
16
|
+
// n'est pas gardée. `horloge` ne sert qu'aux tests.
|
|
17
|
+
export function creerLAnnuaire(adresseDuCore = process.env.CORE_ADRESSE, horloge = Date.now) {
|
|
18
|
+
let garde;
|
|
19
|
+
return function lireLAnnuaire() {
|
|
20
|
+
if (!adresseDuCore) {
|
|
21
|
+
return Promise.reject(new Error('La variable CORE_ADRESSE manque : l\'adresse interne du core vient du kit.'));
|
|
22
|
+
}
|
|
23
|
+
if (!garde || horloge() - garde.lu >= dureeDeLAnnuaire) {
|
|
24
|
+
const lecture = { lu: horloge(), annuaire: demanderLAnnuaire(new URL('/annuaire', adresseDuCore)) };
|
|
25
|
+
lecture.annuaire.catch(() => {
|
|
26
|
+
if (garde === lecture) {
|
|
27
|
+
garde = undefined;
|
|
28
|
+
}
|
|
29
|
+
});
|
|
30
|
+
garde = lecture;
|
|
31
|
+
}
|
|
32
|
+
return garde.annuaire;
|
|
33
|
+
};
|
|
34
|
+
}
|
|
35
|
+
async function demanderLAnnuaire(adresse) {
|
|
36
|
+
const reponse = await fetch(adresse, { signal: AbortSignal.timeout(5000) });
|
|
37
|
+
if (reponse.status === 404) {
|
|
38
|
+
return { personnes: [], groupes: [] };
|
|
39
|
+
}
|
|
40
|
+
if (!reponse.ok) {
|
|
41
|
+
throw new Error(`Le core ne donne pas l'annuaire : ${reponse.status}.`);
|
|
42
|
+
}
|
|
43
|
+
const { personnes, groupes } = (await reponse.json());
|
|
44
|
+
return {
|
|
45
|
+
personnes: listeDe(personnes).flatMap(({ id, nom, email, active }) => (typeof id === 'string' && typeof nom === 'string' && typeof email === 'string'
|
|
46
|
+
? [{ id, nom, email, active: active !== false }]
|
|
47
|
+
: [])),
|
|
48
|
+
groupes: listeDe(groupes).flatMap(({ id, nom, membres }) => (typeof id === 'string' && typeof nom === 'string'
|
|
49
|
+
? [{ id, nom, membres: Array.isArray(membres) ? membres.filter((membre) => typeof membre === 'string') : [] }]
|
|
50
|
+
: [])),
|
|
51
|
+
};
|
|
52
|
+
}
|
|
53
|
+
function listeDe(valeur) {
|
|
54
|
+
return Array.isArray(valeur) ? valeur.map((element) => (element ?? {})) : [];
|
|
55
|
+
}
|
|
56
|
+
// Le nom d'une personne de l'équipe, pour un écran.
|
|
57
|
+
export function nomDe(annuaire, id) {
|
|
58
|
+
return annuaire.personnes.find((personne) => personne.id === id)?.nom ?? 'une personne inconnue';
|
|
59
|
+
}
|
|
60
|
+
// « partagée par <nom> », pour un écran qui montre une chose ouverte à la personne.
|
|
61
|
+
export function partageePar(annuaire, proprietaire) {
|
|
62
|
+
return `partagée par ${nomDe(annuaire, proprietaire)}`;
|
|
63
|
+
}
|
|
64
|
+
const confirmer = { type: 'boolean', description: 'true seulement après l\'accord explicite de la personne, sur ce qui s\'ouvre et à qui.' };
|
|
65
|
+
const personnes = { type: 'array', maxItems: 50, items: { type: 'string', minLength: 3, maxLength: 320 }, description: 'Les courriels de personnes de l\'équipe.' };
|
|
66
|
+
const groupes = { type: 'array', maxItems: 50, items: { type: 'string', minLength: 1, maxLength: 200 }, description: 'Les noms de groupes de l\'équipe.' };
|
|
67
|
+
// Le schéma des arguments de `partager` : la chose (`argument`, que l'app décrit), et avec qui
|
|
68
|
+
// (`personnes`, `groupes`, `equipe`), quel droit, l'accord.
|
|
69
|
+
export function schemaDePartager(argument, schemaDeLaChose) {
|
|
70
|
+
return {
|
|
71
|
+
type: 'object',
|
|
72
|
+
properties: {
|
|
73
|
+
[argument]: schemaDeLaChose,
|
|
74
|
+
personnes,
|
|
75
|
+
groupes,
|
|
76
|
+
equipe: { type: 'boolean', description: 'true : toute l\'équipe.' },
|
|
77
|
+
droit: { type: 'string', enum: ['lecture', 'modification'], description: '`lecture` : voir ; `modification` : voir et modifier.' },
|
|
78
|
+
confirmer,
|
|
79
|
+
},
|
|
80
|
+
required: [argument, 'droit'],
|
|
81
|
+
};
|
|
82
|
+
}
|
|
83
|
+
// Le schéma des arguments de `ne_plus_partager` : la chose, et avec qui elle ne s'ouvre plus ;
|
|
84
|
+
// `groupes_supprimes` retire les ouvertures aux groupes supprimés.
|
|
85
|
+
export function schemaDeNePlusPartager(argument, schemaDeLaChose) {
|
|
86
|
+
return {
|
|
87
|
+
type: 'object',
|
|
88
|
+
properties: {
|
|
89
|
+
[argument]: schemaDeLaChose,
|
|
90
|
+
personnes,
|
|
91
|
+
groupes,
|
|
92
|
+
equipe: { type: 'boolean', description: 'true : toute l\'équipe.' },
|
|
93
|
+
groupes_supprimes: { type: 'boolean', description: 'true : les groupes supprimés, montrés « un groupe supprimé ».' },
|
|
94
|
+
},
|
|
95
|
+
required: [argument],
|
|
96
|
+
};
|
|
97
|
+
}
|
|
98
|
+
export function creerLePartage(options) {
|
|
99
|
+
const chose = identifiantSql(options.chose);
|
|
100
|
+
const table = identifiantSql(options.table ?? options.chose);
|
|
101
|
+
const proprietaire = identifiantSql(options.proprietaire ?? 'proprietaire');
|
|
102
|
+
const partage = identifiantSql(options.partage ?? 'partage');
|
|
103
|
+
const { base, laChose, absente } = options;
|
|
104
|
+
const lireLAnnuaire = creerLAnnuaire(options.adresseDuCore ?? process.env.CORE_ADRESSE);
|
|
105
|
+
// Le filtre d'une requête sur les choses (`alias`, la table des choses dans la requête) : la
|
|
106
|
+
// chose est à la personne, ou ouverte à elle ; et l'expression de son droit, `proprietaire`,
|
|
107
|
+
// `modification`, `lecture`, ou null. Ses deux valeurs sont les paramètres `$<depuis>` et
|
|
108
|
+
// `$<depuis + 1>` de la requête.
|
|
109
|
+
function pourLaPersonne(personne, { alias = table, depuis = 1 } = {}) {
|
|
110
|
+
const nom = identifiantSql(alias);
|
|
111
|
+
const elle = `$${depuis}`;
|
|
112
|
+
const ouvertures = `select 1 from ${partage} as partage_ouvert where partage_ouvert.${chose} = ${nom}.id and partage_ouvert.avec = any($${depuis + 1}::text[])`;
|
|
113
|
+
return {
|
|
114
|
+
ouverte: `(${nom}.${proprietaire} = ${elle} or exists (${ouvertures}))`,
|
|
115
|
+
droit: `(case when ${nom}.${proprietaire} = ${elle} then 'proprietaire'
|
|
116
|
+
when exists (${ouvertures} and partage_ouvert.droit = 'modification') then 'modification'
|
|
117
|
+
when exists (${ouvertures}) then 'lecture' end)`,
|
|
118
|
+
valeurs: [personne.id, ouverturesDe(personne)],
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
// Le droit de la personne sur une chose, ou rien : une chose absente, ou qui ne lui est pas ouverte.
|
|
122
|
+
async function droitSur(personne, id) {
|
|
123
|
+
const { droit, valeurs } = pourLaPersonne(personne, { alias: 'chose_lue', depuis: 2 });
|
|
124
|
+
const { rows } = await base.query(`select ${droit} as droit from ${table} as chose_lue where chose_lue.id = $1`, [id, ...valeurs]);
|
|
125
|
+
return rows[0]?.droit ?? undefined;
|
|
126
|
+
}
|
|
127
|
+
// Seul le propriétaire partage : pour toute autre personne, la chose est absente.
|
|
128
|
+
async function exigerLaPropriete(personne, id) {
|
|
129
|
+
const { rows } = await base.query(`select 1 from ${table} where id = $1 and ${proprietaire} = $2`, [id, personne.id]);
|
|
130
|
+
if (!rows[0]) {
|
|
131
|
+
throw new Refus(absente(id));
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
async function lignesDe(id) {
|
|
135
|
+
const { rows } = await base.query(`select avec, droit from ${partage} where ${chose} = $1`, [id]);
|
|
136
|
+
return new Map(rows.map((ligne) => [ligne.avec, ligne.droit]));
|
|
137
|
+
}
|
|
138
|
+
// Avec qui la chose est partagée, nommé par l'annuaire : toute l'équipe, puis les groupes, puis
|
|
139
|
+
// les personnes. Un groupe supprimé n'ouvre plus rien, et se montre comme tel.
|
|
140
|
+
function decrire(lignes, annuaire) {
|
|
141
|
+
const rang = { equipe: 0, groupe: 1, personne: 2 };
|
|
142
|
+
return [...lignes].map(([avec, droit]) => {
|
|
143
|
+
if (avec === 'equipe') {
|
|
144
|
+
return { avec: 'equipe', nom: 'Toute l\'équipe', droit };
|
|
145
|
+
}
|
|
146
|
+
const [sorte, id] = [avec.slice(0, avec.indexOf(':')), avec.slice(avec.indexOf(':') + 1)];
|
|
147
|
+
if (sorte === 'groupe') {
|
|
148
|
+
return { avec: 'groupe', nom: annuaire.groupes.find((groupe) => groupe.id === id)?.nom ?? 'un groupe supprimé', droit };
|
|
149
|
+
}
|
|
150
|
+
const connue = annuaire.personnes.find((une) => une.id === id);
|
|
151
|
+
return connue ? { avec: 'personne', nom: connue.nom, email: connue.email, droit } : { avec: 'personne', nom: 'une personne inconnue', droit };
|
|
152
|
+
}).sort((une, autre) => rang[une.avec] - rang[autre.avec] || une.nom.localeCompare(autre.nom, 'fr'));
|
|
153
|
+
}
|
|
154
|
+
// Les cibles que nomment les arguments, retrouvées dans l'annuaire ; une personne ou un groupe
|
|
155
|
+
// inconnus sont refusés, `refus` en tête du texte.
|
|
156
|
+
function cibles(arguments_, annuaire, refus) {
|
|
157
|
+
const trouvees = arguments_.equipe === true ? [{ avec: 'equipe', quoi: 'à toute l\'équipe' }] : [];
|
|
158
|
+
for (const nom of texts(arguments_.groupes)) {
|
|
159
|
+
const groupe = annuaire.groupes.find((un) => un.nom === nom.trim())
|
|
160
|
+
?? annuaire.groupes.find((un) => un.nom.toLowerCase() === nom.trim().toLowerCase());
|
|
161
|
+
if (!groupe) {
|
|
162
|
+
const connus = annuaire.groupes.map((un) => un.nom).sort((un, autre) => un.localeCompare(autre, 'fr'));
|
|
163
|
+
throw new Refus(`${refus} : aucun groupe de l'équipe ne s'appelle « ${nom} ». ${connus.length ? `Ses groupes : ${connus.join(', ')}.` : 'L\'équipe n\'a aucun groupe.'} Toute l'équipe se dit \`equipe: true\`.`);
|
|
164
|
+
}
|
|
165
|
+
const membres = groupe.membres.flatMap((id) => annuaire.personnes.filter((une) => une.id === id && une.active).map((une) => une.nom));
|
|
166
|
+
trouvees.push({ avec: `groupe:${groupe.id}`, quoi: `au groupe ${groupe.nom} (${membres.length ? membres.join(', ') : 'sans membre'})` });
|
|
167
|
+
}
|
|
168
|
+
for (const email of texts(arguments_.personnes)) {
|
|
169
|
+
const connue = annuaire.personnes.find((une) => une.email.toLowerCase() === email.trim().toLowerCase());
|
|
170
|
+
if (!connue) {
|
|
171
|
+
throw new Refus(`${refus} : personne dans l'équipe n'a le courriel ${email}. Vérifier le courriel avec la personne.`);
|
|
172
|
+
}
|
|
173
|
+
trouvees.push({ avec: `personne:${connue.id}`, quoi: `à ${connue.nom} (${connue.email})` });
|
|
174
|
+
}
|
|
175
|
+
return [...new Map(trouvees.map((cible) => [cible.avec, cible])).values()];
|
|
176
|
+
}
|
|
177
|
+
return {
|
|
178
|
+
pourLaPersonne,
|
|
179
|
+
droitSur,
|
|
180
|
+
lireLAnnuaire,
|
|
181
|
+
// Avec qui la chose est partagée, et quel droit : ce que `lire` en rend.
|
|
182
|
+
async partageDe(id) {
|
|
183
|
+
return decrire(await lignesDe(id), await lireLAnnuaire());
|
|
184
|
+
},
|
|
185
|
+
// `partager`, au propriétaire seul : ouvre la chose aux cibles, avec le droit dit. Un partage
|
|
186
|
+
// qui s'élargit (une cible nouvelle, ou la lecture qui passe en modification) demande
|
|
187
|
+
// `confirmer: true`, et son refus dit à qui la chose s'ouvrirait. Restreindre n'attend pas.
|
|
188
|
+
// Rend le partage qui en résulte.
|
|
189
|
+
async partager(personne, id, arguments_) {
|
|
190
|
+
await exigerLaPropriete(personne, id);
|
|
191
|
+
const droit = arguments_.droit === 'modification' ? 'modification' : 'lecture';
|
|
192
|
+
const annuaire = await lireLAnnuaire();
|
|
193
|
+
const visees = cibles(arguments_, annuaire, 'Rien n\'est partagé');
|
|
194
|
+
if (!visees.length) {
|
|
195
|
+
throw new Error('Dire avec qui partager : `personnes`, `groupes` ou `equipe: true`.');
|
|
196
|
+
}
|
|
197
|
+
if (visees.some((cible) => cible.avec === `personne:${personne.id}`)) {
|
|
198
|
+
throw new Refus(`Rien n'est partagé : ${laChose} est déjà à ${personne.email}.`);
|
|
199
|
+
}
|
|
200
|
+
for (const cible of visees) {
|
|
201
|
+
const connue = annuaire.personnes.find((une) => `personne:${une.id}` === cible.avec);
|
|
202
|
+
if (connue && !connue.active) {
|
|
203
|
+
throw new Refus(`Rien n'est partagé : ${connue.nom} (${connue.email}) est désactivée et ne se connecte plus.`);
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
const avant = await lignesDe(id);
|
|
207
|
+
const elargies = visees.filter((cible) => !avant.has(cible.avec) || (avant.get(cible.avec) === 'lecture' && droit === 'modification'));
|
|
208
|
+
if (elargies.length && arguments_.confirmer !== true) {
|
|
209
|
+
throw new Refus(`Rien n'est partagé : ${laChose} s'ouvrirait en ${droit} ${enumerer(elargies.map((cible) => cible.quoi))}. Dire à la personne à qui ${laChose} s'ouvrirait, et ne rappeler avec confirmer: true qu'après son accord explicite.`);
|
|
210
|
+
}
|
|
211
|
+
for (const cible of visees) {
|
|
212
|
+
await base.query(`insert into ${partage} (${chose}, avec, droit) values ($1, $2, $3)
|
|
213
|
+
on conflict (${chose}, avec) do update set droit = excluded.droit`, [id, cible.avec, droit]);
|
|
214
|
+
}
|
|
215
|
+
return decrire(await lignesDe(id), annuaire);
|
|
216
|
+
},
|
|
217
|
+
// `ne_plus_partager`, au propriétaire seul : la chose ne s'ouvre plus aux cibles, ni, avec
|
|
218
|
+
// `groupes_supprimes`, aux groupes supprimés. Sans accord : rien ne s'ouvre. Rend le partage
|
|
219
|
+
// qui reste.
|
|
220
|
+
async nePlusPartager(personne, id, arguments_) {
|
|
221
|
+
await exigerLaPropriete(personne, id);
|
|
222
|
+
const annuaire = await lireLAnnuaire();
|
|
223
|
+
const retirees = cibles(arguments_, annuaire, 'Rien n\'est retiré').map((cible) => cible.avec);
|
|
224
|
+
if (arguments_.groupes_supprimes === true) {
|
|
225
|
+
const existants = new Set(annuaire.groupes.map((groupe) => `groupe:${groupe.id}`));
|
|
226
|
+
retirees.push(...[...(await lignesDe(id)).keys()].filter((avec) => avec.startsWith('groupe:') && !existants.has(avec)));
|
|
227
|
+
}
|
|
228
|
+
else if (!retirees.length) {
|
|
229
|
+
throw new Error('Dire avec qui ne plus partager : `personnes`, `groupes`, `equipe: true` ou `groupes_supprimes: true`.');
|
|
230
|
+
}
|
|
231
|
+
await base.query(`delete from ${partage} where ${chose} = $1 and avec = any($2::text[])`, [id, retirees]);
|
|
232
|
+
return decrire(await lignesDe(id), annuaire);
|
|
233
|
+
},
|
|
234
|
+
};
|
|
235
|
+
}
|
|
236
|
+
// Un nom de table ou de colonne écrit dans le SQL : celui que l'app donne, en lettres simples.
|
|
237
|
+
function identifiantSql(nom) {
|
|
238
|
+
if (!/^[a-z_][a-z0-9_]*$/.test(nom)) {
|
|
239
|
+
throw new Error(`« ${nom} » n'est pas un nom de table ou de colonne.`);
|
|
240
|
+
}
|
|
241
|
+
return nom;
|
|
242
|
+
}
|
|
243
|
+
function texts(valeur) {
|
|
244
|
+
return Array.isArray(valeur) ? valeur.filter((element) => typeof element === 'string') : [];
|
|
245
|
+
}
|
|
246
|
+
function enumerer(parties) {
|
|
247
|
+
return parties.length > 1 ? `${parties.slice(0, -1).join(', ')} et ${parties.at(-1)}` : (parties[0] ?? '');
|
|
248
|
+
}
|
package/src/session.d.ts
ADDED
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
2
|
+
import { type PersonneDeLEspace } from './ecran.ts';
|
|
3
|
+
import type { Personne } from './jeton.ts';
|
|
4
|
+
export type PersonneConnectee = Personne & PersonneDeLEspace & {
|
|
5
|
+
groupes: string[];
|
|
6
|
+
};
|
|
7
|
+
export type SessionLue = {
|
|
8
|
+
personne: PersonneConnectee;
|
|
9
|
+
ouvre: (app: string) => boolean;
|
|
10
|
+
};
|
|
11
|
+
export declare function creerLaSession(adresse?: string | undefined, adresseDuCore?: string | undefined): {
|
|
12
|
+
lireLaSession: (requete: IncomingMessage) => Promise<SessionLue | undefined>;
|
|
13
|
+
personneDe: (requete: IncomingMessage) => Promise<PersonneConnectee | undefined>;
|
|
14
|
+
personneDuFormulaire(requete: IncomingMessage): Promise<PersonneConnectee | undefined>;
|
|
15
|
+
personneDuGeste(requete: IncomingMessage): Promise<PersonneConnectee | 'fermee' | undefined>;
|
|
16
|
+
envoyerALaConnexion(requete: IncomingMessage, reponse: ServerResponse): void;
|
|
17
|
+
};
|