@dboio/cli 0.11.4 → 0.13.2

package/src/lib/scripts.js

@@ -0,0 +1,232 @@
+// src/lib/scripts.js
+import { spawn } from 'child_process';
+
+const HOOK_NAMES = ['prebuild', 'build', 'postbuild', 'prepush', 'push', 'postpush'];
+
+/**
+ * Merge scripts.json with scripts.local.json.
+ * scripts.local.json keys take precedence over scripts.json at each scope level.
+ *
+ * @param {object|null} base   - Parsed scripts.json (or null)
+ * @param {object|null} local  - Parsed scripts.local.json (or null)
+ * @returns {object} - Merged config with { scripts, targets, entities } keys
+ */
+export function mergeScriptsConfig(base, local) {
+  const merged = {
+    scripts: Object.assign({}, base?.scripts, local?.scripts),
+    targets: {},
+    entities: {},
+  };
+  // Merge target entries: normalize path separators, local overrides base per-hook
+  const allTargetKeys = new Set([
+    ...Object.keys(base?.targets || {}),
+    ...Object.keys(local?.targets || {}),
+  ]);
+  for (const key of allTargetKeys) {
+    const normalKey = key.replace(/\\/g, '/');
+    merged.targets[normalKey] = Object.assign(
+      {},
+      base?.targets?.[key],
+      local?.targets?.[key]
+    );
+  }
+  // Merge entity entries: local overrides base per-hook
+  const allEntityKeys = new Set([
+    ...Object.keys(base?.entities || {}),
+    ...Object.keys(local?.entities || {}),
+  ]);
+  for (const key of allEntityKeys) {
+    merged.entities[key] = Object.assign(
+      {},
+      base?.entities?.[key],
+      local?.entities?.[key]
+    );
+  }
+  return merged;
+}
+
+/**
+ * Resolve hooks for a given file path and entity type.
+ * Resolution order (highest priority first): target → entity → global scripts.
+ * Resolution is per-hook — a target can override 'build' while global 'prepush' still applies.
+ *
+ * @param {string} filePath     - Relative file path from project root (forward slashes)
+ * @param {string} entityType   - Entity type string (e.g., 'content', 'extension.control')
+ * @param {object} config       - Merged scripts config from mergeScriptsConfig()
+ * @returns {object} - Resolved hook map: { prebuild, build, postbuild, prepush, push, postpush }
+ *                     Each value is the resolved hook (string|string[]|false|true|undefined)
+ */
+export function resolveHooks(filePath, entityType, config) {
+  const normalPath = filePath.replace(/\\/g, '/');
+  const resolved = {};
+
+  for (const hook of HOOK_NAMES) {
+    let value;
+
+    // 1. Global scripts (lowest priority)
+    if (config.scripts && hook in config.scripts) {
+      value = config.scripts[hook];
+    }
+
+    // 2. Entity-level: check both 'extension' (base) and 'extension.control' (specific)
+    // More-specific descriptor match overrides base entity match
+    const [baseEntity] = entityType.split('.');
+    if (baseEntity !== entityType && config.entities[baseEntity] && hook in config.entities[baseEntity]) {
+      value = config.entities[baseEntity][hook];
+    }
+    if (config.entities[entityType] && hook in config.entities[entityType]) {
+      value = config.entities[entityType][hook];
+    }
+
+    // 3. Target-level (highest priority): exact path match OR directory prefix match
+    for (const [targetKey, targetHooks] of Object.entries(config.targets)) {
+      const isDir = targetKey.endsWith('/');
+      const matches = isDir
+        ? normalPath.startsWith(targetKey) || normalPath.startsWith(targetKey.slice(0, -1) + '/')
+        : normalPath === targetKey;
+      if (matches && targetHooks && hook in targetHooks) {
+        value = targetHooks[hook];
+      }
+    }
+
+    if (value !== undefined) resolved[hook] = value;
+  }
+
+  return resolved;
+}
+
+/**
+ * Execute a single hook value.
+ * - string: run as shell command
+ * - string[]: run sequentially, fail-fast on first non-zero exit
+ * - false: no-op (returns { skipped: false })
+ * - true/undefined: no-op (use default behavior)
+ *
+ * @param {string|string[]|boolean|undefined} hookValue
+ * @param {object} env  - Environment variables to inject (merged with process.env)
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]  - Working directory (default: process.cwd())
+ * @returns {Promise<{ skipped: boolean, exitCode: number|null }>}
+ */
+export async function runHook(hookValue, env, { cwd = process.cwd() } = {}) {
+  if (hookValue === false) return { skipped: false, exitCode: null };
+  if (hookValue === true || hookValue === undefined) return { skipped: true, exitCode: null };
+
+  const commands = Array.isArray(hookValue) ? hookValue : [hookValue];
+  const mergedEnv = { ...process.env, ...env };
+
+  for (const cmd of commands) {
+    const exitCode = await spawnShell(cmd, mergedEnv, cwd);
+    if (exitCode !== 0) {
+      return { skipped: false, exitCode };
+    }
+  }
+  return { skipped: false, exitCode: 0 };
+}
+
+/**
+ * Spawn a shell command and wait for it to exit.
+ * Uses /bin/sh -c on Unix, cmd.exe /c on Windows.
+ * Inherits stdio so output streams directly to terminal.
+ *
+ * @param {string} cmd
+ * @param {object} env
+ * @param {string} cwd
+ * @returns {Promise<number>} exit code
+ */
+function spawnShell(cmd, env, cwd) {
+  return new Promise((resolve) => {
+    const isWin = process.platform === 'win32';
+    const shell = isWin ? 'cmd.exe' : '/bin/sh';
+    const args = isWin ? ['/c', cmd] : ['-c', cmd];
+    const proc = spawn(shell, args, { env, cwd, stdio: 'inherit' });
+    proc.on('close', (code) => resolve(code ?? 1));
+    proc.on('error', () => resolve(1));
+  });
+}
+
+/**
+ * Build env vars to inject into hook processes for a given target file.
+ *
+ * @param {string} filePath   - Relative file path from project root
+ * @param {string} entityType - Entity type string
+ * @param {object} appConfig  - From loadAppConfig(): { domain, AppShortName, AppUID }
+ * @returns {object} env vars
+ */
+export function buildHookEnv(filePath, entityType, appConfig) {
+  return {
+    DBO_TARGET: filePath,
+    DBO_ENTITY: entityType,
+    DBO_DOMAIN: appConfig?.domain || '',
+    DBO_APP: appConfig?.AppShortName || '',
+    DBO_APP_UID: appConfig?.AppUID || '',
+  };
+}
+
+/**
+ * Run the full build lifecycle for a target: prebuild → build → postbuild.
+ * Returns false if any hook fails (non-zero exit), true if all succeed or are skipped.
+ *
+ * @param {object} hooks      - Resolved hooks from resolveHooks()
+ * @param {object} env        - Env vars from buildHookEnv()
+ * @param {string} [cwd]      - Working directory
+ * @returns {Promise<boolean>} true = success/skipped, false = failure
+ */
+export async function runBuildLifecycle(hooks, env, cwd) {
+  for (const name of ['prebuild', 'build', 'postbuild']) {
+    if (!(name in hooks)) continue;
+    const result = await runHook(hooks[name], env, { cwd });
+    if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Run the push lifecycle for a target: prepush → (push or default) → postpush.
+ * Returns:
+ *   { runDefault: true }  — caller should run the default push
+ *   { runDefault: false } — push was handled by custom hook or push: false
+ *   { failed: true }      — a hook failed; abort
+ *
+ * @param {object} hooks      - Resolved hooks
+ * @param {object} env        - Env vars
+ * @param {string} [cwd]      - Working directory
+ */
+export async function runPushLifecycle(hooks, env, cwd) {
+  // prepush
+  if ('prepush' in hooks) {
+    const result = await runHook(hooks['prepush'], env, { cwd });
+    if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+      return { failed: true };
+    }
+  }
+
+  // push
+  let runDefault = true;
+  if ('push' in hooks) {
+    const pushVal = hooks['push'];
+    if (pushVal === false) {
+      runDefault = false;
+    } else if (pushVal !== true && pushVal !== undefined) {
+      // Custom push command overrides default HTTP submit
+      const result = await runHook(pushVal, env, { cwd });
+      if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+        return { failed: true };
+      }
+      runDefault = false;
+    }
+    // push: true or undefined → keep runDefault = true
+  }
+
+  // postpush (runs regardless of whether push was default or custom)
+  if ('postpush' in hooks) {
+    const result = await runHook(hooks['postpush'], env, { cwd });
+    if (!result.skipped && result.exitCode !== 0 && result.exitCode !== null) {
+      return { failed: true };
+    }
+  }
+
+  return { runDefault, failed: false };
+}

package/src/migrations/006-remove-uid-companion-filenames.js

@@ -0,0 +1,181 @@
+import { readdir, readFile, writeFile, rename, access, mkdir } from 'fs/promises';
+import { join, extname, basename, dirname } from 'path';
+import { log } from '../lib/logger.js';
+import { stripUidFromFilename, hasUidInFilename } from '../lib/filenames.js';
+import { ensureTrashIcon } from '../lib/folder-icon.js';
+
+export const description = 'Rename legacy ~UID companion files to natural filenames';
+
+/**
+ * Migration 006 — Rename companion files from name~uid.ext to name.ext.
+ *
+ * Handles two cases:
+ *   A) @reference itself contains ~UID (e.g. "@colors~uid.css") — strip ~UID
+ *      from both the filename on disk AND the @reference in metadata.
+ *   B) @reference is already natural but file on disk has ~UID — just rename file.
+ *
+ * Metadata files retain their ~UID naming.
+ */
+export default async function run(_options) {
+  const cwd = process.cwd();
+  let totalRenamed = 0;
+  let totalRefsUpdated = 0;
+
+  const metaFiles = await findAllMetadataFiles(cwd);
+
+  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);
+
+        // Case A: @reference itself contains ~UID — strip it
+        if (hasUidInFilename(refName, uid)) {
+          const naturalName = stripUidFromFilename(refName, uid);
+          const legacyPath = join(metaDir, refName);
+          const naturalPath = join(metaDir, naturalName);
+
+          // Rename or trash legacy file
+          let naturalExists = false;
+          let legacyExists = false;
+          try { await access(naturalPath); naturalExists = true; } catch { /* missing */ }
+          try { await access(legacyPath); legacyExists = true; } catch { /* missing */ }
+
+          if (legacyExists && !naturalExists) {
+            try {
+              await rename(legacyPath, naturalPath);
+              log.dim(`  ${refName} → ${naturalName}`);
+              totalRenamed++;
+            } catch { /* rename failed */ }
+          } else if (legacyExists && naturalExists) {
+            // Both exist — move orphan to trash
+            try {
+              const trashDir = join(process.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 */ }
+          }
+
+          // Update @reference
+          meta[col] = `@${naturalName}`;
+          metaChanged = true;
+          continue;
+        }
+
+        // Case B: @reference is natural but file on disk might have ~UID
+        const naturalPath = join(metaDir, refName);
+        try { await access(naturalPath); continue; } catch { /* missing */ }
+
+        const ext = extname(refName);
+        const base = basename(refName, ext);
+        const legacyName = ext ? `${base}~${uid}${ext}` : `${base}~${uid}`;
+        const legacyPath = join(metaDir, legacyName);
+
+        try {
+          await access(legacyPath);
+          await rename(legacyPath, naturalPath);
+          log.dim(`  ${legacyName} → ${refName}`);
+          totalRenamed++;
+        } catch { /* legacy not present — skip */ }
+      }
+
+      // 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 */ }
+  }
+
+  // Pass 2: Trash orphaned ~UID companion files not referenced by any metadata
+  const referencedFiles = new Set();
+  const tildeFiles = [];
+
+  for (const metaPath of metaFiles) {
+    try {
+      const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+      const metaDir = dirname(metaPath);
+      const cols = [...(meta._contentColumns || [])];
+      if (meta._mediaFile) cols.push('_mediaFile');
+      for (const col of cols) {
+        const ref = meta[col];
+        if (ref && String(ref).startsWith('@')) {
+          const refName = String(ref).substring(1);
+          referencedFiles.add(refName.startsWith('/') ? join(cwd, refName) : join(metaDir, refName));
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  // Scan for ~ files not referenced
+  async function scanForTildeFiles(dir) {
+    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 scanForTildeFiles(full); continue; }
+      if (!entry.name.endsWith('.metadata.json') && entry.name.includes('~')) {
+        tildeFiles.push(full);
+      }
+    }
+  }
+  await scanForTildeFiles(cwd);
+
+  const orphans = tildeFiles.filter(f => !referencedFiles.has(f));
+  if (orphans.length > 0) {
+    const trashDir = join(cwd, 'trash');
+    await mkdir(trashDir, { recursive: true });
+    let trashed = 0;
+    for (const orphan of orphans) {
+      try {
+        await rename(orphan, join(trashDir, basename(orphan)));
+        trashed++;
+      } catch { /* non-critical */ }
+    }
+    if (trashed > 0) {
+      await ensureTrashIcon(trashDir);
+      totalRenamed += trashed;
+      log.dim(`  Trashed ${trashed} orphaned legacy ~UID file(s)`);
+    }
+  }
+
+  if (totalRenamed > 0 || totalRefsUpdated > 0) {
+    log.dim(`  Renamed ${totalRenamed} companion file(s), updated ${totalRefsUpdated} metadata @reference(s)`);
+  }
+}
+
+const SKIP = new Set(['.dbo', 'node_modules', 'trash', '.git', '.claude']);
+
+async function findAllMetadataFiles(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 findAllMetadataFiles(full));
+      } else if (entry.name.endsWith('.metadata.json')) {
+        results.push(full);
+      }
+    }
+  } catch { /* skip unreadable dirs */ }
+  return results;
+}