@dboio/cli 0.10.1 → 0.11.2

package/src/migrations/002-move-entity-dirs-to-lib.js

@@ -0,0 +1,190 @@
+import { readFile, writeFile, mkdir, rename, access, readdir, rmdir } from 'fs/promises';
+import { join } from 'path';
+import { log } from '../lib/logger.js';
+
+export const description = 'Relocated server entity directories into lib/';
+
+/** Entity dirs that should live under lib/ (the full list, in detection order) */
+const ENTITY_DIRS_TO_MOVE = [
+  'bins', 'extension', 'automation', 'app_version', 'entity',
+  'entity_column', 'entity_column_value', 'integration', 'security',
+  'security_column', 'data_source', 'group', 'site', 'redirect',
+];
+
+/**
+ * Migration 002 — Move root-level entity directories into lib/.
+ *
+ * Detects old flat-root layout, moves dirs to lib/, rewrites app.json @path
+ * references, updates structure.json extensionDescriptorDirs, renames tests/ → test/.
+ *
+ * @param {object} _options - Command options (unused)
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+
+  // Detect which old-layout dirs exist at root
+  const detected = [];
+  for (const dirName of ENTITY_DIRS_TO_MOVE) {
+    try {
+      await access(join(cwd, dirName));
+      detected.push(dirName);
+    } catch { /* not present */ }
+  }
+
+  if (detected.length === 0) {
+    // Check for tests/ → test/ rename even if no entity dirs to move
+    await renameTestsDir(cwd);
+    return;
+  }
+
+  // Create lib/ directory
+  await mkdir(join(cwd, 'lib'), { recursive: true });
+
+  let movedCount = 0;
+  for (const dirName of detected) {
+    const src = join(cwd, dirName);
+    const dest = join(cwd, 'lib', dirName);
+
+    try {
+      await access(dest);
+      // Destination already exists — merge: move files from src not in dest
+      await mergeDir(src, dest);
+      log.dim(`  ✓ Merged ${dirName}/ → lib/${dirName}/ (partial migration detected)`);
+    } catch {
+      // Destination absent — simple rename
+      await rename(src, dest);
+      log.dim(`  ✓ Moved ${dirName}/ → lib/${dirName}/`);
+    }
+    movedCount++;
+  }
+
+  // Rewrite app.json @path references
+  await rewriteAppJson(cwd, detected);
+
+  // Update .dbo/structure.json extensionDescriptorDirs
+  await rewriteStructureJson(cwd);
+
+  // Rename tests/ → test/ if present
+  await renameTestsDir(cwd);
+
+  log.success(`  Migration 002: Relocated ${movedCount} server director${movedCount === 1 ? 'y' : 'ies'} into lib/`);
+}
+
+/**
+ * Merge contents of srcDir into destDir without overwriting existing files.
+ * Recursively processes subdirectories.
+ */
+async function mergeDir(srcDir, destDir) {
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  await mkdir(destDir, { recursive: true });
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await mergeDir(srcPath, destPath);
+    } else {
+      try {
+        await access(destPath);
+        // File already in dest — skip to avoid overwriting
+      } catch {
+        await rename(srcPath, destPath);
+      }
+    }
+  }
+
+  // Remove now-empty source dir (best-effort)
+  try {
+    const remaining = await readdir(srcDir);
+    if (remaining.length === 0) {
+      await rmdir(srcDir);
+    }
+  } catch { /* ignore */ }
+}
+
+/**
+ * Rewrite app.json @path references from old root-level paths to lib/-prefixed paths.
+ * e.g. "@extension/foo.metadata.json" → "@lib/extension/foo.metadata.json"
+ *      "@bins/app/styles.css" → "@lib/bins/app/styles.css"
+ */
+async function rewriteAppJson(cwd, movedDirs) {
+  const appJsonPath = join(cwd, 'app.json');
+  let raw;
+  try {
+    raw = await readFile(appJsonPath, 'utf8');
+  } catch {
+    return; // no app.json — skip
+  }
+
+  let updated = raw;
+  for (const dirName of movedDirs) {
+    // Replace "@dirName/" with "@lib/dirName/"
+    // Use a global regex that handles the @ prefix in JSON string values
+    const pattern = new RegExp(`"@${dirName}/`, 'g');
+    updated = updated.replace(pattern, `"@lib/${dirName}/`);
+  }
+
+  if (updated !== raw) {
+    await writeFile(appJsonPath, updated);
+    log.dim('  ✓ Rewrote app.json @path references to lib/ prefix');
+  }
+}
+
+/**
+ * Update .dbo/structure.json extensionDescriptorDirs from "extension/..." to "lib/extension/...".
+ */
+async function rewriteStructureJson(cwd) {
+  const structurePath = join(cwd, '.dbo', 'structure.json');
+  let raw;
+  try {
+    raw = await readFile(structurePath, 'utf8');
+  } catch {
+    return; // no structure.json — skip
+  }
+
+  let structure;
+  try {
+    structure = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  if (!Array.isArray(structure.extensionDescriptorDirs)) return;
+
+  const updated = structure.extensionDescriptorDirs.map(dir => {
+    if (dir.startsWith('extension/') || dir === 'extension/_unsupported') {
+      return `lib/${dir}`;
+    }
+    // Already prefixed (re-entrant safety)
+    return dir;
+  });
+
+  structure.extensionDescriptorDirs = updated;
+  await writeFile(structurePath, JSON.stringify(structure, null, 2) + '\n');
+  log.dim('  ✓ Updated .dbo/structure.json extensionDescriptorDirs to lib/ prefix');
+}
+
+/**
+ * Rename tests/ → test/ at project root if tests/ exists and test/ does not.
+ */
+async function renameTestsDir(cwd) {
+  const testsSrc = join(cwd, 'tests');
+  const testDest = join(cwd, 'test');
+
+  try {
+    await access(testsSrc);
+  } catch {
+    return; // tests/ doesn't exist — nothing to do
+  }
+
+  try {
+    await access(testDest);
+    // test/ already exists — skip rename to avoid conflict
+    log.dim('  ⚠ Both tests/ and test/ exist — tests/ was not renamed; resolve manually');
+    return;
+  } catch { /* test/ absent — safe to rename */ }
+
+  await rename(testsSrc, testDest);
+  log.dim('  ✓ Renamed tests/ → test/');
+}

package/src/migrations/003-move-deploy-config.js

@@ -0,0 +1,50 @@
+import { access, rename, readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { log } from '../lib/logger.js';
+
+export const description = 'Moved deploy manifest from dbo.deploy.json to .dbo/deploy_config.json';
+
+/**
+ * Migration 003 — Move dbo.deploy.json → .dbo/deploy_config.json
+ *
+ * The deploy manifest now lives inside .dbo/ alongside other config files.
+ * Also removes the legacy `dbo.deploy.json` entry from .dboignore if present.
+ *
+ * @param {object} _options - Command options (unused)
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+  const legacyPath = join(cwd, 'dbo.deploy.json');
+  const newPath = join(cwd, '.dbo', 'deploy_config.json');
+
+  // Check if legacy file exists
+  try {
+    await access(legacyPath);
+  } catch {
+    return; // No legacy file — nothing to do
+  }
+
+  // Check if new location already exists (avoid overwriting)
+  try {
+    await access(newPath);
+    log.dim('  ⚠ Both dbo.deploy.json and .dbo/deploy_config.json exist — skipping move; resolve manually');
+    return;
+  } catch { /* new path absent — safe to move */ }
+
+  await rename(legacyPath, newPath);
+  log.dim('  ✓ Moved dbo.deploy.json → .dbo/deploy_config.json');
+
+  // Clean up .dboignore — remove the dbo.deploy.json entry if present
+  const dboignorePath = join(cwd, '.dboignore');
+  try {
+    const content = await readFile(dboignorePath, 'utf8');
+    const updated = content
+      .split('\n')
+      .filter(line => line.trim() !== 'dbo.deploy.json')
+      .join('\n');
+    if (updated !== content) {
+      await writeFile(dboignorePath, updated);
+      log.dim('  ✓ Removed dbo.deploy.json from .dboignore');
+    }
+  } catch { /* no .dboignore — skip */ }
+}

package/src/migrations/004-rename-output-files.js

@@ -0,0 +1,101 @@
+import { readdir, readFile, writeFile, rename, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { log } from '../lib/logger.js';
+
+export const description = 'Rename _output~ files to Name~UID convention';
+
+const OUTPUT_PREFIX = '_output~';
+
+/**
+ * Migration 004 — Rename output hierarchy files to drop the _output~ prefix.
+ *
+ * Old:  _output~task.info~UID.json, _output~task.info~UID.column~ColUID.CustomSQL.sql
+ * New:  task.info~UID.json,          task.info~UID.column~ColUID.CustomSQL.sql
+ *
+ * Also rewrites @_output~ references inside the root JSON files.
+ *
+ * @param {object} _options - Command options (unused)
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+  let totalRenamed = 0;
+
+  // Recursively find directories that contain _output~ files
+  const dirs = await findDirsWithOutputFiles(cwd);
+
+  for (const dir of dirs) {
+    const entries = await readdir(dir);
+    const outputFiles = entries.filter(f => f.startsWith(OUTPUT_PREFIX));
+    if (outputFiles.length === 0) continue;
+
+    for (const oldName of outputFiles) {
+      const newName = oldName.substring(OUTPUT_PREFIX.length);
+      const oldPath = join(dir, oldName);
+      const newPath = join(dir, newName);
+
+      // Skip if destination already exists (avoid overwrite)
+      try {
+        await access(newPath);
+        continue;
+      } catch { /* good — doesn't exist */ }
+
+      await rename(oldPath, newPath);
+      totalRenamed++;
+
+      // If it's a root JSON, also rewrite @_output~ references inside it
+      if (newName.endsWith('.json') && !newName.includes('.CustomSQL.')) {
+        await rewriteReferences(newPath);
+      }
+    }
+  }
+
+  if (totalRenamed > 0) {
+    log.dim(`  Renamed ${totalRenamed} output file${totalRenamed === 1 ? '' : 's'} (dropped _output~ prefix)`);
+  }
+}
+
+/**
+ * Rewrite @_output~ references in a JSON file's string values.
+ * e.g. "@_output~task.info~UID.column~ColUID.CustomSQL.sql"
+ *    → "@task.info~UID.column~ColUID.CustomSQL.sql"
+ */
+async function rewriteReferences(filePath) {
+  let raw;
+  try {
+    raw = await readFile(filePath, 'utf8');
+  } catch { return; }
+
+  const updated = raw.replace(/@_output~/g, '@');
+  if (updated !== raw) {
+    await writeFile(filePath, updated);
+  }
+}
+
+/**
+ * Recursively find directories that contain _output~ files.
+ * Skips .dbo/, node_modules/, trash/, .git/.
+ */
+async function findDirsWithOutputFiles(root) {
+  const SKIP = new Set(['.dbo', 'node_modules', 'trash', '.git', '.claude']);
+  const results = [];
+
+  async function walk(dir) {
+    let entries;
+    try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    let hasOutputFiles = false;
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIP.has(entry.name)) {
+          await walk(join(dir, entry.name));
+        }
+      } else if (entry.name.startsWith(OUTPUT_PREFIX)) {
+        hasOutputFiles = true;
+      }
+    }
+    if (hasOutputFiles) results.push(dir);
+  }
+
+  await walk(root);
+  return results;
+}