@verdnatura/myt 1.5.24 → 1.5.26

package/README.md

@@ -250,7 +250,7 @@ $ myt create [-t <type>] <schema>.<name>
 Cleans all already applied versions older than  *maxOldVersions*.
 
 ```text
-$ myt clean
+$ myt clean [-p|--purge]
 ```
 
 ## Local server commands
@@ -276,8 +276,7 @@ $ myt fixtures [<remote>]
 ### run
 
 Builds and starts local database server container. It only rebuilds the image 
-when fixtures have been modified or when the day on which the image was built 
-is different to today.
+dump has been modified.
 
 ```text
 $ myt run [-c|--ci] [-r|--random]

package/myt-clean.js

@@ -8,26 +8,36 @@ const path = require('path');
  */
 class Clean extends Command {
     static usage = {
-        description: 'Cleans old applied versions'
+        description: 'Cleans old applied versions',
+        params: {
+            purge: 'Wether to remove non-existent scripts from DB log'
+        }
     };
 
     static opts = {
+        alias: {
+            purge: 'p'
+        },
+        boolean: [
+            'purge'
+        ],
         default: {
             remote: 'production'
         }
     };
 
     async run(myt, opts) {
-        await myt.dbConnect();
+        const conn = await myt.dbConnect();
+        const versionDirs = await fs.readdir(opts.versionsDir);
+        const archiveDir = path.join(opts.versionsDir, '.archive');
+
         const dbVersion = await myt.fetchDbVersion() || {};
         const number = parseInt(dbVersion.number);
 
         const oldVersions = [];
-        const versionDirs = await fs.readdir(opts.versionsDir);
         for (const versionDir of versionDirs) {
             const version = await myt.loadVersion(versionDir);
             const shouldArchive = version
-                && version.matchRegex
                 && !version.apply
                 && parseInt(version.number) < number;
 
@@ -39,19 +49,85 @@ class Clean extends Command {
         && oldVersions.length > opts.maxOldVersions) {
             oldVersions.splice(-opts.maxOldVersions);
 
-            const archiveDir = path.join(opts.versionsDir, '.archive');
             if (!await fs.pathExists(archiveDir))
                 await fs.mkdir(archiveDir);
 
-            for (const oldVersion of oldVersions)
-                await fs.move(
-                    path.join(opts.versionsDir, oldVersion),
-                    path.join(archiveDir, oldVersion)
-                );
+            for (const oldVersion of oldVersions) {
+                const srcDir = path.join(opts.versionsDir, oldVersion);
+                const dstDir = path.join(archiveDir, oldVersion);
+
+                if (!await fs.pathExists(dstDir))
+                    await fs.mkdir(dstDir);
+
+                const scripts = await fs.readdir(srcDir);
+                for (const script of scripts) {
+                    await fs.move(
+                        path.join(srcDir, script),
+                        path.join(dstDir, script),
+                        {overwrite: true}
+                    );
+                }
+
+                await fs.rmdir(srcDir);
+            }
 
             console.log(`Old versions archived: ${oldVersions.length}`);
         } else
             console.log(`No versions to archive.`);
+
+        if (opts.purge) {
+            const versionDb = new VersionDb(myt, opts.versionsDir);
+            versionDb.load();
+
+            const archiveDb = new VersionDb(myt, archiveDir);
+            archiveDb.load();
+
+            const [res] = await conn.query(
+                `SELECT number, file FROM versionLog
+                    WHERE code = ?
+                    ORDER BY number, file`,
+                [opts.code]
+            );
+
+            for (const script of res) {
+                const hasVersion = await versionDb.hasScript(script);
+                const hasArchive = await archiveDb.hasScript(script);
+    
+                if (!hasVersion && !hasArchive) {
+                    await conn.query(
+                        `DELETE FROM versionLog
+                            WHERE code = ? AND number = ? AND file = ?`,
+                        [opts.code, script.number, script.file]
+                    );
+                }
+            }
+        }
+    }
+}
+
+class VersionDb {
+    constructor(myt, baseDir) {
+        Object.assign(this, {myt, baseDir});
+    }
+
+    async load() {
+        const versionMap = this.versionMap = new Map();
+        if (await fs.pathExists(this.baseDir)) {
+            const dirs = await fs.readdir(this.baseDir);
+            for (const dir of dirs) {
+                const version = this.myt.parseVersionDir(dir);
+                if (!version) continue;
+                versionMap.set(version.number, dir);
+            }
+        }
+        return versionMap;
+    }
+
+    async hasScript(script) {
+        const dir = this.versionMap.get(script.number);
+        if (!dir) return false;
+        const scriptPath = path.join(this.baseDir, dir, script.file);
+        return await fs.pathExists(scriptPath);
     }
 }
 

package/myt-run.js

@@ -9,10 +9,9 @@ const connExt = require('./lib/conn');
 const SqlString = require('sqlstring');
 
 /**
- * Builds the database image and runs a container. It only rebuilds the
- * image when fixtures have been modified or when the day on which the
- * image was built is different to today. Some workarounds have been used
- * to avoid a bug with OverlayFS driver on MacOS.
+ * Builds the database image and runs a container. It only rebuilds the image
+ * when dump has been modified. Some workarounds have been used to avoid a bug
+ * with OverlayFS driver on MacOS.
  */
 class Run extends Command {
     static usage = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdnatura/myt",
-  "version": "1.5.24",
+  "version": "1.5.26",
   "author": "Verdnatura Levante SL",
   "description": "MySQL version control",
   "license": "GPL-3.0",