@mlagie/sql-connector 3.2.0 → 3.4.0

package/index.d.ts

@@ -362,6 +362,19 @@ export type SelectAggregation = {
      */
     count?: string | string[] | Record<string, any>;
 
+    /**
+     * Calculates MAX(column).
+     * 
+     * A string, list of strings or object may be supplied
+     * depending on the query builder expression.
+     * 
+     * @example
+     * ```ts
+     * { max: "created_at", as: "latest" }
+     * ```
+     */
+    max?: string | string[] | Record<string, any>;
+
     /**
      * Alias assigned to the resulting expression.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "The sql-connector module allows you to manage connections to a MySQL database, define table schemas, and interact with data in a simple and efficient way.",
   "main": "index.js",
   "exports": {

package/src/migration/MigrationRunner.js

@@ -61,6 +61,11 @@ class MigrationRunner {
             plan.id
         );
 
+        // The rollback files are written BEFORE the schema is touched: if the
+        // process dies or the write fails, nothing has been changed yet and the
+        // database never ends up "applied" without its rollback metadata.
+        await this.store.writeMigration(plan);
+
         const run = async () => {
             for (const operation of plan.operations) {
                 const sql = this.sqlForOperation(operation);
@@ -75,15 +80,31 @@ class MigrationRunner {
             );
         };
 
-        await this.dialect.transaction(this.connection, run);
-        await this.store.writeMigration(plan);
-        await this.store.writeSnapshot(plan.snapshot);
-        await this.store.cleanup();
+        try {
+            await this.dialect.transaction(this.connection, run);
+        } catch (error) {
+            await this.store.removeMigration(plan.id).catch(() => {});
+            throw error;
+        }
+
+        const warnings = [];
+        try {
+            await this.store.writeSnapshot(plan.snapshot);
+        } catch (error) {
+            warnings.push(`Migration applied but schema snapshot could not be written: ${error.message}`);
+        }
+        try {
+            await this.store.cleanup();
+        } catch (error) {
+            warnings.push(`Migration applied but cleanup failed: ${error.message}`);
+        }
+        for (const warning of warnings) console.warn(warning);
 
         return {
             applied: true,
             plan,
-            backupPath
+            backupPath,
+            ...(warnings.length > 0 ? { warnings } : {})
         };
     }
 

package/src/migration/MigrationStore.js

@@ -43,6 +43,11 @@ class MigrationStore {
         return outputPath;
     }
 
+    async removeMigration(id) {
+        await fs.rm(path.join(this.directory, `${id}.sql.enc`), { force: true });
+        await fs.rm(path.join(this.directory, `${id}.meta.json.enc`), { force: true });
+    }
+
     async readMigration(id) {
         await this.ensureDirectories();
         if (!this.encryptionKey) throw new Error("An encryption key is required to read migration files.");
@@ -134,4 +139,4 @@ class MigrationStore {
     }
 }
 
-module.exports = { MigrationStore };
+module.exports = { MigrationStore };

package/src/migration/SchemaDiffer.js

@@ -171,37 +171,13 @@ class SchemaDiffer {
 
             /*
              * Second pass:
-             * detect additions and modifications.
-             */
-            for (const [columnName, field] of Object.entries(desiredColumns)) {
-                const currentField = getSafe(virtualCurrentColumns, columnName);
-
-                if (!currentField) {
-                    operations.push({
-                        type: "addColumn",
-                        table: tableName,
-                        column: columnName,
-                        field
-                    });
-
-                    continue;
-                }
-
-                if (!equivalentField(field, currentField)) {
-                    operations.push({
-                        type: "alterColumn",
-                        table: tableName,
-                        column: columnName,
-                        field,
-                        previous: currentField
-                    });
-                }
-            }
-
-            /*
-             * Third pass:
              * detect removed columns.
              *
+             * Deletions are emitted BEFORE additions/alterations so that a
+             * dropped primary key column (e.g. `uuid`) releases its PRIMARY KEY
+             * before a new one (e.g. `id`) is added; otherwise PostgreSQL fails
+             * with "multiple primary keys for table".
+             *
              * Renamed columns are excluded because their old name
              * intentionally disappears from the desired schema.
              */
@@ -228,6 +204,35 @@ class SchemaDiffer {
                     operations.push(operation);
                 }
             }
+            /*
+             * Third pass:
+             * detect additions and modifications (after the deletions).
+             */
+            for (const [columnName, field] of Object.entries(desiredColumns)) {
+                const currentField = getSafe(virtualCurrentColumns, columnName);
+
+                if (!currentField) {
+                    operations.push({
+                        type: "addColumn",
+                        table: tableName,
+                        column: columnName,
+                        field
+                    });
+
+                    continue;
+                }
+
+                if (!equivalentField(field, currentField)) {
+                    operations.push({
+                        type: "alterColumn",
+                        table: tableName,
+                        column: columnName,
+                        field,
+                        previous: currentField
+                    });
+                }
+            }
+
         }
 
         /*

package/src/utils/buildQuery/buildAggregationField.js

@@ -0,0 +1,11 @@
+const { getDialect } = require("../../db/dialects");
+
+module.exports = (aggregateType, field) => {
+    if (typeof field === 'string') return `${aggregateType}(${getDialect().escape(field)})`;
+    if (field instanceof Array && field !== null) return field.map(col => `${aggregateType}(${getDialect().escape(col)})`).join(' + ');
+    if (field instanceof Object) {
+        const [key, value] = Object.entries(field)[0];
+        return `${aggregateType}(CASE WHEN ${getDialect().escape(key)} = ${getDialect().escapeValue(value)} THEN 1 END)`;
+    }
+    throw new Error(`Invalid field type for ${aggregateType}. Must be a string, array, or object.`);
+}

package/src/utils/buildQuery/buildQuery.js

@@ -1,6 +1,6 @@
 const { getDialect } = require("../../db/dialects");
 const { escapeOrderDirection } = require("../sql");
-const count = require("./count");
+const buildAggregationField = require("./buildAggregationField");
 
 function buildGroupByItem(group) {
     let sql;
@@ -43,7 +43,9 @@ function buildField(field) {
     else if (field.distinct)
         sql = `DISTINCT ${getDialect().escape(field.distinct)}`;
     else if (field.count)
-        sql = count(field.count);
+        sql = buildAggregationField("COUNT", field.count);
+    else if (field.max)
+        sql = buildAggregationField("MAX", field.max);
     if (field.as)
         sql += ` AS ${getDialect().escape(field.as)}`;
     else if (field.sum)

package/src/utils/buildQuery/count.js

@@ -1,11 +0,0 @@
-const { getDialect } = require("../../db/dialects");
-
-module.exports = (field) => {
-    if (typeof field === 'string') return `COUNT(${getDialect().escape(field)})`;
-    if (field instanceof Array && field !== null) return field.map(col => `COUNT(${getDialect().escape(col)})`).join(' + ');
-    if (field instanceof Object) {
-        const [key, value] = Object.entries(field)[0];
-        return `COUNT(CASE WHEN ${getDialect().escape(key)} = ${getDialect().escapeValue(value)} THEN 1 END)`;
-    }
-    throw new Error("Invalid field type for COUNT. Must be a string, array, or object.");
-}