mdkg 0.4.2 → 0.5.0

package/dist/core/project_db_migrations.js

@@ -9,9 +9,9 @@ exports.projectDbStats = projectDbStats;
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const filesystem_authority_1 = require("./filesystem_authority");
 const project_db_1 = require("./project_db");
 const version_1 = require("./version");
-const atomic_1 = require("../util/atomic");
 const errors_1 = require("../util/errors");
 const FOUNDATION_MIGRATION_SQL = `
 CREATE TABLE IF NOT EXISTS project_meta (
@@ -219,46 +219,71 @@ function checksumContent(content) {
 }
 function assertDirectory(root, dirPath, label) {
     const relative = rel(root, dirPath);
-    if (!fs_1.default.existsSync(dirPath)) {
-        throw new errors_1.ValidationError(`${label} missing at ${relative}; run mdkg db init`);
+    try {
+        (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: relative, operation: "read" }, ({ absolutePath }) => {
+            if (!fs_1.default.existsSync(absolutePath)) {
+                throw new errors_1.ValidationError(`${label} missing at ${relative}; run mdkg db init`);
+            }
+            if (!fs_1.default.lstatSync(absolutePath).isDirectory()) {
+                throw new errors_1.ValidationError(`${relative} exists and is not a directory`);
+            }
+        });
     }
-    if (!fs_1.default.statSync(dirPath).isDirectory()) {
-        throw new errors_1.ValidationError(`${relative} exists and is not a directory`);
+    catch (error) {
+        if (error instanceof errors_1.ValidationError) {
+            throw error;
+        }
+        throw new errors_1.ValidationError(`${relative} is not a safe contained directory: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 function directoryCheck(root, dirPath, name) {
     const relative = rel(root, dirPath);
-    if (!fs_1.default.existsSync(dirPath)) {
-        return {
-            name,
-            ok: false,
-            level: "fail",
-            path: relative,
-            detail: `${name} missing`,
-            errors: [`${relative} missing; run mdkg db init`],
-            warnings: [],
-        };
+    try {
+        return (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: relative, operation: "read" }, ({ absolutePath }) => {
+            if (!fs_1.default.existsSync(absolutePath)) {
+                return {
+                    name,
+                    ok: false,
+                    level: "fail",
+                    path: relative,
+                    detail: `${name} missing`,
+                    errors: [`${relative} missing; run mdkg db init`],
+                    warnings: [],
+                };
+            }
+            if (!fs_1.default.lstatSync(absolutePath).isDirectory()) {
+                return {
+                    name,
+                    ok: false,
+                    level: "fail",
+                    path: relative,
+                    detail: `${name} is not a directory`,
+                    errors: [`${relative} exists and is not a directory`],
+                    warnings: [],
+                };
+            }
+            return {
+                name,
+                ok: true,
+                level: "ok",
+                path: relative,
+                detail: `${name} exists`,
+                errors: [],
+                warnings: [],
+            };
+        });
     }
-    if (!fs_1.default.statSync(dirPath).isDirectory()) {
+    catch (error) {
         return {
             name,
             ok: false,
             level: "fail",
             path: relative,
-            detail: `${name} is not a directory`,
-            errors: [`${relative} exists and is not a directory`],
+            detail: `${name} is not safely contained`,
+            errors: [`${relative} is not safely contained: ${error instanceof Error ? error.message : String(error)}`],
             warnings: [],
         };
     }
-    return {
-        name,
-        ok: true,
-        level: "ok",
-        path: relative,
-        detail: `${name} exists`,
-        errors: [],
-        warnings: [],
-    };
 }
 function assertProjectDbReady(root, config) {
     if (!config.db.enabled) {
@@ -274,31 +299,42 @@ function assertProjectDbReady(root, config) {
     assertDirectory(root, layout.runtimeDir, "project db runtime directory");
     assertDirectory(root, layout.stateDir, "project db state directory");
     assertDirectory(root, layout.receipts, "project db receipts directory");
-    if (fs_1.default.existsSync(layout.runtimeFile) && fs_1.default.statSync(layout.runtimeFile).isDirectory()) {
-        throw new errors_1.ValidationError(`${rel(root, layout.runtimeFile)} exists and is not a file`);
+    try {
+        (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: config.db.runtime_path, operation: "replace" }, ({ absolutePath }) => {
+            if (fs_1.default.existsSync(absolutePath) && fs_1.default.lstatSync(absolutePath).isDirectory()) {
+                throw new errors_1.ValidationError(`${rel(root, absolutePath)} exists and is not a file`);
+            }
+        });
+    }
+    catch (error) {
+        if (error instanceof errors_1.ValidationError) {
+            throw error;
+        }
+        throw new errors_1.ValidationError(`project db runtime path is not safely contained: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 function ensureMigrationFiles(root, config) {
     const layout = (0, project_db_1.resolveConfiguredProjectDbLayout)(root, config.db);
     const created = [];
     const unchanged = [];
+    const missing = [];
     for (const migration of BUILTIN_MIGRATIONS) {
         const filePath = path_1.default.join(layout.migrations, migration.filename);
         const expectedContent = `${migration.sql.trim()}\n`;
         const relative = rel(root, filePath);
-        if (fs_1.default.existsSync(filePath)) {
-            if (fs_1.default.statSync(filePath).isDirectory()) {
-                throw new errors_1.ValidationError(`${relative} exists and is not a file`);
-            }
-            const current = fs_1.default.readFileSync(filePath, "utf8");
+        if ((0, filesystem_authority_1.containedPathExists)({ root, relativePath: relative })) {
+            const current = (0, filesystem_authority_1.readContainedFile)({ root, relativePath: relative });
             if (checksumContent(current) !== checksumContent(expectedContent)) {
                 throw new errors_1.ValidationError(`migration file checksum drift at ${relative}`);
             }
             unchanged.push(relative);
             continue;
         }
-        (0, atomic_1.atomicWriteFile)(filePath, expectedContent);
-        created.push(relative);
+        missing.push({ relative, expectedContent });
+    }
+    for (const item of missing) {
+        (0, filesystem_authority_1.atomicReplaceContainedFile)({ root, relativePath: item.relative }, item.expectedContent);
+        created.push(item.relative);
     }
     return { created, unchanged };
 }
@@ -309,17 +345,18 @@ function checkMigrationFiles(root, config) {
         const filePath = path_1.default.join(layout.migrations, migration.filename);
         const relative = rel(root, filePath);
         const expectedContent = `${migration.sql.trim()}\n`;
-        if (!fs_1.default.existsSync(filePath)) {
-            errors.push(`${relative} missing; run mdkg db migrate`);
-            continue;
-        }
-        if (fs_1.default.statSync(filePath).isDirectory()) {
-            errors.push(`${relative} exists and is not a file`);
-            continue;
+        try {
+            if (!(0, filesystem_authority_1.containedPathExists)({ root, relativePath: relative })) {
+                errors.push(`${relative} missing; run mdkg db migrate`);
+                continue;
+            }
+            const current = (0, filesystem_authority_1.readContainedFile)({ root, relativePath: relative });
+            if (checksumContent(current) !== checksumContent(expectedContent)) {
+                errors.push(`migration file checksum drift at ${relative}`);
+            }
         }
-        const current = fs_1.default.readFileSync(filePath, "utf8");
-        if (checksumContent(current) !== checksumContent(expectedContent)) {
-            errors.push(`migration file checksum drift at ${relative}`);
+        catch (error) {
+            errors.push(`${relative} is not safely contained: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     return {
@@ -509,83 +546,84 @@ function runProjectDbMigrations(root, config) {
     assertProjectDbReady(root, config);
     const migrationFiles = ensureMigrationFiles(root, config);
     const layout = (0, project_db_1.resolveConfiguredProjectDbLayout)(root, config.db);
-    fs_1.default.mkdirSync(path_1.default.dirname(layout.runtimeFile), { recursive: true });
     const DatabaseSync = loadDatabaseCtor();
-    const db = new DatabaseSync(layout.runtimeFile);
     const statuses = [];
     let appliedCount = 0;
-    try {
-        db.exec("PRAGMA foreign_keys = ON;");
-        db.exec("PRAGMA synchronous = FULL;");
-        assertIntegrity(db);
-        db.exec(createMigrationTableSql(config.db.migration_table));
-        db.exec("BEGIN IMMEDIATE");
+    (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: config.db.runtime_path, operation: "replace", createParents: true }, ({ absolutePath }) => {
+        const db = new DatabaseSync(absolutePath);
         try {
-            const applied = readAppliedMigrations(db, config.db.migration_table);
-            const knownKeys = new Set(BUILTIN_MIGRATIONS.map((migration) => migration.key));
-            for (const appliedKey of applied.keys()) {
-                if (!knownKeys.has(appliedKey)) {
-                    throw new errors_1.ValidationError(`project DB contains unsupported migration ${appliedKey}`);
-                }
-            }
-            const now = Date.now();
-            for (const migration of BUILTIN_MIGRATIONS) {
-                const checksum = checksumMigration(migration);
-                const row = applied.get(migration.key);
-                if (row) {
-                    if (row.ordinal !== migration.ordinal) {
-                        throw new errors_1.ValidationError(`migration order drift for ${migration.key}`);
+            db.exec("PRAGMA foreign_keys = ON;");
+            db.exec("PRAGMA synchronous = FULL;");
+            assertIntegrity(db);
+            db.exec(createMigrationTableSql(config.db.migration_table));
+            db.exec("BEGIN IMMEDIATE");
+            try {
+                const applied = readAppliedMigrations(db, config.db.migration_table);
+                const knownKeys = new Set(BUILTIN_MIGRATIONS.map((migration) => migration.key));
+                for (const appliedKey of applied.keys()) {
+                    if (!knownKeys.has(appliedKey)) {
+                        throw new errors_1.ValidationError(`project DB contains unsupported migration ${appliedKey}`);
                     }
-                    if (row.checksum !== checksum) {
-                        throw new errors_1.ValidationError(`migration checksum drift for ${migration.key}`);
+                }
+                const now = Date.now();
+                for (const migration of BUILTIN_MIGRATIONS) {
+                    const checksum = checksumMigration(migration);
+                    const row = applied.get(migration.key);
+                    if (row) {
+                        if (row.ordinal !== migration.ordinal) {
+                            throw new errors_1.ValidationError(`migration order drift for ${migration.key}`);
+                        }
+                        if (row.checksum !== checksum) {
+                            throw new errors_1.ValidationError(`migration checksum drift for ${migration.key}`);
+                        }
+                        statuses.push({
+                            key: migration.key,
+                            ordinal: migration.ordinal,
+                            checksum,
+                            status: "already_applied",
+                            applied_at_ms: row.applied_at_ms,
+                        });
+                        continue;
                     }
+                    db.exec(migration.sql);
+                    const appliedAt = now + appliedCount;
+                    db
+                        .prepare(`INSERT INTO ${config.db.migration_table} (migration_key, ordinal, checksum, applied_at_ms, mdkg_version) VALUES (?, ?, ?, ?, ?)`)
+                        .run(migration.key, migration.ordinal, checksum, appliedAt, (0, version_1.readPackageVersion)());
                     statuses.push({
                         key: migration.key,
                         ordinal: migration.ordinal,
                         checksum,
-                        status: "already_applied",
-                        applied_at_ms: row.applied_at_ms,
+                        status: "applied",
+                        applied_at_ms: appliedAt,
                     });
-                    continue;
+                    appliedCount += 1;
                 }
-                db.exec(migration.sql);
-                const appliedAt = now + appliedCount;
-                db
-                    .prepare(`INSERT INTO ${config.db.migration_table} (migration_key, ordinal, checksum, applied_at_ms, mdkg_version) VALUES (?, ?, ?, ?, ?)`)
-                    .run(migration.key, migration.ordinal, checksum, appliedAt, (0, version_1.readPackageVersion)());
-                statuses.push({
-                    key: migration.key,
-                    ordinal: migration.ordinal,
-                    checksum,
-                    status: "applied",
-                    applied_at_ms: appliedAt,
-                });
-                appliedCount += 1;
+                syncProjectMeta(db, config);
+                db.exec("COMMIT");
             }
-            syncProjectMeta(db, config);
-            db.exec("COMMIT");
+            catch (err) {
+                try {
+                    db.exec("ROLLBACK");
+                }
+                catch {
+                    // ignore rollback failures when no transaction is active
+                }
+                throw err;
+            }
+            assertIntegrity(db);
         }
         catch (err) {
-            try {
-                db.exec("ROLLBACK");
+            if (err instanceof errors_1.ValidationError) {
+                throw err;
             }
-            catch {
-                // ignore rollback failures when no transaction is active
-            }
-            throw err;
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.ValidationError(`project DB migration failed: ${message}`);
         }
-        assertIntegrity(db);
-    }
-    catch (err) {
-        if (err instanceof errors_1.ValidationError) {
-            throw err;
+        finally {
+            db.close();
         }
-        const message = err instanceof Error ? err.message : String(err);
-        throw new errors_1.ValidationError(`project DB migration failed: ${message}`);
-    }
-    finally {
-        db.close();
-    }
+    });
     return {
         action: "db-migrate",
         ok: true,
@@ -628,36 +666,51 @@ function verifyProjectDb(root, config) {
     checks.push(directoryCheck(root, layout.stateDir, "project db state directory"));
     checks.push(directoryCheck(root, layout.receipts, "project db receipts directory"));
     const databasePath = rel(root, layout.runtimeFile);
-    if (!fs_1.default.existsSync(layout.runtimeFile)) {
-        checks.push({
-            name: "runtime-database",
-            ok: false,
-            level: "fail",
-            path: databasePath,
-            detail: "runtime database missing",
-            errors: [`${databasePath} missing; run mdkg db migrate`],
-            warnings: [],
+    try {
+        (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: config.db.runtime_path, operation: "read" }, ({ absolutePath }) => {
+            if (!fs_1.default.existsSync(absolutePath)) {
+                checks.push({
+                    name: "runtime-database",
+                    ok: false,
+                    level: "fail",
+                    path: databasePath,
+                    detail: "runtime database missing",
+                    errors: [`${databasePath} missing; run mdkg db migrate`],
+                    warnings: [],
+                });
+            }
+            else if (fs_1.default.lstatSync(absolutePath).isDirectory()) {
+                checks.push({
+                    name: "runtime-database",
+                    ok: false,
+                    level: "fail",
+                    path: databasePath,
+                    detail: "runtime database path is not a file",
+                    errors: [`${databasePath} exists and is not a file`],
+                    warnings: [],
+                });
+            }
+            else {
+                checks.push({
+                    name: "runtime-database",
+                    ok: true,
+                    level: "ok",
+                    path: databasePath,
+                    detail: "runtime database exists",
+                    errors: [],
+                    warnings: [],
+                });
+            }
         });
     }
-    else if (fs_1.default.statSync(layout.runtimeFile).isDirectory()) {
+    catch (error) {
         checks.push({
             name: "runtime-database",
             ok: false,
             level: "fail",
             path: databasePath,
-            detail: "runtime database path is not a file",
-            errors: [`${databasePath} exists and is not a file`],
-            warnings: [],
-        });
-    }
-    else {
-        checks.push({
-            name: "runtime-database",
-            ok: true,
-            level: "ok",
-            path: databasePath,
-            detail: "runtime database exists",
-            errors: [],
+            detail: "runtime database is not safely contained",
+            errors: [`${databasePath} is not safely contained: ${error instanceof Error ? error.message : String(error)}`],
             warnings: [],
         });
     }
@@ -667,14 +720,16 @@ function verifyProjectDb(root, config) {
         checks.push(checkMigrationFiles(root, config));
         const DatabaseSync = loadDatabaseCtor();
         try {
-            const db = new DatabaseSync(layout.runtimeFile);
-            try {
-                checks.push(integrityCheck(db));
-                checks.push(migrationTableCheck(db, config));
-            }
-            finally {
-                db.close();
-            }
+            (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: config.db.runtime_path, operation: "read" }, ({ absolutePath }) => {
+                const db = new DatabaseSync(absolutePath);
+                try {
+                    checks.push(integrityCheck(db));
+                    checks.push(migrationTableCheck(db, config));
+                }
+                finally {
+                    db.close();
+                }
+            });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -712,49 +767,51 @@ function projectDbStats(root, config) {
     }
     const layout = (0, project_db_1.resolveConfiguredProjectDbLayout)(root, config.db);
     const DatabaseSync = loadDatabaseCtor();
-    const db = new DatabaseSync(layout.runtimeFile);
-    try {
-        const applied = readAppliedMigrations(db, config.db.migration_table);
-        const migrationStatuses = BUILTIN_MIGRATIONS
-            .map((migration) => {
-            const row = applied.get(migration.key);
-            return row
-                ? {
-                    key: migration.key,
-                    ordinal: migration.ordinal,
-                    checksum: row.checksum,
-                    status: "already_applied",
-                    applied_at_ms: row.applied_at_ms,
-                }
-                : undefined;
-        })
-            .filter((item) => item !== undefined);
-        const latestMigration = migrationStatuses[migrationStatuses.length - 1] ?? null;
-        const receiptFiles = walkFiles(layout.receipts);
-        return {
-            action: "db-stats",
-            ok: true,
-            enabled: config.db.enabled,
-            database: rel(root, layout.runtimeFile),
-            schema_version: config.db.schema_version,
-            migration_table: config.db.migration_table,
-            db_size: fs_1.default.statSync(layout.runtimeFile).size,
-            transient_files: transientFiles(root, layout.runtimeFile),
-            migration_count: migrationStatuses.length,
-            latest_migration: latestMigration,
-            tables: tableCounts(db),
-            state_snapshot: {
-                path: rel(root, layout.stateFile),
-                exists: fs_1.default.existsSync(layout.stateFile),
-                size: fs_1.default.existsSync(layout.stateFile) ? fs_1.default.statSync(layout.stateFile).size : 0,
-            },
-            receipt_files: {
-                path: rel(root, layout.receipts),
-                count: receiptFiles.length,
-            },
-        };
-    }
-    finally {
-        db.close();
-    }
+    return (0, filesystem_authority_1.withContainedPathSink)({ root, relativePath: config.db.runtime_path, operation: "read" }, ({ absolutePath }) => {
+        const db = new DatabaseSync(absolutePath);
+        try {
+            const applied = readAppliedMigrations(db, config.db.migration_table);
+            const migrationStatuses = BUILTIN_MIGRATIONS
+                .map((migration) => {
+                const row = applied.get(migration.key);
+                return row
+                    ? {
+                        key: migration.key,
+                        ordinal: migration.ordinal,
+                        checksum: row.checksum,
+                        status: "already_applied",
+                        applied_at_ms: row.applied_at_ms,
+                    }
+                    : undefined;
+            })
+                .filter((item) => item !== undefined);
+            const latestMigration = migrationStatuses[migrationStatuses.length - 1] ?? null;
+            const receiptFiles = walkFiles(layout.receipts);
+            return {
+                action: "db-stats",
+                ok: true,
+                enabled: config.db.enabled,
+                database: rel(root, absolutePath),
+                schema_version: config.db.schema_version,
+                migration_table: config.db.migration_table,
+                db_size: fs_1.default.statSync(absolutePath).size,
+                transient_files: transientFiles(root, absolutePath),
+                migration_count: migrationStatuses.length,
+                latest_migration: latestMigration,
+                tables: tableCounts(db),
+                state_snapshot: {
+                    path: rel(root, layout.stateFile),
+                    exists: fs_1.default.existsSync(layout.stateFile),
+                    size: fs_1.default.existsSync(layout.stateFile) ? fs_1.default.statSync(layout.stateFile).size : 0,
+                },
+                receipt_files: {
+                    path: rel(root, layout.receipts),
+                    count: receiptFiles.length,
+                },
+            };
+        }
+        finally {
+            db.close();
+        }
+    });
 }