@dboio/cli 0.13.2 → 0.15.1

package/src/lib/deploy-config.js

@@ -0,0 +1,137 @@
+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';
+
+function deployConfigPath() {
+  return join(process.cwd(), DEPLOY_CONFIG_FILE);
+}
+
+function sortedKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+/**
+ * Load .dbo/deploy_config.json. Returns { deployments: {} } if missing.
+ * Throws on malformed JSON (do not silently recreate — would lose existing entries).
+ */
+export async function loadDeployConfig() {
+  try {
+    const raw = await readFile(deployConfigPath(), 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { deployments: {} };
+    throw new Error(`Failed to parse ${DEPLOY_CONFIG_FILE}: ${err.message}`);
+  }
+}
+
+/**
+ * Write .dbo/deploy_config.json with alphabetically sorted deployment keys.
+ */
+export async function saveDeployConfig(config) {
+  await mkdir(join(process.cwd(), '.dbo'), { recursive: true });
+  const sorted = { ...config, deployments: sortedKeys(config.deployments || {}) };
+  await writeFile(deployConfigPath(), JSON.stringify(sorted, null, 2) + '\n');
+}
+
+/**
+ * Derive the <ext>:<basename> deploy key from a relative file path.
+ * Finds the shortest key not already occupied in existingDeployments.
+ *
+ * @param {string} relPath             - e.g. "lib/bins/app/assets/css/colors.css"
+ * @param {Object} existingDeployments - current deployments object (to avoid collisions)
+ * @returns {string}                   - e.g. "css:colors"
+ */
+export function buildDeployKey(relPath, existingDeployments = {}) {
+  const normalized = relPath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const filename = parts[parts.length - 1];
+  const ext = extname(filename).slice(1).toLowerCase();   // '' if no dot
+  const base = ext ? basename(filename, `.${ext}`) : filename;
+  const prefix = ext || 'file';
+
+  // Try simplest key first, then progressively add parent segments for disambiguation
+  const dirParts = parts.slice(0, -1);
+  const candidates = [`${prefix}:${base}`];
+  for (let depth = 1; depth <= dirParts.length; depth++) {
+    const suffix = dirParts.slice(-depth).join('/');
+    candidates.push(`${prefix}:${suffix}/${base}`);
+  }
+  candidates.push(`${prefix}:${normalized}`);   // absolute fallback
+
+  for (const key of candidates) {
+    if (!existingDeployments[key]) return key;
+  }
+  return `${prefix}:${normalized}`;  // always unique
+}
+
+/**
+ * Insert or update a deploy config entry for a companion file.
+ *
+ * Behaviour:
+ *  - If an entry with the same UID already exists → update file, entity, column in place
+ *    (keeps the existing key, avoids duplicate keys on re-clone)
+ *  - If a new key collision exists with a DIFFERENT UID → log a warning, skip
+ *  - Otherwise → create new entry with the shortest unique key
+ *
+ * @param {string} companionPath - Absolute path to the companion file
+ * @param {string} uid           - Record UID (from metadata)
+ * @param {string} entity        - Entity type (e.g. 'content', 'extension', 'media')
+ * @param {string} [column]      - Column name (e.g. 'Content', 'CSS')
+ */
+export async function upsertDeployEntry(companionPath, uid, entity, column) {
+  if (!uid || !companionPath) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+
+  const relPath = relative(process.cwd(), companionPath).replace(/\\/g, '/');
+
+  // Find if this UID is already tracked under any key
+  const existingKey = Object.keys(deployments).find(k => deployments[k].uid === uid);
+
+  if (existingKey) {
+    // Update path + metadata in place — keeps existing key, avoids duplicates on re-clone
+    deployments[existingKey] = {
+      ...deployments[existingKey],
+      file: relPath,
+      entity,
+      ...(column ? { column } : {}),
+    };
+    config.deployments = sortedKeys(deployments);
+    await saveDeployConfig(config);
+    return;
+  }
+
+  // New entry — build unique key avoiding all occupied keys
+  const key = buildDeployKey(relPath, deployments);
+
+  if (deployments[key]) {
+    // buildDeployKey returned an occupied key (should not happen — means all path segments collide)
+    log.warn(`Deploy config: skipping auto-registration of "${relPath}" — key "${key}" already exists for a different record. Add manually to ${DEPLOY_CONFIG_FILE}.`);
+    return;
+  }
+
+  const entry = { uid, file: relPath, entity };
+  if (column) entry.column = column;
+  deployments[key] = entry;
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}
+
+/**
+ * Remove the deploy config entry matching a given UID.
+ * No-op if no entry with that UID exists.
+ *
+ * @param {string} uid - Record UID to remove
+ */
+export async function removeDeployEntry(uid) {
+  if (!uid) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+  const key = Object.keys(deployments).find(k => deployments[k].uid === uid);
+  if (!key) return;
+  delete deployments[key];
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}

package/src/lib/diff.js

@@ -5,6 +5,7 @@ import { loadIgnore } from './ignore.js';
 import { parseServerDate, setFileTimestamps } from './timestamps.js';
 import { loadConfig, loadUserInfo, loadAppJsonBaseline } from './config.js';
 import { findBaselineEntry } from './delta.js';
+import { isMetadataFile, parseMetaFilename } from './filenames.js';
 import { log } from './logger.js';
 
 // ─── Baseline Cache ─────────────────────────────────────────────────────────
@@ -155,10 +156,10 @@ export async function findMetadataFiles(dir, ig) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
       results.push(...await findMetadataFiles(fullPath, ig));
-    } else if (entry.name.endsWith('.metadata.json') && !entry.name.startsWith('__WILL_DELETE__')) {
+    } else if (isMetadataFile(entry.name) && !entry.name.startsWith('__WILL_DELETE__')) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (!ig.ignores(relPath)) results.push(fullPath);
-    } else if (entry.name.endsWith('.json') && !entry.name.endsWith('.metadata.json') && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
+    } else if (entry.name.endsWith('.json') && !isMetadataFile(entry.name) && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
       // Output hierarchy root files: Name~UID.json (or legacy _output~Name~UID.json)
       // Exclude old-format child output files — they contain a dot-prefixed
       // child-type segment (.column~, .join~, .filter~) before .json.
@@ -495,7 +496,7 @@ export async function compareRecord(metaPath, config, serverRecordsMap) {
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];
 
@@ -799,7 +800,7 @@ export async function inlineDiffAndMerge(serverRow, metaPath, config, options =
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];
 

package/src/lib/filenames.js

@@ -1,6 +1,7 @@
 /**
- * Filename convention helpers for the UID tilde convention.
- * All entity files use <basename>~<uid>.<ext> as the local filename.
+ * Filename convention helpers for the metadata~uid convention.
+ * Metadata files: name.metadata~uid.json
+ * Companion files: natural names, no UID embedded.
  */
 
 import { rename, unlink, writeFile, readFile, readdir } from 'fs/promises';
@@ -117,6 +118,68 @@ export function detectLegacyDotUid(filename) {
   return match ? { name: match[1], uid: match[2] } : null;
 }
 
+/**
+ * Build the new-convention metadata filename.
+ * Format: <naturalBase>.metadata~<uid>.json
+ *
+ * For content records: naturalBase = "colors" → "colors.metadata~abc123.json"
+ * For media records:   naturalBase = "logo.png" → "logo.png.metadata~abc123.json"
+ * For output records:  naturalBase = "Sales" → "Sales.metadata~abc123.json"
+ *
+ * @param {string} naturalBase - Name without any ~uid (may include media extension)
+ * @param {string} uid         - Server-assigned UID
+ * @returns {string}
+ */
+export function buildMetaFilename(naturalBase, uid) {
+  return `${naturalBase}.metadata~${uid}.json`;
+}
+
+/**
+ * Test whether a filename is a metadata file (new or legacy format).
+ *
+ * New format:    name.metadata~uid.json
+ * Legacy format: name~uid.metadata.json  (also accepted during migration)
+ *
+ * @param {string} filename
+ * @returns {boolean}
+ */
+export function isMetadataFile(filename) {
+  return /\.metadata~[a-z0-9]+\.json$/i.test(filename)   // new: name.metadata~uid.json
+    || filename.endsWith('.metadata.json')                 // legacy + pre-UID temp files
+    || /\.[a-z0-9]{10,}\.metadata\.json$/i.test(filename); // legacy dot-separated: name.uid.metadata.json
+}
+
+/**
+ * Parse a new-format metadata filename into its components.
+ * Returns null for legacy-format filenames (use detectLegacyTildeMetadata for those).
+ *
+ * @param {string} filename - e.g. "colors.metadata~abc123.json"
+ * @returns {{ naturalBase: string, uid: string } | null}
+ */
+export function parseMetaFilename(filename) {
+  const m = filename.match(/^(.+)\.metadata~([a-z0-9]+)\.json$/i);
+  return m ? { naturalBase: m[1], uid: m[2] } : null;
+}
+
+/**
+ * Detect whether a filename uses the legacy tilde convention:
+ *   <name>~<uid>.metadata.json  OR  <name>~<uid>.<ext>.metadata.json
+ * where uid is ≥10 lowercase alphanumeric characters.
+ *
+ * Returns { naturalBase, uid } or null.
+ */
+export function detectLegacyTildeMetadata(filename) {
+  // Case 1: name~uid.metadata.json (content/entity metadata)
+  const m1 = filename.match(/^(.+)~([a-z0-9]{10,})\.metadata\.json$/);
+  if (m1) return { naturalBase: m1[1], uid: m1[2] };
+
+  // Case 2: name~uid.ext.metadata.json (media metadata)
+  const m2 = filename.match(/^(.+)~([a-z0-9]{10,})\.([a-z0-9]+)\.metadata\.json$/);
+  if (m2) return { naturalBase: `${m2[1]}.${m2[3]}`, uid: m2[2] };
+
+  return null;
+}
+
 /**
  * Find the metadata file that references a given companion file via @reference.
  *
@@ -133,19 +196,20 @@ export async function findMetadataForCompanion(companionPath) {
   const ext = extname(companionName);
   const base = basename(companionName, ext);
 
-  // 1. Direct match: base.metadata.json
-  const directMeta = join(dir, `${base}.metadata.json`);
-  try {
-    await readFile(directMeta, 'utf8');
-    return directMeta;
-  } catch { /* not found */ }
-
-  // 2. Scan sibling *.metadata.json files for @reference match
   let entries;
   try { entries = await readdir(dir); } catch { return null; }
 
+  // 1. Fast path: match naturalBase of new-format metadata files
+  for (const entry of entries) {
+    const parsed = parseMetaFilename(entry);
+    if (parsed && (parsed.naturalBase === base || parsed.naturalBase === companionName)) {
+      return join(dir, entry);
+    }
+  }
+
+  // 2. Scan all metadata files (new + legacy) for @reference match
   for (const entry of entries) {
-    if (!entry.endsWith('.metadata.json')) continue;
+    if (!isMetadataFile(entry)) continue;
     const metaPath = join(dir, entry);
     try {
       const meta = JSON.parse(await readFile(metaPath, 'utf8'));
@@ -155,7 +219,6 @@ export async function findMetadataForCompanion(companionPath) {
         const ref = meta[col];
         if (!ref || !String(ref).startsWith('@')) continue;
         const refName = String(ref).substring(1);
-        // Match both relative and root-relative (@/) references
         if (refName === companionName || refName === `/${companionName}`) {
           return metaPath;
         }
@@ -180,25 +243,27 @@ export async function findMetadataForCompanion(companionPath) {
  */
 export async function renameToUidConvention(meta, metaPath, uid, lastUpdated, serverTz) {
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json'); // e.g. "colors" or "logo.png"
+  const metaFilename = basename(metaPath);
 
-  if (hasUidInFilename(metaBase, uid)) {
+  // Already in new format — nothing to do
+  if (parseMetaFilename(metaFilename)?.uid === uid) {
     return { newMetaPath: metaPath, newFilePath: null, updatedMeta: meta };
   }
 
-  // Compute new metadata filename with ~UID
-  // For media files: metaBase = "logo.png", newBase = "logo~uid.png"
-  // For content files: metaBase = "colors", newBase = "colors~uid"
-  const metaBaseExt = extname(metaBase); // ".png" for media metadata, "" for content metadata
-  let newMetaBase;
-  if (metaBaseExt) {
-    const nameWithoutExt = metaBase.slice(0, -metaBaseExt.length);
-    newMetaBase = `${buildUidFilename(nameWithoutExt, uid)}${metaBaseExt}`;
+  // Determine naturalBase from the temp/old metadata filename
+  // Temp format from add.js: "colors.metadata.json" → naturalBase = "colors"
+  // Old tilde format: "colors~uid.metadata.json" → naturalBase = "colors"
+  let naturalBase;
+  const legacyParsed = detectLegacyTildeMetadata(metaFilename);
+  if (legacyParsed) {
+    naturalBase = legacyParsed.naturalBase;
+  } else if (metaFilename.endsWith('.metadata.json')) {
+    naturalBase = metaFilename.slice(0, -'.metadata.json'.length);
   } else {
-    newMetaBase = buildUidFilename(metaBase, uid);
+    naturalBase = basename(metaFilename, '.json');
   }
 
-  const newMetaPath = join(metaDir, `${newMetaBase}.metadata.json`);
+  const newMetaPath = join(metaDir, buildMetaFilename(naturalBase, uid));
 
   // Update only the UID field; @reference values are UNCHANGED (companions keep natural names)
   const updatedMeta = { ...meta, UID: uid };

package/src/lib/scaffold.js

@@ -2,7 +2,7 @@ import { mkdir, stat, readFile, writeFile, access } from 'fs/promises';
 import { join } from 'path';
 import { SCAFFOLD_DIRS } from './structure.js';
 import { log } from './logger.js';
-import { applyTrashIcon } from './folder-icon.js';
+import { applyTrashIcon } from './tagging.js';
 
 /**
  * Scaffold the standard DBO project directory structure in cwd.