@dboio/cli 0.16.2 → 0.19.0

package/src/migrations/012-project-dir-restructure.js

@@ -0,0 +1,211 @@
+import { readFile, writeFile, rename, mkdir, rm, readdir, access } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export const description = 'Rename .dbo/ → .app/; rename baseline/structure/metadata files; move dependencies → app_dependencies/; move config.local.json → ~/.dbo/settings.json; remove schema.json';
+
+async function fileExists(p) {
+  try { await access(p); return true; } catch { return false; }
+}
+
+export default async function run() {
+  const cwd = process.cwd();
+  const log = (...args) => console.log(...args);
+
+  const dboDirPath = join(cwd, '.dbo');
+  const appDirPath = join(cwd, '.app');
+
+  // Guard: skip if already on new layout
+  if (!(await fileExists(dboDirPath)) || (await fileExists(appDirPath))) {
+    log('  .dbo/ not found or .app/ already exists — skipping');
+    return;
+  }
+
+  // Step 1: Read AppShortName from .dbo/config.json BEFORE rename
+  let appShortName = null;
+  try {
+    const cfg = JSON.parse(await readFile(join(dboDirPath, 'config.json'), 'utf8'));
+    appShortName = cfg.AppShortName || null;
+  } catch { /* no config — proceed without AppShortName */ }
+
+  const safeName = appShortName
+    ? String(appShortName).replace(/[/\\:*?"<>|]/g, '-')
+    : null;
+
+  // Step 2: Rename .dbo/ → .app/
+  try {
+    await rename(dboDirPath, appDirPath);
+    log(`  Renamed .dbo/ → .app/`);
+  } catch (err) {
+    log(`  (skip) Could not rename .dbo/ → .app/: ${err.message}`);
+    return;
+  }
+
+  // Step 3: Rename .app/.app_baseline.json → .app/<shortName>.json
+  if (safeName) {
+    const oldBaseline = join(appDirPath, '.app_baseline.json');
+    const newBaseline = join(appDirPath, `${safeName}.json`);
+    if ((await fileExists(oldBaseline)) && !(await fileExists(newBaseline))) {
+      try {
+        await rename(oldBaseline, newBaseline);
+        log(`  Renamed .app/.app_baseline.json → .app/${safeName}.json`);
+      } catch (e) { log(`  (skip) baseline rename: ${e.message}`); }
+    }
+  }
+
+  // Step 4: Rename .app/structure.json → .app/directories.json
+  const oldStructure = join(appDirPath, 'structure.json');
+  const newStructure = join(appDirPath, 'directories.json');
+  if ((await fileExists(oldStructure)) && !(await fileExists(newStructure))) {
+    try {
+      await rename(oldStructure, newStructure);
+      log(`  Renamed .app/structure.json → .app/directories.json`);
+    } catch (e) { log(`  (skip) structure rename: ${e.message}`); }
+  }
+
+  // Step 4b: Rename .app/metadata_schema.json → .app/<shortName>.metadata_schema.json
+  if (safeName) {
+    const oldSchema = join(appDirPath, 'metadata_schema.json');
+    const newSchema = join(appDirPath, `${safeName}.metadata_schema.json`);
+    if ((await fileExists(oldSchema)) && !(await fileExists(newSchema))) {
+      try {
+        await rename(oldSchema, newSchema);
+        log(`  Renamed .app/metadata_schema.json → .app/${safeName}.metadata_schema.json`);
+      } catch (e) { log(`  (skip) metadata_schema rename: ${e.message}`); }
+    }
+  }
+
+  // Step 5: Move .app/dependencies/ → app_dependencies/
+  const oldDepsDir = join(appDirPath, 'dependencies');
+  const newDepsRoot = join(cwd, 'app_dependencies');
+  if (await fileExists(oldDepsDir)) {
+    try {
+      await mkdir(newDepsRoot, { recursive: true });
+      const depNames = await readdir(oldDepsDir);
+      for (const name of depNames) {
+        const src = join(oldDepsDir, name);
+        const dest = join(newDepsRoot, name);
+        if (!(await fileExists(dest))) {
+          await rename(src, dest);
+          log(`  Moved app_dependencies/${name}`);
+        }
+      }
+      try { await rm(oldDepsDir, { recursive: true }); } catch { /* non-empty */ }
+    } catch (e) { log(`  (skip) dependencies move: ${e.message}`); }
+  }
+
+  // Step 6: Move root app.json → .app/<shortName>.metadata.json
+  if (safeName) {
+    const rootAppJson = join(cwd, 'app.json');
+    const newMetaPath = join(appDirPath, `${safeName}.metadata.json`);
+    if ((await fileExists(rootAppJson)) && !(await fileExists(newMetaPath))) {
+      try {
+        await rename(rootAppJson, newMetaPath);
+        log(`  Moved app.json → .app/${safeName}.metadata.json`);
+      } catch (e) { log(`  (skip) app.json move: ${e.message}`); }
+    }
+  }
+
+  // Step 7: Remove root schema.json
+  const rootSchema = join(cwd, 'schema.json');
+  if (await fileExists(rootSchema)) {
+    try {
+      await rm(rootSchema);
+      log(`  Removed schema.json (schema now sourced from app_dependencies/_system/.app/_system.json)`);
+    } catch (e) { log(`  (skip) schema.json removal: ${e.message}`); }
+  }
+
+  // Step 8: Move .app/config.local.json → ~/.dbo/settings.json
+  const oldLocal = join(appDirPath, 'config.local.json');
+  const globalSettingsDir = join(homedir(), '.dbo');
+  const globalSettings = join(globalSettingsDir, 'settings.json');
+  if (await fileExists(oldLocal)) {
+    try {
+      await mkdir(globalSettingsDir, { recursive: true });
+      let oldData = {};
+      try { oldData = JSON.parse(await readFile(oldLocal, 'utf8')); } catch { /* ignore */ }
+
+      let newData = {};
+      try { newData = JSON.parse(await readFile(globalSettings, 'utf8')); } catch { /* new file */ }
+
+      if (oldData.plugins) {
+        if (!newData.plugins) newData.plugins = {};
+        Object.assign(newData.plugins, oldData.plugins);
+      }
+
+      if (Array.isArray(oldData._completedMigrations) && oldData._completedMigrations.length > 0) {
+        if (!newData._completedMigrations) newData._completedMigrations = {};
+        const existing = new Set(Array.isArray(newData._completedMigrations[cwd]) ? newData._completedMigrations[cwd] : []);
+        for (const id of oldData._completedMigrations) existing.add(id);
+        newData._completedMigrations[cwd] = [...existing].sort();
+      }
+
+      await writeFile(globalSettings, JSON.stringify(newData, null, 2) + '\n');
+      try { await rm(oldLocal); } catch { /* leave it */ }
+      log(`  Merged .app/config.local.json → ~/.dbo/settings.json`);
+    } catch (e) { log(`  (skip) config.local.json merge: ${e.message}`); }
+  }
+
+  // Step 9: Update .gitignore
+  const gitignorePath = join(cwd, '.gitignore');
+  try {
+    let content = '';
+    try { content = await readFile(gitignorePath, 'utf8'); } catch { /* no .gitignore */ }
+
+    const replacements = [
+      ['.dbo/credentials.json', '.app/credentials.json'],
+      ['.dbo/cookies.txt', '.app/cookies.txt'],
+      ['.dbo/config.local.json', null],
+      ['.dbo/.app_baseline.json', null],
+      ['.dbo/ticketing.local.json', '.app/ticketing.local.json'],
+      ['.dbo/scripts.local.json', '.app/scripts.local.json'],
+      ['.dbo/errors.log', '.app/errors.log'],
+      ['.dbo/dependencies/', null],
+      ['schema.json', null],
+    ];
+
+    let changed = false;
+    let lines = content.split('\n');
+
+    for (const [oldPat, newPat] of replacements) {
+      const idx = lines.findIndex(l => l.trim() === oldPat);
+      if (idx >= 0) {
+        if (newPat) { lines[idx] = newPat; }
+        else lines.splice(idx, 1);
+        changed = true;
+      } else if (newPat && !content.includes(newPat)) {
+        lines.push(newPat);
+        changed = true;
+      }
+    }
+
+    if (!content.includes('app_dependencies/')) {
+      lines.push('app_dependencies/');
+      changed = true;
+    }
+
+    if (changed) {
+      await writeFile(gitignorePath, lines.join('\n'));
+      log(`  Updated .gitignore with new .app/ paths`);
+    }
+  } catch (e) { log(`  (skip) .gitignore update: ${e.message}`); }
+
+  // Step 10: Update .dboignore
+  const dboignorePath = join(cwd, '.dboignore');
+  try {
+    let content = await readFile(dboignorePath, 'utf8');
+    const updated = content
+      .replace(/^\.dbo\/$/m, '.app/')
+      .replace(/^\.dbo\/dependencies\/$/m, '')
+      .replace(/^app\.json$/m, '');
+    if (!updated.includes('app_dependencies/')) {
+      const finalContent = updated.replace(/^\.app\/$/m, '.app/\napp_dependencies/');
+      await writeFile(dboignorePath, finalContent);
+    } else {
+      await writeFile(dboignorePath, updated);
+    }
+    log(`  Updated .dboignore`);
+  } catch { /* no .dboignore */ }
+
+  log(`  Migration 012 complete: .dbo/ → .app/`);
+}