@mostajs/achats 0.0.0-stage → 0.1.1

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/src/codes.mjs ADDED
@@ -0,0 +1,30 @@
1
+ // @mostajs/achats — vocabulaire fermé des erreurs, avec leur libellé français.
2
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
3
+
4
+ export const LIBELLES = Object.freeze({
5
+ CONFIG_INVALIDE: 'Configuration du module invalide (dépôts, ports, horloge).',
6
+ PORT_ABSENT: 'Port requis non branché pour cette opération.',
7
+ DONNEES_INVALIDES: 'Données invalides.',
8
+ QUANTITE_INVALIDE: 'Quantité invalide : un entier strictement positif est attendu.',
9
+ MONTANT_INVALIDE: 'Montant invalide : un entier positif ou nul, dans l\'unité monétaire, est attendu.',
10
+ LIGNES_VIDES: 'Une commande porte au moins une ligne.',
11
+ LIGNE_EN_DOUBLE: 'La même ligne apparaît deux fois.',
12
+ LIGNE_INCONNUE: 'Cette ligne n\'existe pas dans la commande.',
13
+ FOURNISSEUR_INCONNU: 'Fournisseur inconnu du référentiel.',
14
+ FOURNISSEUR_INACTIF: 'Fournisseur désactivé dans le référentiel.',
15
+ COMMANDE_INCONNUE: 'Commande inconnue.',
16
+ COMMANDE_NON_MODIFIABLE: 'Seul un brouillon se modifie.',
17
+ COMMANDE_NON_ENVOYEE: 'La commande n\'a pas été envoyée : rien ne peut être reçu.',
18
+ COMMANDE_SOLDEE: 'La commande est soldée.',
19
+ COMMANDE_ANNULEE: 'La commande est annulée.',
20
+ TRANSITION_INTERDITE: 'Cette opération n\'est pas permise dans l\'état de la commande.',
21
+ ANNULATION_IMPOSSIBLE: 'Une commande déjà reçue en partie ne s\'annule pas : elle se solde.',
22
+ MOTIF_REQUIS: 'Un motif est requis.',
23
+ RECEPTION_VIDE: 'Une réception porte au moins une ligne.',
24
+ RECEPTION_EXCEDENTAIRE: 'Quantité reçue au-delà du reste à recevoir.',
25
+ RECEPTION_INCONNUE: 'Réception inconnue.',
26
+ ENTREE_STOCK_ECHOUEE: 'L\'entrée en stock a échoué ; la réception est à reprendre.',
27
+ CONFLIT_VERSION: 'La commande a changé entre-temps ; relire et recommencer.',
28
+ });
29
+
30
+ export const CODES = Object.freeze(Object.fromEntries(Object.keys(LIBELLES).map((c) => [c, c])));
@@ -0,0 +1,39 @@
1
+ // @mostajs/achats — dépôt en mémoire : le contrat à prédicat, avec version optimiste.
2
+ // Sert aux essais, aux démonstrations, et convient aussi aux dépôts de @mostajs/stocks et @mostajs/fournisseurs.
3
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
4
+
5
+ /**
6
+ * Contrat (que tout dépôt en base doit tenir) :
7
+ * create(doc) → doc (doc.id fourni ; sinon tiré)
8
+ * findById(id) → doc | null
9
+ * find(predicat) → doc[] (predicat : une FONCTION)
10
+ * update(id, patch, { version }?) → doc | null
11
+ * null si l'id est inconnu, OU si `version` est donnée et diffère de la version stockée
12
+ * (en base : UPDATE … WHERE id = ? AND version = ?). Le patch porte la nouvelle version.
13
+ * delete(id) → boolean (facultatif pour @mostajs/achats)
14
+ * Les documents rendus sont des COPIES : les modifier ne touche pas au dépôt.
15
+ */
16
+ export function depotMemoire() {
17
+ const docs = new Map();
18
+ const copie = (d) => structuredClone(d);
19
+ return {
20
+ async create(doc) {
21
+ const d = copie(doc);
22
+ if (d.id === undefined || d.id === null) d.id = globalThis.crypto.randomUUID();
23
+ if (docs.has(d.id)) throw new Error(`depotMemoire : l'identifiant « ${d.id} » existe déjà`);
24
+ docs.set(d.id, d);
25
+ return copie(d);
26
+ },
27
+ async findById(id) { return docs.has(id) ? copie(docs.get(id)) : null; },
28
+ async find(predicat) { return [...docs.values()].map(copie).filter((d) => predicat(d)); },
29
+ async update(id, patch, options = {}) {
30
+ const avant = docs.get(id);
31
+ if (!avant) return null;
32
+ if (options && options.version !== undefined && avant.version !== options.version) return null;
33
+ const apres = { ...avant, ...copie(patch), id };
34
+ docs.set(id, apres);
35
+ return copie(apres);
36
+ },
37
+ async delete(id) { return docs.delete(id); },
38
+ };
39
+ }
@@ -0,0 +1,23 @@
1
+ // @mostajs/achats — arithmétique entière : quantités et montants, sans flottant.
2
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
3
+ import { lever } from './erreur.mjs';
4
+
5
+ export const estEntierPositif = (v) => Number.isSafeInteger(v) && v > 0;
6
+ export const estEntierPositifOuNul = (v) => Number.isSafeInteger(v) && v >= 0;
7
+
8
+ /** Produit d'entiers sûrs ; lève `code` si le résultat sort des entiers sûrs. */
9
+ export function produit(a, b, code, champ) {
10
+ const p = a * b;
11
+ if (!Number.isSafeInteger(p)) lever(code, `${champ} : dépasse les entiers sûrs`, { champ });
12
+ return p;
13
+ }
14
+
15
+ /** Somme d'entiers sûrs ; lève `code` en cas de dépassement. */
16
+ export function somme(valeurs, code, champ) {
17
+ let s = 0;
18
+ for (const v of valeurs) { s += v; if (!Number.isSafeInteger(s)) lever(code, `${champ} : dépasse les entiers sûrs`, { champ }); }
19
+ return s;
20
+ }
21
+
22
+ /** ⌈a / b⌉ pour a ≥ 0, b > 0, entiers. */
23
+ export const plafond = (a, b) => Math.floor(a / b) + (a % b === 0 ? 0 : 1);
package/src/erreur.mjs ADDED
@@ -0,0 +1,21 @@
1
+ // @mostajs/achats — une seule classe d'erreur, à vocabulaire fermé.
2
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
3
+ import { LIBELLES } from './codes.mjs';
4
+
5
+ export class ErreurAchats extends Error {
6
+ /**
7
+ * @param {string} code un code de CODES (sinon : erreur de programmation, levée telle quelle)
8
+ * @param {string} [message] défaut : le libellé français du code
9
+ * @param {object} [details] données utiles à l'appelant (lignes en cause, identifiants)
10
+ */
11
+ constructor(code, message, details) {
12
+ if (!Object.prototype.hasOwnProperty.call(LIBELLES, code)) throw new TypeError(`ErreurAchats : code inconnu « ${code} »`);
13
+ super(message || LIBELLES[code]);
14
+ this.name = 'ErreurAchats';
15
+ this.code = code;
16
+ this.details = details ?? null;
17
+ }
18
+ }
19
+
20
+ /** Raccourci : lever une ErreurAchats. */
21
+ export const lever = (code, message, details) => { throw new ErreurAchats(code, message, details); };
package/src/etats.mjs ADDED
@@ -0,0 +1,30 @@
1
+ // @mostajs/achats — états d'une commande fournisseur et transitions permises.
2
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
3
+ import { lever } from './erreur.mjs';
4
+
5
+ export const ETATS = Object.freeze(['brouillon', 'envoyee', 'recue_partiellement', 'soldee', 'annulee']);
6
+
7
+ /** Pour chaque opération, les états de départ permis. */
8
+ export const TRANSITIONS = Object.freeze({
9
+ modifier: Object.freeze(['brouillon']),
10
+ envoyer: Object.freeze(['brouillon']),
11
+ recevoir: Object.freeze(['envoyee', 'recue_partiellement']),
12
+ solder: Object.freeze(['recue_partiellement']),
13
+ annuler: Object.freeze(['brouillon', 'envoyee']),
14
+ });
15
+
16
+ /**
17
+ * Vérifie que `commande` permet `operation`, sinon lève l'erreur la plus parlante :
18
+ * une commande close nomme son état ; sinon un code propre à l'opération ; sinon TRANSITION_INTERDITE.
19
+ */
20
+ export function exigerEtat(commande, operation) {
21
+ const { etat } = commande;
22
+ if (TRANSITIONS[operation].includes(etat)) return;
23
+ const details = { commandeId: commande.id, etat, operation };
24
+ if (etat === 'soldee') lever('COMMANDE_SOLDEE', undefined, details);
25
+ if (etat === 'annulee') lever('COMMANDE_ANNULEE', undefined, details);
26
+ if (operation === 'modifier') lever('COMMANDE_NON_MODIFIABLE', undefined, details);
27
+ if (operation === 'recevoir' && etat === 'brouillon') lever('COMMANDE_NON_ENVOYEE', undefined, details);
28
+ if (operation === 'annuler' && etat === 'recue_partiellement') lever('ANNULATION_IMPOSSIBLE', undefined, details);
29
+ lever('TRANSITION_INTERDITE', `« ${operation} » n'est pas permis sur une commande « ${etat} »`, details);
30
+ }
package/src/index.mjs ADDED
@@ -0,0 +1,11 @@
1
+ // @mostajs/achats — entrée du paquet.
2
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
3
+ export { CODES, LIBELLES } from './codes.mjs';
4
+ export { ErreurAchats } from './erreur.mjs';
5
+ export { ETATS, TRANSITIONS } from './etats.mjs';
6
+ export { PERMISSIONS, PERMISSION_PAR_OPERATION } from './permissions.mjs';
7
+ export { calculerQuantite } from './proposition.mjs';
8
+ export { creerAchats } from './service.mjs';
9
+ export { depotMemoire } from './depot-memoire.mjs';
10
+ export { portStocks, portNumerotation } from './adaptateurs.mjs';
11
+ export { schemaCommandeAchat, schemaReceptionAchat } from './schemas.mjs';
@@ -0,0 +1,31 @@
1
+ // @mostajs/achats — permissions CONTRIBUÉES par le module (domaine:action, deux-points).
2
+ // Le module ne les attribue à aucun rôle : l'administrateur coche la matrice (@mostajs/rbac).
3
+ // Il ne les contrôle pas non plus : l'application vérifie le droit avant d'appeler l'opération.
4
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
5
+
6
+ export const PERMISSIONS = Object.freeze({
7
+ 'achats:lire': 'Consulter les commandes fournisseurs et les réceptions',
8
+ 'achats:proposer': 'Calculer les quantités à commander',
9
+ 'achats:commander': 'Préparer et modifier une commande fournisseur',
10
+ 'achats:envoyer': 'Envoyer une commande au fournisseur',
11
+ 'achats:recevoir': 'Enregistrer une réception et son entrée en stock',
12
+ 'achats:cloturer': 'Annuler ou solder une commande',
13
+ });
14
+
15
+ /** La permission que l'application vérifie avant chaque opération du service. */
16
+ export const PERMISSION_PAR_OPERATION = Object.freeze({
17
+ creer: 'achats:commander',
18
+ modifier: 'achats:commander',
19
+ brouillonsDepuis: 'achats:commander',
20
+ envoyer: 'achats:envoyer',
21
+ recevoir: 'achats:recevoir',
22
+ reprendreEntrees: 'achats:recevoir',
23
+ solder: 'achats:cloturer',
24
+ annuler: 'achats:cloturer',
25
+ lire: 'achats:lire',
26
+ lister: 'achats:lire',
27
+ receptionsDe: 'achats:lire',
28
+ aReprendre: 'achats:lire',
29
+ enCommande: 'achats:lire',
30
+ proposer: 'achats:proposer',
31
+ });
@@ -0,0 +1,57 @@
1
+ // @mostajs/achats — quantité proposée : point de commande, stock de sécurité, couverture, colis, minimum.
2
+ // Fonction PURE, en entiers : la consommation est une quantité sur une durée, chaque division est un plafond.
3
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
4
+ import { lever } from './erreur.mjs';
5
+ import { estEntierPositif, estEntierPositifOuNul, plafond } from './entiers.mjs';
6
+
7
+ const exiger = (ok, champ, valeur) => { if (!ok) lever('DONNEES_INVALIDES', `${champ} : valeur invalide`, { champ, valeur }); };
8
+
9
+ /**
10
+ * @param {object} p
11
+ * @param {number} p.disponible stock disponible (unités de stock, entier ≥ 0)
12
+ * @param {number} [p.enCommande=0] reste à recevoir sur les commandes ouvertes
13
+ * @param {{quantite:number, jours:number}} p.consommation consommé sur la fenêtre
14
+ * @param {number} p.delaiJours délai de livraison du fournisseur
15
+ * @param {number} [p.stockSecurite] en unités ; exclusif de stockSecuriteJours
16
+ * @param {number} [p.stockSecuriteJours] en jours de consommation
17
+ * @param {number} [p.couvertureJours=0] jours de consommation couverts au-delà du point de commande
18
+ * @param {number} [p.minimumQuantite=0] minimum de commande, en unités
19
+ * @param {number} [p.multiple=1] unités par colis
20
+ */
21
+ export function calculerQuantite(p) {
22
+ exiger(p && typeof p === 'object', 'paramètres', p);
23
+ const { disponible, enCommande = 0, consommation, delaiJours, stockSecurite, stockSecuriteJours,
24
+ couvertureJours = 0, minimumQuantite = 0, multiple = 1 } = p;
25
+ exiger(estEntierPositifOuNul(disponible), 'disponible', disponible);
26
+ exiger(estEntierPositifOuNul(enCommande), 'enCommande', enCommande);
27
+ exiger(consommation && typeof consommation === 'object', 'consommation', consommation);
28
+ exiger(estEntierPositifOuNul(consommation.quantite), 'consommation.quantite', consommation.quantite);
29
+ exiger(estEntierPositif(consommation.jours), 'consommation.jours', consommation.jours);
30
+ exiger(estEntierPositifOuNul(delaiJours), 'delaiJours', delaiJours);
31
+ exiger(!(stockSecurite !== undefined && stockSecuriteJours !== undefined), 'stockSecurite', 'stockSecurite et stockSecuriteJours sont exclusifs');
32
+ if (stockSecurite !== undefined) exiger(estEntierPositifOuNul(stockSecurite), 'stockSecurite', stockSecurite);
33
+ if (stockSecuriteJours !== undefined) exiger(estEntierPositifOuNul(stockSecuriteJours), 'stockSecuriteJours', stockSecuriteJours);
34
+ exiger(estEntierPositifOuNul(couvertureJours), 'couvertureJours', couvertureJours);
35
+ exiger(estEntierPositifOuNul(minimumQuantite), 'minimumQuantite', minimumQuantite);
36
+ exiger(estEntierPositif(multiple), 'multiple', multiple);
37
+
38
+ const { quantite: q, jours } = consommation;
39
+ const demandeSur = (j, champ) => {
40
+ const n = q * j;
41
+ exiger(Number.isSafeInteger(n), champ, n);
42
+ return plafond(n, jours);
43
+ };
44
+ const demandePendantDelai = demandeSur(delaiJours, 'delaiJours');
45
+ const ss = stockSecurite !== undefined ? stockSecurite : stockSecuriteJours !== undefined ? demandeSur(stockSecuriteJours, 'stockSecuriteJours') : 0;
46
+ const pointDeCommande = demandePendantDelai + ss;
47
+ const position = disponible + enCommande;
48
+ const niveauCible = pointDeCommande + demandeSur(couvertureJours, 'couvertureJours');
49
+ for (const [champ, v] of [['pointDeCommande', pointDeCommande], ['position', position], ['niveauCible', niveauCible]]) exiger(Number.isSafeInteger(v), champ, v);
50
+
51
+ const declenche = position <= pointDeCommande;
52
+ const quantiteBrute = declenche ? Math.max(niveauCible - position, 0) : 0;
53
+ const arrondi = (x) => plafond(x, multiple) * multiple;
54
+ const quantite = declenche ? Math.max(arrondi(Math.max(quantiteBrute, 1)), arrondi(minimumQuantite)) : 0;
55
+ exiger(Number.isSafeInteger(quantite), 'quantite', quantite);
56
+ return { declenche, position, demandePendantDelai, stockSecurite: ss, pointDeCommande, niveauCible, quantiteBrute, multiple, quantite, colis: quantite / multiple };
57
+ }
@@ -0,0 +1,24 @@
1
+ // @mostajs/achats — register(registry) : le module CONTRIBUE ses schémas et ses permissions au socle,
2
+ // en objet simple (aucun import de module-contract), de même forme que @mostajs/stocks/register.
3
+ // Aucune permission n'est attribuée à un rôle : l'administrateur coche la matrice.
4
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
5
+ import { PERMISSIONS } from './permissions.mjs';
6
+ import { schemaCommandeAchat, schemaReceptionAchat } from './schemas.mjs';
7
+
8
+ export function register(registry) {
9
+ registry.register({
10
+ manifest: {
11
+ name: 'achats', package: '@mostajs/achats', version: '0.1.1', type: 'business', priority: 110,
12
+ displayName: 'Achats', description: 'Commandes fournisseurs, quantités proposées, réceptions.',
13
+ icon: 'ShoppingCart', register: './src/register.mjs',
14
+ },
15
+ permissions: {
16
+ permissions: { ...PERMISSIONS },
17
+ definitions: Object.entries(PERMISSIONS).map(([code, name]) => ({ code, name, category: 'achats' })),
18
+ categories: [{ name: 'achats', label: 'Achats', description: 'Commandes fournisseurs et réceptions', order: 45, system: false }],
19
+ },
20
+ schemas: [schemaCommandeAchat, schemaReceptionAchat].map((s) => ({ name: s.name, schema: s })),
21
+ });
22
+ }
23
+
24
+ export default register;
@@ -0,0 +1,55 @@
1
+ // @mostajs/achats — descriptions d'entités (forme EntitySchema de @mostajs/orm), en objets simples.
2
+ // Les montants et quantités sont des entiers : @mostajs/orm n'a pas de type entier, le module le garantit.
3
+ // @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
4
+ import { ETATS } from './etats.mjs';
5
+
6
+ export const schemaCommandeAchat = Object.freeze({
7
+ name: 'CommandeAchat',
8
+ collection: 'achats_commandes',
9
+ fields: {
10
+ numero: { type: 'string', default: null },
11
+ fournisseurId: { type: 'string', required: true },
12
+ etat: { type: 'string', required: true, enum: [...ETATS] },
13
+ devise: { type: 'string', default: null },
14
+ reference: { type: 'string', default: null },
15
+ note: { type: 'text', default: null },
16
+ // [{ ligne, articleId, code, libelle, parColis, quantite, prixUnitaire, montant, quantiteRecue }]
17
+ lignes: { type: 'json', required: true },
18
+ total: { type: 'number', required: true },
19
+ creeLe: { type: 'date' },
20
+ creePar: { type: 'string', default: null },
21
+ envoyeeLe: { type: 'date', default: null },
22
+ soldeeLe: { type: 'date', default: null },
23
+ annuleeLe: { type: 'date', default: null },
24
+ motifCloture: { type: 'text', default: null },
25
+ version: { type: 'number', required: true },
26
+ historique: { type: 'json', default: [] },
27
+ },
28
+ relations: {},
29
+ indexes: [
30
+ { fields: { numero: 'asc' }, unique: true, sparse: true },
31
+ { fields: { fournisseurId: 'asc' } },
32
+ { fields: { etat: 'asc' } },
33
+ ],
34
+ timestamps: true,
35
+ });
36
+
37
+ export const schemaReceptionAchat = Object.freeze({
38
+ name: 'ReceptionAchat',
39
+ collection: 'achats_receptions',
40
+ fields: {
41
+ commandeId: { type: 'string', required: true },
42
+ numeroCommande: { type: 'string', default: null },
43
+ fournisseurId: { type: 'string' },
44
+ le: { type: 'date', required: true },
45
+ par: { type: 'string', default: null },
46
+ bonLivraison: { type: 'string', default: null },
47
+ // [{ ligne, articleId, quantite, quantiteStock, montant, excedent, lot, peremption, entree, mouvementId }]
48
+ lignes: { type: 'json', required: true },
49
+ etat: { type: 'string', required: true, enum: ['a_entrer', 'entree'] },
50
+ creeLe: { type: 'date' },
51
+ },
52
+ relations: {},
53
+ indexes: [{ fields: { commandeId: 'asc' } }, { fields: { etat: 'asc' } }],
54
+ timestamps: true,
55
+ });