@starterlib/cli 0.10.2

package/src/schema.mjs

@@ -0,0 +1,188 @@
+/**
+ * Un validateur JSON Schema (2020-12) REDUIT aux mots-cles que le schema du manifeste de remote
+ * emploie (`@starterlib/core/schemas/manifeste-de-remote.schema.json`, lot 177).
+ *
+ * Pourquoi pas une bibliotheque : le CLI n'a aucune dependance a l'execution, et le schema tient en
+ * une vingtaine de mots-cles. Un mot-cle que ce validateur ne connait pas LEVE : un schema qui
+ * evolue sans que le validateur le lise ne doit jamais passer pour respecte.
+ *
+ * `format` est une annotation (le vocabulaire par defaut de 2020-12) : il ne juge rien, comme le
+ * socle Java et `validerLeManifesteDeRemote`, qui ne demandent a `construitLe` qu'un texte non vide.
+ */
+
+const ANNOTATIONS = new Set([
+  '$schema',
+  '$id',
+  '$comment',
+  '$defs',
+  'title',
+  'description',
+  'format',
+  'examples',
+  'default',
+]);
+const CONNUS = new Set([
+  ...ANNOTATIONS,
+  'type',
+  'const',
+  'enum',
+  'properties',
+  'required',
+  'additionalProperties',
+  'propertyNames',
+  'pattern',
+  'minLength',
+  'minimum',
+  'items',
+  'minItems',
+  'contains',
+  'not',
+  'if',
+  'then',
+  'else',
+  '$ref',
+]);
+
+const estUnObjet = (valeur) =>
+  typeof valeur === 'object' && valeur !== null && !Array.isArray(valeur);
+
+function egaux(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a === null || b === null || typeof a !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const clesA = Object.keys(a);
+  return clesA.length === Object.keys(b).length && clesA.every((cle) => egaux(a[cle], b[cle]));
+}
+
+function aLeType(valeur, type) {
+  switch (type) {
+    case 'object':
+      return estUnObjet(valeur);
+    case 'array':
+      return Array.isArray(valeur);
+    case 'string':
+      return typeof valeur === 'string';
+    case 'boolean':
+      return typeof valeur === 'boolean';
+    case 'integer':
+      return Number.isInteger(valeur);
+    case 'number':
+      return typeof valeur === 'number' && Number.isFinite(valeur);
+    case 'null':
+      return valeur === null;
+    default:
+      throw new Error(`schema : type inconnu "${String(type)}".`);
+  }
+}
+
+/** Le sous-schema designe par `$ref` (`#/$defs/route`) dans le schema racine. */
+function resoudre(racine, reference) {
+  if (!reference.startsWith('#/')) throw new Error(`schema : reference externe "${reference}".`);
+  let courant = racine;
+  for (const morceau of reference.slice(2).split('/')) {
+    courant = courant?.[morceau.replaceAll('~1', '/').replaceAll('~0', '~')];
+  }
+  if (courant === undefined) throw new Error(`schema : reference introuvable "${reference}".`);
+  return courant;
+}
+
+function valider(schema, valeur, chemin, racine, problemes) {
+  if (schema === true) return;
+  if (schema === false) {
+    problemes.push(`${chemin} : aucune valeur admise ici.`);
+    return;
+  }
+  for (const cle of Object.keys(schema)) {
+    if (!CONNUS.has(cle))
+      throw new Error(`schema : mot-cle "${cle}" que le validateur ne lit pas.`);
+  }
+  const dire = (message) => problemes.push(`${chemin} : ${message}`);
+  const respecte = (sousSchema, sousValeur) => {
+    const essai = [];
+    valider(sousSchema, sousValeur, chemin, racine, essai);
+    return essai.length === 0;
+  };
+
+  if (schema.$ref !== undefined)
+    valider(resoudre(racine, schema.$ref), valeur, chemin, racine, problemes);
+  if (schema.type !== undefined) {
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (!types.some((type) => aLeType(valeur, type))) {
+      dire(`${types.join(' ou ')} attendu.`);
+      return;
+    }
+  }
+  if (schema.const !== undefined && !egaux(valeur, schema.const)) {
+    dire(`${JSON.stringify(schema.const)} attendu.`);
+  }
+  if (schema.enum !== undefined && !schema.enum.some((admis) => egaux(valeur, admis))) {
+    dire(
+      `une valeur parmi ${schema.enum.map((admis) => JSON.stringify(admis)).join(', ')} attendue.`,
+    );
+  }
+
+  if (typeof valeur === 'string') {
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern, 'u').test(valeur)) {
+      dire(`"${valeur}" ne respecte pas le motif ${schema.pattern}.`);
+    }
+    if (schema.minLength !== undefined && [...valeur].length < schema.minLength) {
+      dire(`${String(schema.minLength)} caractere(s) au moins.`);
+    }
+  }
+  if (typeof valeur === 'number' && schema.minimum !== undefined && valeur < schema.minimum) {
+    dire(`${String(schema.minimum)} au moins.`);
+  }
+
+  if (Array.isArray(valeur)) {
+    if (schema.minItems !== undefined && valeur.length < schema.minItems) {
+      dire(`${String(schema.minItems)} element(s) au moins.`);
+    }
+    if (schema.items !== undefined) {
+      valeur.forEach((element, indice) =>
+        valider(schema.items, element, `${chemin}[${String(indice)}]`, racine, problemes),
+      );
+    }
+    if (
+      schema.contains !== undefined &&
+      !valeur.some((element) => respecte(schema.contains, element))
+    ) {
+      dire('aucun element ne respecte "contains".');
+    }
+  }
+
+  if (estUnObjet(valeur)) {
+    const proprietes = schema.properties ?? {};
+    for (const cle of schema.required ?? []) {
+      if (!Object.hasOwn(valeur, cle)) dire(`propriete "${cle}" obligatoire.`);
+    }
+    for (const [cle, sousValeur] of Object.entries(valeur)) {
+      const sousChemin = chemin === '' ? cle : `${chemin}.${cle}`;
+      if (schema.propertyNames !== undefined)
+        valider(schema.propertyNames, cle, sousChemin, racine, problemes);
+      if (Object.hasOwn(proprietes, cle)) {
+        valider(proprietes[cle], sousValeur, sousChemin, racine, problemes);
+      } else if (schema.additionalProperties === false) {
+        problemes.push(`${sousChemin} : propriete inconnue du schema.`);
+      } else if (estUnObjet(schema.additionalProperties)) {
+        valider(schema.additionalProperties, sousValeur, sousChemin, racine, problemes);
+      }
+    }
+  }
+
+  if (schema.not !== undefined && respecte(schema.not, valeur)) {
+    dire(
+      `forme refusee (not${schema.not.$comment === undefined ? '' : ` : ${schema.not.$comment}`}).`,
+    );
+  }
+  if (schema.if !== undefined) {
+    const suite = respecte(schema.if, valeur) ? schema.then : schema.else;
+    if (suite !== undefined) valider(suite, valeur, chemin, racine, problemes);
+  }
+}
+
+/** Les problemes de `valeur` selon `schema` ; `[]` si elle le respecte. Leve sur un schema illisible. */
+export function validerSelonLeSchema(schema, valeur) {
+  const problemes = [];
+  valider(schema, valeur, '', schema, problemes);
+  return problemes.map((probleme) => probleme.replace(/^ : /, 'racine : '));
+}

package/src/socle-installe.mjs

@@ -0,0 +1,52 @@
+/**
+ * Ce que la SPA a INSTALLE du socle, lu depuis son `node_modules` et non depuis le CLI (lot 177) :
+ * le contrat de federation (`validerLeManifesteDeRemote`) et le schema du manifeste, publies par
+ * `@starterlib/core`. Les regles du manifeste n'existent ainsi qu'a un seul endroit, le socle, et la
+ * CI d'un remote les applique a la version meme qui tournera dans sa page.
+ *
+ * Le paquet est trouve par son `package.json` (exporte), puis ses fichiers par leur chemin : le
+ * CLI ne depend pas de la forme des `exports` d'une version donnee.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/** Le dossier installe de `paquet`, depuis la racine de la SPA ; `null` s'il manque. */
+export function dossierInstalle(racine, paquet) {
+  try {
+    return dirname(createRequire(join(racine, 'package.json')).resolve(`${paquet}/package.json`));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `{ validerLeManifesteDeRemote, schema, version }` de `@starterlib/core` installe. Leve avec un
+ * message qui dit quoi faire si le paquet, le point d'entree ou le schema manque.
+ */
+export async function contratDeFederation(racine) {
+  const dossier = dossierInstalle(racine, '@starterlib/core');
+  if (dossier === null)
+    throw new Error("@starterlib/core n'est pas installe : pnpm install d'abord.");
+  const module = join(dossier, 'fesm2022', 'starterlib-core-federation.mjs');
+  const cheminDuSchema = join(dossier, 'schemas', 'manifeste-de-remote.schema.json');
+  for (const [chemin, quoi] of [
+    [module, "le point d'entree @starterlib/core/federation"],
+    [cheminDuSchema, 'le schema du manifeste'],
+  ]) {
+    if (!existsSync(chemin))
+      throw new Error(`${quoi} manque a @starterlib/core installe (${chemin}).`);
+  }
+  const { validerLeManifesteDeRemote } = await import(pathToFileURL(module).href);
+  if (typeof validerLeManifesteDeRemote !== 'function') {
+    throw new Error(
+      '@starterlib/core/federation installe ne publie pas validerLeManifesteDeRemote.',
+    );
+  }
+  return {
+    validerLeManifesteDeRemote,
+    schema: JSON.parse(readFileSync(cheminDuSchema, 'utf8')),
+    version: JSON.parse(readFileSync(join(dossier, 'package.json'), 'utf8')).version,
+  };
+}

package/src/trains.mjs

@@ -0,0 +1,33 @@
+/**
+ * Les trains du socle (ADR web 0006). Avant la 1.0, un train est une mineure (`0.9.x`, puis
+ * `0.10.x`) ; ensuite, une majeure.
+ */
+
+/** `0.10.2` donne `0.10` ; `null` pour ce qui n'est pas un numero de version. */
+export function trainDe(version) {
+  const trouve = /^(\d+)\.(\d+)(?:\.\d+)?/.exec(String(version ?? ''));
+  return trouve === null ? null : `${trouve[1]}.${trouve[2]}`;
+}
+
+/** Negatif si `a` precede `b`, nul s'ils sont egaux : `0.9` precede `0.10`, qui precede `1.0`. */
+export function comparerLesTrains(a, b) {
+  const [majeureA, mineureA] = a.split('.').map(Number);
+  const [majeureB, mineureB] = b.split('.').map(Number);
+  return majeureA - majeureB || mineureA - mineureB;
+}
+
+/**
+ * Le nombre de trains qui separent `train` de `reference` : 0 s'il est le meme ou en avance.
+ *
+ * Avant la 1.0, chaque mineure est un train. Apres, chaque majeure. D'un train `0.x` a un train
+ * `M.y` (M >= 1), le compte est au moins M : la 1.0 est un train a elle seule, et le detail des
+ * mineures `0.x` qui la precedent ne change rien a la decision (un retard de deux trains echoue).
+ */
+export function retardEnTrains(train, reference) {
+  if (comparerLesTrains(train, reference) >= 0) return 0;
+  const [majeure, mineure] = train.split('.').map(Number);
+  const [majeureDeReference, mineureDeReference] = reference.split('.').map(Number);
+  if (majeure === 0 && majeureDeReference === 0) return mineureDeReference - mineure;
+  if (majeure >= 1) return majeureDeReference - majeure;
+  return majeureDeReference;
+}

package/src/verifier.mjs

@@ -0,0 +1,106 @@
+/**
+ * `starter-web verify` : les etapes d'une SPA, dans l'ordre du plan SPA §3, arretees a la premiere
+ * qui echoue — et qui la NOMME : un « Command failed » ne dit pas quoi corriger.
+ *
+ * versions -> dependances -> jetons -> format -> lint -> i18n -> test -> contrat -> build ->
+ * manifeste -> federation -> entree (hote) -> budget -> amorcage (hote) -> securite.
+ *
+ * Le sprite est pose une fois, avant la premiere etape qui lit le code (lint, test, build).
+ */
+import { construire } from './construction/construire.mjs';
+import { poserLeSprite } from './construction/sprite.mjs';
+import budget from './etapes/budget.mjs';
+import dependances from './etapes/dependances.mjs';
+import federation from './etapes/federation.mjs';
+import { amorcage, entree } from './etapes/hote.mjs';
+import i18n from './etapes/i18n.mjs';
+import jetons from './etapes/jetons.mjs';
+import manifeste from './etapes/manifeste.mjs';
+import { contrat, format, lint, test } from './etapes/outillage.mjs';
+import securite from './etapes/securite.mjs';
+import versions from './etapes/versions.mjs';
+
+const build = {
+  nom: 'build',
+  roles: ['remote', 'hote'],
+  preparation: 'sprite',
+  executer(projet, contexte) {
+    const code = construire(projet, { journal: contexte.journal, sprite: false });
+    return code === 0
+      ? { defauts: [], resume: 'construction de production conforme.' }
+      : { defauts: [`construction en echec (code ${String(code)}).`] };
+  },
+};
+
+/** Les etapes, dans leur ordre. */
+export const ETAPES = [
+  versions,
+  dependances,
+  jetons,
+  format,
+  lint,
+  i18n,
+  test,
+  contrat,
+  build,
+  manifeste,
+  federation,
+  entree,
+  budget,
+  amorcage,
+  securite,
+];
+
+/** Les noms d'etape inconnus d'une liste. */
+export function etapesInconnues(noms) {
+  return noms.filter((nom) => !ETAPES.some((etape) => etape.nom === nom));
+}
+
+/**
+ * Lance les etapes retenues sur `projet`. `options` : `etapes` (seulement celles-ci), `sauter`,
+ * `trainDeReference`, `journal` (`{ info, erreur }`). Rend 0 si tout est conforme, 1 sinon.
+ */
+export async function verifier(
+  projet,
+  { etapes, sauter = [], trainDeReference, journal = console } = {},
+) {
+  const retenues = ETAPES.filter(
+    (etape) =>
+      etape.roles.includes(projet.role) &&
+      (etapes === undefined || etapes.includes(etape.nom)) &&
+      !sauter.includes(etape.nom),
+  );
+  const contexte = { trainDeReference, journal };
+  let spritePose = false;
+
+  for (const [indice, etape] of retenues.entries()) {
+    journal.info(`[${String(indice + 1)}/${String(retenues.length)}] ${etape.nom}`);
+    if (etape.preparation === 'sprite' && !spritePose) {
+      journal.info(`  sprite : ${poserLeSprite(projet)}`);
+      spritePose = true;
+    }
+    let resultat;
+    try {
+      resultat = await etape.executer(projet, contexte);
+    } catch (erreur) {
+      resultat = { defauts: [erreur instanceof Error ? erreur.message : String(erreur)] };
+    }
+    if (resultat.sautee !== undefined) {
+      journal.info(`  sautee : ${resultat.sautee}`);
+      continue;
+    }
+    for (const ligne of resultat.details ?? []) journal.info(`  ${ligne}`);
+    for (const avertissement of resultat.avertissements ?? []) journal.info(`  ! ${avertissement}`);
+    const defauts = resultat.defauts ?? [];
+    if (defauts.length > 0) {
+      for (const defaut of defauts) journal.erreur(`  - ${defaut}`);
+      journal.erreur(
+        `starter-web verify : echec a l'etape ${etape.nom} (${String(defauts.length)} defaut(s)).`,
+      );
+      return 1;
+    }
+    if (resultat.resume !== undefined) journal.info(`  ${etape.nom} : ${resultat.resume}`);
+  }
+  journal.info(`starter-web verify : ${String(retenues.length)} etape(s) conforme(s).`);
+  return 0;
+}