@dboio/cli 0.16.2 → 0.19.0

package/src/lib/delta.js

@@ -45,19 +45,16 @@ export function findBaselineEntry(baseline, entity, uid) {
     if (found) return found;
   }
 
-  // For output hierarchy entities (output_value, output_value_filter,
-  // output_value_entity_column_rel), also search nested inside each
-  // output record's .children — server nests them per-output.
-  if (entity !== 'output') {
-    const outputs = baseline.children.output;
-    if (Array.isArray(outputs)) {
-      for (const o of outputs) {
-        if (!o.children) continue;
-        const nested = o.children[entity];
-        if (Array.isArray(nested)) {
-          const found = nested.find(item => item.UID === uid);
-          if (found) return found;
-        }
+  // Search nested inside parent records' .children — server nests children
+  // per-parent (e.g. output→output_value, entity→entity_column).
+  for (const [parentEntity, parentArray] of Object.entries(baseline.children)) {
+    if (!Array.isArray(parentArray)) continue;
+    for (const parent of parentArray) {
+      if (!parent.children) continue;
+      const nested = parent.children[entity];
+      if (Array.isArray(nested)) {
+        const found = nested.find(item => item.UID === uid);
+        if (found) return found;
       }
     }
   }
@@ -274,7 +271,7 @@ export function normalizeValue(value) {
 
 // ─── Compound Output Delta Detection ────────────────────────────────────────
 
-const _OUTPUT_DOC_KEYS = ['column', 'join', 'filter'];
+const _OUTPUT_CHILD_KEYS = ['output_value', 'output_value_filter', 'output_value_entity_column_rel'];
 
 /**
  * Detect changed columns across a compound output file (root + inline children).
@@ -344,10 +341,10 @@ const BIN_TRACKED_COLUMNS = ['Name', 'Path', 'ParentBinID', 'Active', 'Public'];
 
 /**
  * Detect changes between a current bin entry (from structure.json) and the
- * baseline (from app.json children.bin array).
+ * baseline (from baseline children.bin array).
  *
  * @param {Object} binEntry - Current bin entry from structure.json (with binId, name, path, etc.)
- * @param {Object} baseline - The baseline JSON (app.json)
+ * @param {Object} baseline - The baseline JSON
  * @returns {string[]} - Array of changed column names
  */
 export function detectBinChanges(binEntry, baseline) {
@@ -411,7 +408,7 @@ export function synthesizeBinMetadata(binEntry, appId) {
 }
 
 async function _walkChildrenForChanges(childrenObj, baseline, metaDir, result) {
-  for (const docKey of _OUTPUT_DOC_KEYS) {
+  for (const docKey of _OUTPUT_CHILD_KEYS) {
     const entityArray = childrenObj[docKey];
     if (!Array.isArray(entityArray) || entityArray.length === 0) continue;
     for (const child of entityArray) {
@@ -424,3 +421,108 @@ async function _walkChildrenForChanges(childrenObj, baseline, metaDir, result) {
     }
   }
 }
+
+// ─── Generic Entity Children Delta Detection ─────────────────────────────────
+
+/**
+ * Detect changed, added, and removed child records in a metadata file with `children`.
+ * Applies to entity dir metadata (e.g. entity→entity_column, extension→...).
+ * Does NOT apply to output hierarchy — use detectOutputChanges() for those.
+ *
+ * @param {string} metaPath - Path to the parent metadata file
+ * @param {Object} baseline - Loaded baseline JSON
+ * @returns {Promise<Object>} - { [childUID]: { childEntity, changedColumns, isNew, isRemoved } }
+ */
+export async function detectEntityChildrenChanges(metaPath, baseline) {
+  const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+  const { children, UID: parentUid, _entity: parentEntity } = meta;
+
+  if (!children || typeof children !== 'object') return {};
+
+  const result = {};
+
+  for (const [childEntityName, childArray] of Object.entries(children)) {
+    if (!Array.isArray(childArray)) continue;
+
+    // Collect UIDs present in current metadata
+    const metaChildUIDs = new Set(childArray.map(c => c.UID).filter(Boolean));
+
+    // Find baseline children for this parent + child entity combo
+    const baselineChildren = findChildrenInBaseline(baseline, parentEntity, parentUid, childEntityName);
+    const baselineByUID = new Map(baselineChildren.map(c => [c.UID, c]));
+
+    // Detect new and edited children
+    for (const child of childArray) {
+      const uid = child.UID;
+      if (!uid) continue;
+      const baselineChild = baselineByUID.get(uid);
+      if (!baselineChild) {
+        result[uid] = { childEntity: childEntityName, changedColumns: getAllUserColumns(child), isNew: true };
+      } else {
+        const changed = _compareChildToBaseline(child, baselineChild);
+        if (changed.length > 0) {
+          result[uid] = { childEntity: childEntityName, changedColumns: changed, isNew: false };
+        }
+      }
+    }
+
+    // Detect removed children (in baseline but not in metadata)
+    for (const [uid] of baselineByUID.entries()) {
+      if (!metaChildUIDs.has(uid)) {
+        result[uid] = { childEntity: childEntityName, changedColumns: [], isRemoved: true };
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find children in the baseline for a given parent record + child entity name.
+ * Checks the parent's nested children first; falls back to top-level baseline array.
+ *
+ * @param {Object} baseline - Loaded baseline JSON
+ * @param {string} parentEntity - e.g. 'entity'
+ * @param {string} parentUid - UID of the parent record
+ * @param {string} childEntityName - e.g. 'entity_column'
+ * @returns {Array} - Array of baseline child records
+ */
+export function findChildrenInBaseline(baseline, parentEntity, parentUid, childEntityName) {
+  if (!baseline || !baseline.children) return [];
+
+  // First: try nested inside the parent entity record
+  const parentArray = baseline.children[parentEntity];
+  if (Array.isArray(parentArray)) {
+    const parentRecord = parentArray.find(p => p.UID === parentUid);
+    if (parentRecord?.children && Array.isArray(parentRecord.children[childEntityName])) {
+      return parentRecord.children[childEntityName];
+    }
+  }
+
+  // Fallback: top-level baseline array for the child entity (less common)
+  const topLevel = baseline.children[childEntityName];
+  return Array.isArray(topLevel) ? topLevel : [];
+}
+
+/**
+ * Compare a child record's fields against its baseline entry.
+ * Returns names of changed columns (excludes system columns and 'children').
+ */
+function _compareChildToBaseline(child, baselineChild) {
+  const changed = [];
+  for (const [col, val] of Object.entries(child)) {
+    if (shouldSkipColumn(col) || col === 'children') continue;
+    if (normalizeValue(val) !== normalizeValue(baselineChild[col])) {
+      changed.push(col);
+    }
+  }
+  // Columns removed from metadata but present in baseline
+  for (const [col, baselineVal] of Object.entries(baselineChild)) {
+    if (shouldSkipColumn(col) || col === 'children') continue;
+    if (col in child) continue;
+    if (baselineVal !== null && baselineVal !== undefined && normalizeValue(baselineVal) !== '') {
+      changed.push(col);
+    }
+  }
+  return changed;
+}

package/src/lib/dependencies.js

@@ -1,11 +1,11 @@
 /**
  * Dependency management for entity synchronization and app dependency cloning.
  * - Entity ordering: ensures children are processed before parents for referential integrity.
- * - App dependencies: auto-clone related apps into .dbo/dependencies/<shortname>/.
+ * - App dependencies: auto-clone related apps into app_dependencies/<shortname>/.
  */
 
 import { spawn } from 'child_process';
-import { mkdir, symlink, access, readFile, writeFile } from 'fs/promises';
+import { mkdir, symlink, access, readFile, readdir, writeFile, rm } from 'fs/promises';
 import { join, resolve, relative, sep } from 'path';
 import { fileURLToPath } from 'url';
 import { DboClient } from './client.js';
@@ -219,7 +219,7 @@ export async function checkDependencyStaleness(shortname, options = {}) {
 
   const dateStr = stored.substring(0, 10); // YYYY-MM-DD from ISO string
   const result = await client.get(
-    `/api/app/object/${encodeURIComponent(shortname)}[_LastUpdated]?UpdatedAfter=${dateStr}`
+    `/api/app/object/${encodeURIComponent(shortname)}?UpdatedAfter=${dateStr}`
   );
   if (!result.ok || !result.data) return false; // Can't determine — assume fresh
 
@@ -229,7 +229,7 @@ export async function checkDependencyStaleness(shortname, options = {}) {
 }
 
 /**
- * Sync dependency apps into .dbo/dependencies/<shortname>/.
+ * Sync dependency apps into app_dependencies/<shortname>/.
  *
  * @param {object} options
  * @param {string}   [options.domain]           - Override domain
@@ -243,7 +243,7 @@ export async function checkDependencyStaleness(shortname, options = {}) {
 export async function syncDependencies(options = {}) {
   // Recursive guard: don't run inside a checkout directory
   const cwd = process.cwd();
-  if (cwd.includes(`${sep}.dbo${sep}dependencies${sep}`)) {
+  if (cwd.includes(`${sep}app_dependencies${sep}`)) {
     log.dim('  Skipping dependency sync (inside a checkout directory)');
     return;
   }
@@ -252,8 +252,8 @@ export async function syncDependencies(options = {}) {
     ? [...new Set(['_system', ...options.only])]
     : await getDependencies();
 
-  const parentDboDir = join(cwd, '.dbo');
-  const depsRoot = join(parentDboDir, 'dependencies');
+  const parentProjectDir = join(cwd, '.app');
+  const depsRoot = join(cwd, 'app_dependencies');
 
   const forceAll = !!(options.force || options.schema);
   const execFn = options._execOverride || execDboInDir;
@@ -271,12 +271,12 @@ export async function syncDependencies(options = {}) {
     spinner.update(`Syncing dependency: ${shortname}`);
 
     const checkoutDir = join(depsRoot, shortname);
-    const checkoutDboDir = join(checkoutDir, '.dbo');
+    const checkoutProjectDir = join(checkoutDir, '.app');
 
     try {
       // 1. Create checkout dir + minimal config
-      await mkdir(checkoutDboDir, { recursive: true });
-      const minConfigPath = join(checkoutDboDir, 'config.json');
+      await mkdir(checkoutProjectDir, { recursive: true });
+      const minConfigPath = join(checkoutProjectDir, 'config.json');
       let configExists = false;
       try { await access(minConfigPath); configExists = true; } catch {}
       if (!configExists) {
@@ -286,20 +286,31 @@ export async function syncDependencies(options = {}) {
       }
 
       // 2. Symlink credentials
-      await symlinkCredentials(parentDboDir, checkoutDboDir);
+      await symlinkCredentials(parentProjectDir, checkoutProjectDir);
 
       // 3. Staleness check (unless --force or --schema)
       if (!forceAll) {
-        let isStale = true;
+        // Also check if the checkout is essentially empty (only .app/ exists) —
+        // a previous clone may have failed or been cleaned up, leaving just config
+        let checkoutEmpty = true;
         try {
-          isStale = await checkDependencyStaleness(shortname, options);
-        } catch {
-          // Network unavailable — assume stale to attempt clone
-        }
-        if (!isStale) {
-          skipped.push(shortname);
-          continue;
+          const entries = await readdir(checkoutDir);
+          checkoutEmpty = entries.every(e => e === '.app' || e.startsWith('.'));
+        } catch { /* dir doesn't exist yet — treat as empty */ }
+
+        if (!checkoutEmpty) {
+          let isStale = true;
+          try {
+            isStale = await checkDependencyStaleness(shortname, options);
+          } catch {
+            // Network unavailable — assume stale to attempt clone
+          }
+          if (!isStale) {
+            skipped.push(shortname);
+            continue;
+          }
         }
+        // If checkout is empty, always re-clone regardless of timestamp
       }
 
       // 4. Run the clone (quiet — suppress child process output)
@@ -310,18 +321,34 @@ export async function syncDependencies(options = {}) {
         await execFn(checkoutDir, ['clone', '--app', shortname, '--force', '--yes', '--no-deps'], { quiet: true });
       }
 
-      // 5. Read _LastUpdated from checkout's app.json and persist
+      // 5. Read _LastUpdated from checkout's .app/<shortname>.metadata.json and persist
       try {
-        const appJsonPath = join(checkoutDir, 'app.json');
-        const appJson = JSON.parse(await readFile(appJsonPath, 'utf8'));
-        const ts = appJson._LastUpdated || appJson.LastUpdated || null;
+        const metaFile = join(checkoutDir, '.app', `${shortname}.metadata.json`);
+        const appMeta = JSON.parse(await readFile(metaFile, 'utf8'));
+        const ts = appMeta._LastUpdated || appMeta.LastUpdated || null;
         if (ts) await setDependencyLastUpdated(shortname, ts);
       } catch { /* can't read _LastUpdated — that's OK */ }
 
+      // 6. Clean up legacy and unnecessary files from dependency checkouts.
+      //    - Legacy .dbo/ layout from pre-restructure clones
+      //    - Root app.json/schema.json (now inside .app/)
+      //    - package.json, manifest.json, .gitignore (not needed for deps)
+      //    - src/, test/, trash/ (deps are not development projects)
+      try {
+        const legacyDbo = join(checkoutDir, '.dbo');
+        try { await access(legacyDbo); await rm(legacyDbo, { recursive: true }); } catch {}
+        for (const f of ['app.json', 'schema.json', 'package.json', 'manifest.json', '.gitignore']) {
+          try { await access(join(checkoutDir, f)); await rm(join(checkoutDir, f)); } catch {}
+        }
+        for (const d of ['src', 'test', 'trash']) {
+          try { await access(join(checkoutDir, d)); await rm(join(checkoutDir, d), { recursive: true }); } catch {}
+        }
+      } catch { /* ignore cleanup errors */ }
+
       synced.push(shortname);
     } catch (err) {
       failed.push(shortname);
-      if (options.verbose) log.warn(`  Dependency "${shortname}" failed: ${err.message}`);
+      log.warn(`  Dependency "${shortname}" failed: ${err.message}`);
     }
   }
 

package/src/lib/deploy-config.js

@@ -2,7 +2,7 @@ import { readFile, writeFile, mkdir } from 'fs/promises';
 import { join, relative, extname, basename } from 'path';
 import { log } from './logger.js';
 
-const DEPLOY_CONFIG_FILE = '.dbo/deploy_config.json';
+const DEPLOY_CONFIG_FILE = '.app/deploy_config.json';
 
 function deployConfigPath() {
   return join(process.cwd(), DEPLOY_CONFIG_FILE);
@@ -13,7 +13,7 @@ function sortedKeys(obj) {
 }
 
 /**
- * Load .dbo/deploy_config.json. Returns { deployments: {} } if missing.
+ * Load .app/deploy_config.json. Returns { deployments: {} } if missing.
  * Throws on malformed JSON (do not silently recreate — would lose existing entries).
  */
 export async function loadDeployConfig() {
@@ -27,10 +27,10 @@ export async function loadDeployConfig() {
 }
 
 /**
- * Write .dbo/deploy_config.json with alphabetically sorted deployment keys.
+ * Write .app/deploy_config.json with alphabetically sorted deployment keys.
  */
 export async function saveDeployConfig(config) {
-  await mkdir(join(process.cwd(), '.dbo'), { recursive: true });
+  await mkdir(join(process.cwd(), '.app'), { recursive: true });
   const sorted = { ...config, deployments: sortedKeys(config.deployments || {}) };
   await writeFile(deployConfigPath(), JSON.stringify(sorted, null, 2) + '\n');
 }

package/src/lib/domain-guard.js

@@ -1,24 +1,23 @@
 import { readFile, writeFile, stat, utimes } from 'fs/promises';
 import { join } from 'path';
-import { loadConfig, loadTransactionKeyPreset } from './config.js';
+import { loadConfig, loadTransactionKeyPreset, appMetadataPath } from './config.js';
 import { log } from './logger.js';
 
-const appJsonPath = () => join(process.cwd(), 'app.json');
-
-/** Read _domain from app.json. Returns null if file missing or field absent. */
+/** Read _domain from the metadata file. Returns null if file missing or field absent. */
 export async function readAppJsonDomain() {
   try {
-    const obj = JSON.parse(await readFile(appJsonPath(), 'utf8'));
+    const path = await appMetadataPath();
+    const obj = JSON.parse(await readFile(path, 'utf8'));
     return obj._domain || null;
   } catch { return null; }
 }
 
 /**
- * Write _domain to app.json, preserving mtime so git doesn't see a spurious change.
- * No-op if app.json does not exist.
+ * Write _domain to the metadata file, preserving mtime so git doesn't see a spurious change.
+ * No-op if the metadata file does not exist.
  */
 export async function writeAppJsonDomain(domain) {
-  const path = appJsonPath();
+  const path = await appMetadataPath();
   let originalStat;
   try { originalStat = await stat(path); } catch { return; }
   const obj = JSON.parse(await readFile(path, 'utf8'));
@@ -29,7 +28,7 @@ export async function writeAppJsonDomain(domain) {
 
 /**
  * Check whether newDomain differs from the project reference domain.
- * Reference = app.json._domain (authoritative) → fallback: config.json.domain.
+ * Reference = metadata._domain (authoritative) → fallback: config.json.domain.
  * If reference is absent entirely, returns { changed: false } (no warning).
  *
  * Returns { changed: false } or { changed: true, proceed: bool }.

package/src/lib/filenames.js

@@ -131,7 +131,18 @@ export function detectLegacyDotUid(filename) {
  * @returns {string}
  */
 export function buildMetaFilename(naturalBase, uid) {
-  return `${naturalBase}.metadata~${uid}.json`;
+  // Guard: strip any trailing .metadata suffix(es) and ~uid fragments from naturalBase
+  // to prevent double-metadata filenames (e.g., "app.metadata.metadata~app.json")
+  let base = naturalBase;
+  const metaParsed = parseMetaFilename(base + '.json');
+  if (metaParsed) {
+    base = metaParsed.naturalBase;
+  }
+  // Strip all trailing .metadata (handles single, double, triple, etc.)
+  while (base.endsWith('.metadata')) {
+    base = base.substring(0, base.length - 9);
+  }
+  return `${base}.metadata~${uid}.json`;
 }
 
 /**
@@ -251,7 +262,7 @@ export async function renameToUidConvention(meta, metaPath, uid, lastUpdated, se
   }
 
   // Determine naturalBase from the temp/old metadata filename
-  // Temp format from add.js: "colors.metadata.json" → naturalBase = "colors"
+  // Temp format from adopt.js: "colors.metadata.json" → naturalBase = "colors"
   // Old tilde format: "colors~uid.metadata.json" → naturalBase = "colors"
   let naturalBase;
   const legacyParsed = detectLegacyTildeMetadata(metaFilename);

package/src/lib/ignore.js

@@ -12,11 +12,10 @@ const DEFAULT_FILE_CONTENT = `# DBO CLI ignore patterns
 # (gitignore-style syntax — works like .gitignore)
 
 # DBO internal
-.dbo/
+.app/
 .dboignore
 *.dboio.json
-app.json
-.dbo/dependencies/
+app_dependencies/
 
 # Editor / IDE / OS
 .DS_Store