@dboio/cli 0.13.2 → 0.15.0

package/src/migrations/007-natural-entity-companion-filenames.js

@@ -0,0 +1,165 @@
+import { readdir, readFile, writeFile, rename, access, mkdir } from 'fs/promises';
+import { join, basename, dirname } from 'path';
+import { log } from '../lib/logger.js';
+import { stripUidFromFilename, hasUidInFilename, isMetadataFile } from '../lib/filenames.js';
+import { ensureTrashIcon } from '../lib/tagging.js';
+
+export const description = 'Rename entity/extension companion files from name~uid.Col.ext to name.Col.ext';
+
+/**
+ * Migration 007 — Strip ~UID from entity and extension companion files.
+ *
+ * Previous convention: entity companion files included ~UID in the filename,
+ * e.g. "Add-Asst-Execute-Security~wxl6ivcwfkix3zgantszjg.String16.js".
+ *
+ * New convention: only .metadata.json files carry ~UID. Companion files use
+ * the natural base name, e.g. "Add-Asst-Execute-Security.String16.js".
+ *
+ * For each metadata file in entity directories (lib/extension/, lib/automation/,
+ * lib/data_source/, etc.):
+ *   1. Check each @reference in _contentColumns
+ *   2. If the reference contains ~UID, strip it, rename the file, update the reference
+ *   3. If both natural and legacy files exist, move the legacy to trash/
+ *
+ * Also handles name collisions: if stripping ~UID from two different records
+ * produces the same natural companion name, the second keeps its ~UID reference
+ * to avoid data loss.
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+  let totalRenamed = 0;
+  let totalRefsUpdated = 0;
+
+  const metaFiles = await findEntityMetadataFiles(cwd);
+  if (metaFiles.length === 0) return;
+
+  // Track natural names we've claimed, to detect collisions
+  // Key: absolute natural path → true
+  const claimedNaturals = new Set();
+
+  for (const metaPath of metaFiles) {
+    try {
+      const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+      const uid = meta.UID;
+      if (!uid) continue;
+
+      const metaDir = dirname(metaPath);
+      const contentCols = [...(meta._contentColumns || [])];
+      if (meta._mediaFile) contentCols.push('_mediaFile');
+      let metaChanged = false;
+
+      for (const col of contentCols) {
+        const ref = meta[col];
+        if (!ref || !String(ref).startsWith('@')) continue;
+
+        const refName = String(ref).substring(1);
+
+        // Only process references that contain ~UID
+        if (!hasUidInFilename(refName, uid)) continue;
+
+        const naturalName = stripUidFromFilename(refName, uid);
+        const legacyPath = refName.startsWith('/')
+          ? join(cwd, refName)
+          : join(metaDir, refName);
+        const naturalPath = refName.startsWith('/')
+          ? join(cwd, naturalName)
+          : join(metaDir, naturalName);
+
+        // Collision check: if another record already claimed this natural path, skip
+        if (claimedNaturals.has(naturalPath)) {
+          log.dim(`  Skipped ${refName} (natural name collision with another record)`);
+          continue;
+        }
+
+        let legacyExists = false;
+        let naturalExists = false;
+        try { await access(legacyPath); legacyExists = true; } catch { /* missing */ }
+        try { await access(naturalPath); naturalExists = true; } catch { /* missing */ }
+
+        if (legacyExists && !naturalExists) {
+          // Rename legacy → natural
+          try {
+            await rename(legacyPath, naturalPath);
+            log.dim(`  ${refName} → ${naturalName}`);
+            totalRenamed++;
+          } catch { /* rename failed — keep reference as-is */ continue; }
+        } else if (legacyExists && naturalExists) {
+          // Both exist — move orphaned legacy to trash
+          try {
+            const trashDir = join(cwd, 'trash');
+            await mkdir(trashDir, { recursive: true });
+            await rename(legacyPath, join(trashDir, basename(legacyPath)));
+            await ensureTrashIcon(trashDir);
+            log.dim(`  Trashed orphan: ${refName}`);
+            totalRenamed++;
+          } catch { /* non-critical */ }
+        }
+        // else: legacy doesn't exist — just update the reference
+
+        // Update @reference to natural name
+        meta[col] = `@${naturalName}`;
+        metaChanged = true;
+        claimedNaturals.add(naturalPath);
+      }
+
+      // Rewrite metadata if @references were updated
+      if (metaChanged) {
+        try {
+          await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+          totalRefsUpdated++;
+        } catch { /* non-critical */ }
+      }
+    } catch { /* skip unreadable metadata */ }
+  }
+
+  if (totalRenamed > 0 || totalRefsUpdated > 0) {
+    log.dim(`  Renamed ${totalRenamed} entity companion file(s), updated ${totalRefsUpdated} metadata @reference(s)`);
+  }
+}
+
+/** Directories that hold entity/extension metadata (under lib/) */
+const ENTITY_DIRS = new Set([
+  'extension', 'automation', 'app_version', 'entity', 'entity_column',
+  'entity_column_value', 'integration', 'security', 'security_column',
+  'data_source', 'group', 'site', 'redirect',
+]);
+
+const SKIP = new Set(['.dbo', 'node_modules', 'trash', '.git', '.claude']);
+
+/**
+ * Find all .metadata.json files inside entity directories (lib/<entity>/).
+ * Skips content/media in Bins/ — those are handled by migration 006.
+ */
+async function findEntityMetadataFiles(cwd) {
+  const results = [];
+  const libDir = join(cwd, 'lib');
+
+  let libEntries;
+  try { libEntries = await readdir(libDir, { withFileTypes: true }); } catch { return results; }
+
+  for (const entry of libEntries) {
+    if (!entry.isDirectory()) continue;
+    if (SKIP.has(entry.name)) continue;
+    if (!ENTITY_DIRS.has(entry.name)) continue;
+
+    await scanDir(join(libDir, entry.name), results);
+  }
+
+  return results;
+}
+
+async function scanDir(dir, results) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+
+  for (const entry of entries) {
+    if (SKIP.has(entry.name) || entry.name.startsWith('.')) continue;
+    const full = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      await scanDir(full, results);
+    } else if (isMetadataFile(entry.name)) {
+      results.push(full);
+    }
+  }
+}

package/src/migrations/008-metadata-uid-in-suffix.js

@@ -0,0 +1,70 @@
+import { readdir, rename, access } from 'fs/promises';
+import { join, basename, dirname } from 'path';
+import { log } from '../lib/logger.js';
+import { detectLegacyTildeMetadata, buildMetaFilename } from '../lib/filenames.js';
+
+export const description = 'Rename metadata files from name~uid.metadata.json to name.metadata~uid.json';
+
+/**
+ * Migration 008 — Move UID from metadata filename base to suffix.
+ *
+ * Old format: colors~abc123.metadata.json
+ * New format: colors.metadata~abc123.json
+ *
+ * Also handles media metadata: logo~uid.png.metadata.json → logo.png.metadata~uid.json
+ *
+ * Does NOT rename companion files (they are already natural-named).
+ * Updates no @references — @references point to companion files, which are unchanged.
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+  let totalRenamed = 0;
+
+  const metaFiles = await findAllLegacyMetadataFiles(cwd);
+  if (metaFiles.length === 0) return;
+
+  for (const metaPath of metaFiles) {
+    const filename = basename(metaPath);
+    const dir = dirname(metaPath);
+
+    // Detect legacy tilde format: name~uid.metadata.json or name~uid.ext.metadata.json
+    const parsed = detectLegacyTildeMetadata(filename);
+    if (!parsed) continue;
+
+    const { naturalBase, uid } = parsed;
+    const newFilename = buildMetaFilename(naturalBase, uid);
+    const newPath = join(dir, newFilename);
+
+    // Skip if target already exists (avoid overwrite)
+    try { await access(newPath); continue; } catch { /* doesn't exist, safe to rename */ }
+
+    try {
+      await rename(metaPath, newPath);
+      log.dim(`  ${filename} → ${newFilename}`);
+      totalRenamed++;
+    } catch { /* non-critical: leave as-is */ }
+  }
+
+  if (totalRenamed > 0) {
+    log.dim(`  Renamed ${totalRenamed} metadata file(s) to new suffix convention`);
+  }
+}
+
+const SKIP = new Set(['.dbo', 'node_modules', 'trash', '.git', '.claude']);
+
+async function findAllLegacyMetadataFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP.has(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await findAllLegacyMetadataFiles(full));
+      } else if (detectLegacyTildeMetadata(entry.name)) {
+        results.push(full);
+      }
+    }
+  } catch { /* skip unreadable dirs */ }
+  return results;
+}