@mlagie/sql-connector 2.0.7 → 2.0.9

package/tests/generateCondition.test.js

@@ -1,241 +0,0 @@
-const generateCondition = require('../src/utils/generateCondition');
-const { Schema } = require('../src/models/Schema');
-
-describe('Utils - generateCondition.js', () => {
-    test('Devrait générer une chaîne classique de conditions WHERE (isUpdate = false)', () => {
-        const filter = { status: 'active', age: 18 };
-        const result = generateCondition(filter, false);
-        expect(result).toBe("`status` = 'active' AND `age` = 18");
-    });
-
-    test('Devrait générer une chaîne d\'assignations SET (isUpdate = true)', () => {
-        const data = { email: 'test@test.com', updated: 1 };
-        const result = generateCondition(data, true);
-        expect(result).toBe("`email` = 'test@test.com' , `updated` = 1");
-    });
-
-    test('Devrait générer un opérateur IN lorsqu\'une valeur est un tableau', () => {
-        const filter = { id: [1, 2, 3] };
-        const result = generateCondition(filter, false);
-        expect(result).toBe('`id` IN (1, 2, 3)');
-    });
-
-    test('Devrait générer "IS NULL" pour les filtres et conserver l\'assignation brute en cas d\'Update', () => {
-        expect(generateCondition({ deletedAt: null }, false)).toBe('`deletedAt` IS NULL');
-        expect(generateCondition({ deletedAt: null }, true)).toBe('`deletedAt` = NULL');
-    });
-
-    test('Devrait convertir une chaîne date ISO au format MySQL si spécifiée dans le Schéma', () => {
-        const schema = new Schema({
-            publishedAt: { type: Date }
-        });
-        const filter = { publishedAt: '2026-07-03T15:00:00.000Z' };
-        const result = generateCondition(filter, false, schema);
-        expect(result).toBe("`publishedAt` = '2026-07-03 15:00:00'");
-    });
-
-    test('Devrait nettoyer les guillemets de protection d\'une chaîne de caractères', () => {
-        const filter = { name: '"Alice"' };
-        expect(generateCondition(filter, false)).toBe("`name` = 'Alice'");
-    });
-
-    test("generateCondition utilise les champs unique du schema", () => {
-        const result = generateCondition(
-            { email: "john@test.fr" },
-            false,
-            {
-                schemaDict: {
-                    email: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("email");
-    });
-
-    test("generateCondition génère un IN pour les champs uniques tableau", () => {
-        const result = generateCondition(
-            { email: ["a@test.fr", "b@test.fr"] },
-            false,
-            {
-                schemaDict: {
-                    email: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("IN");
-    });
-
-    test("generateCondition génère un JSON_CONTAINS pour objet unique", () => {
-        const result = generateCondition(
-            {
-                metadata: {
-                    role: "admin"
-                }
-            },
-            false,
-            {
-                schemaDict: {
-                    metadata: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("JSON_CONTAINS");
-    });
-
-    test("generateCondition génère IS NULL pour champ unique", () => {
-        const result = generateCondition(
-            { email: null },
-            false,
-            {
-                schemaDict: {
-                    email: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("IS NULL");
-    });
-
-    test("generateCondition convertit une date ISO sur champ unique", () => {
-        const result = generateCondition(
-            {
-                created_at: "2025-01-01T10:00:00Z"
-            },
-            false,
-            {
-                schemaDict: {
-                    created_at: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("2025-01-01 10:00:00");
-    });
-
-    test("generateCondition update JSON", () => {
-        const result = generateCondition(
-            {
-                metadata: {
-                    role: "admin"
-                }
-            },
-            true
-        );
-
-        expect(result).toContain("=");
-        expect(result).not.toContain("JSON_CONTAINS");
-    });
-
-    test("generateCondition filtre JSON", () => {
-        const result = generateCondition(
-            {
-                metadata: {
-                    role: "admin"
-                }
-            },
-            false
-        );
-
-        expect(result).toContain("JSON_CONTAINS");
-    });
-
-    test("generateCondition retourne une condition simple", () => {
-        const result = generateCondition(
-            { id: 42 },
-            false
-        );
-
-        expect(result).toContain("42");
-    });
-
-    test("generateCondition retire les guillemets doubles entourant une valeur", () => {
-        const result = generateCondition(
-            { name: '"john"' },
-            false,
-            {
-                schemaDict: {
-                    name: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("john");
-        expect(result).not.toContain('"john"');
-    });
-
-    test("generateCondition utilise JSON_CONTAINS avec une chaîne JSON", () => {
-        const result = generateCondition(
-            {
-                metadata: '{"role":"admin"}'
-            },
-            false,
-            {
-                schemaDict: {
-                    metadata: {
-                        unique: true
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("JSON_CONTAINS");
-    });
-
-    test("generateCondition détecte une chaîne JSON", () => {
-        const result = generateCondition({
-            metadata: '{"role":"admin"}'
-        });
-
-        expect(result).toContain("JSON_CONTAINS");
-    });
-
-    test("generateCondition supporte fieldDef.type string", () => {
-        generateCondition(
-            {
-                created_at: "2025-01-01T10:00:00Z"
-            },
-            false,
-            {
-                schemaDict: {
-                    created_at: {
-                        type: "Date"
-                    }
-                }
-            }
-        );
-    });
-
-    test("generateCondition convertit une date ISO pour un champ Date", () => {
-        const result = generateCondition(
-            {
-                created_at: "2025-01-01T10:00:00Z"
-            },
-            false,
-            {
-                schemaDict: {
-                    created_at: {
-                        type: Date
-                    }
-                }
-            }
-        );
-
-        expect(result).toContain("2025-01-01 10:00:00");
-    });
-
-});

package/tests/mysqlMock.js

@@ -1,22 +0,0 @@
-const mockExecute = jest.fn();
-const mockEnd = jest.fn((callback) => { if (callback) callback(null); });
-
-const mockPool = {
-    promise: () => ({
-        execute: mockExecute
-    }),
-    end: mockEnd
-};
-
-jest.mock('mysql2', () => {
-    // Le require est fait à l'intérieur du callback au moment de l'exécution
-    const mysql2Actual = jest.requireActual('mysql2');
-    
-    return {
-        createPool: jest.fn(() => mockPool),
-        escape: mysql2Actual.escape,
-        escapeId: mysql2Actual.escapeId
-    };
-});
-
-module.exports = { mockExecute, mockEnd, mockPool };

package/tests/safe.test.js

@@ -1,48 +0,0 @@
-const { getSafe, setSafe } = require('../src/utils/security/safe');
-
-describe('Utils - safe.js', () => {
-    describe('getSafe', () => {
-        test('Devrait lire une propriété existante valide', () => {
-            const obj = { name: 'Alice' };
-            expect(getSafe(obj, 'name')).toBe('Alice');
-        });
-
-        test('Devrait renvoyer undefined pour une propriété absente', () => {
-            const obj = { name: 'Alice' };
-            expect(getSafe(obj, 'age')).toBeUndefined();
-        });
-
-        test('Devrait bloquer l’accès aux propriétés interdites (Pollution de Prototype)', () => {
-            const obj = {};
-            expect(getSafe(obj, '__proto__')).toBeUndefined();
-            expect(getSafe(obj, 'constructor')).toBeUndefined();
-            expect(getSafe(obj, 'prototype')).toBeUndefined();
-        });
-
-        test('Devrait gérer un objet null ou indéfini sans lever d’erreur', () => {
-            expect(getSafe(null, 'name')).toBeUndefined();
-            expect(getSafe(undefined, 'name')).toBeUndefined();
-        });
-    });
-
-    describe('setSafe', () => {
-        test('Devrait assigner une valeur à une clé valide', () => {
-            const obj = {};
-            const result = setSafe(obj, 'age', 30);
-            expect(result).toBe(true);
-            expect(obj.age).toBe(30);
-        });
-
-        test('Devrait refuser d’assigner des clés interdites et renvoyer false', () => {
-            const obj = {};
-            expect(setSafe(obj, '__proto__', { polluted: true })).toBe(false);
-            expect(setSafe(obj, 'constructor', {})).toBe(false);
-            expect(setSafe(obj, 'prototype', {})).toBe(false);
-            expect(obj.__proto__.polluted).toBeUndefined();
-        });
-
-        test('Devrait renvoyer false si l’objet cible n’est pas valide', () => {
-            expect(setSafe(null, 'key', 'val')).toBe(false);
-        });
-    });
-});

package/tests/sql.test.js

@@ -1,62 +0,0 @@
-const { escapeIdentifier, escapeIdentifierList, escapeValue, escapeOrderDirection } = require('../src/utils/sql');
-
-describe('Utils - sql.js', () => {
-    describe('escapeIdentifier', () => {
-        test('Devrait renvoyer "*" inchangé', () => {
-            expect(escapeIdentifier('*')).toBe('*');
-        });
-
-        test('Devrait formater un identifiant simple avec des backticks', () => {
-            expect(escapeIdentifier('users')).toBe('`users`');
-        });
-
-        test('Devrait nettoyer les backticks existants (normalisation)', () => {
-            expect(escapeIdentifier('`users`')).toBe('`users`');
-        });
-
-        test('Devrait gérer les identifiants composites sépares par un point', () => {
-            expect(escapeIdentifier('users.id')).toBe('`users`.`id`');
-            expect(escapeIdentifier('users.*')).toBe('`users`.*');
-        });
-
-        test('Devrait lever une erreur si l’identifiant n’est pas une chaîne de caractères ou vide', () => {
-            expect(() => escapeIdentifier('')).toThrow('Invalid SQL identifier');
-            expect(() => escapeIdentifier(null)).toThrow('Invalid SQL identifier');
-        });
-
-        test('Devrait lever une erreur en cas de tentative d’injection de caractères non autorisés', () => {
-            expect(() => escapeIdentifier('users; DROP TABLE users;')).toThrow('Invalid SQL identifier');
-            expect(() => escapeIdentifier('users-table')).toThrow('Invalid SQL identifier');
-            expect(() => escapeIdentifier('users.id;--')).toThrow('Invalid SQL identifier');
-        });
-    });
-
-    describe('escapeIdentifierList', () => {
-        test('Devrait joindre et échapper une liste d’identifiants', () => {
-            expect(escapeIdentifierList(['id', 'email'])).toBe('`id`, `email`');
-        });
-    });
-
-    describe('escapeValue', () => {
-        test('Devrait déléguer l’échappement de valeurs de manière sécurisée', () => {
-            expect(escapeValue("John's")).toBe("'John\\'s'");
-            expect(escapeValue(42)).toBe('42');
-        });
-    });
-
-    describe('escapeOrderDirection', () => {
-        test('Devrait normaliser en majuscule ASC et DESC', () => {
-            expect(escapeOrderDirection('asc')).toBe('ASC');
-            expect(escapeOrderDirection('DESC')).toBe('DESC');
-        });
-
-        test('Devrait retourner ASC par défaut si null ou undefined', () => {
-            expect(escapeOrderDirection(null)).toBe('ASC');
-            expect(escapeOrderDirection(undefined)).toBe('ASC');
-        });
-
-        test('Devrait lever une erreur pour toute direction invalide', () => {
-            expect(() => escapeOrderDirection('INJECTION;')).toThrow('Invalid SQL sort direction');
-        });
-    });
-});

package/tests/sqlTypeMap.test.js

@@ -1,16 +0,0 @@
-const { sqlTypeMap } = require('../src/utils/sqlTypeMap');
-
-describe('Utils - sqlTypeMap.js', () => {
-    test('Devrait posséder les correspondances de types standards indispensables', () => {
-        expect(sqlTypeMap.String).toBe('VARCHAR');
-        expect(sqlTypeMap.Number).toBe('INT');
-        expect(sqlTypeMap.Boolean).toBe('BOOLEAN');
-        expect(sqlTypeMap.Date).toBe('DATETIME');
-        expect(sqlTypeMap.Object).toBe('JSON');
-    });
-
-    test('Devrait retourner les valeurs temporelles par défaut configurées', () => {
-        expect(sqlTypeMap.Now).toBe('NOW()');
-        expect(sqlTypeMap.CurrentTimestamp).toBe('CURRENT_TIMESTAMP');
-    });
-});