@dboio/cli 0.6.6 → 0.6.8

package/src/commands/push.js

@@ -7,6 +7,7 @@ import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
 import { loadConfig, loadSynchronize, saveSynchronize, loadAppJsonBaseline, saveAppJsonBaseline, hasBaseline } from '../lib/config.js';
+import { checkStoredTicket, applyStoredTicketToSubmission, clearRecordTicket, clearGlobalTicket } from '../lib/ticketing.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
 import { findMetadataFiles } from '../lib/diff.js';
 import { detectChangedColumns, findBaselineEntry } from '../lib/delta.js';
@@ -68,9 +69,15 @@ async function processPendingDeletes(client, options) {
       const result = await client.postUrlEncoded('/api/input/submit', body);
 
       // Retry with prompted params if needed
-      const retryParams = await checkSubmitErrors(result);
-      if (retryParams) {
-        Object.assign(extraParams, retryParams);
+      const retryResult = await checkSubmitErrors(result);
+      if (retryResult) {
+        if (retryResult.skipRecord || retryResult.skipAll) {
+          log.warn(`  Skipping deletion of "${entry.name}"`);
+          remaining.push(entry);
+          continue;
+        }
+        const params = retryResult.retryParams || retryResult;
+        Object.assign(extraParams, params);
         const retryBody = await buildInputBody([entry.expression], extraParams);
         const retryResult = await client.postUrlEncoded('/api/input/submit', retryBody);
         if (retryResult.successful) {
@@ -144,7 +151,6 @@ async function pushDirectory(dirPath, client, options) {
 
   // Load baseline for delta detection
   const baseline = await loadAppJsonBaseline();
-  const config = await loadConfig();
 
   if (!baseline) {
     log.warn('No .app.json baseline found — performing full push (run "dbo clone" to enable delta sync)');
@@ -198,7 +204,7 @@ async function pushDirectory(dirPath, client, options) {
     let changedColumns = null;
     if (baseline) {
       try {
-        changedColumns = await detectChangedColumns(metaPath, baseline, config);
+        changedColumns = await detectChangedColumns(metaPath, baseline);
         if (changedColumns.length === 0) {
           log.dim(`  Skipping ${basename(metaPath)} — no changes detected`);
           skipped++;
@@ -217,6 +223,19 @@ async function pushDirectory(dirPath, client, options) {
     return;
   }
 
+  // Pre-flight ticket validation (only if no --ticket flag)
+  if (!options.ticket && toPush.length > 0) {
+    const ticketCheck = await checkStoredTicket(options);
+    if (ticketCheck.cancel) {
+      log.info('Submission cancelled');
+      return;
+    }
+    if (ticketCheck.clearTicket) {
+      await clearGlobalTicket();
+      log.dim('  Cleared stored ticket');
+    }
+  }
+
   // Group by entity and apply dependency ordering
   const byEntity = {};
   for (const item of toPush) {
@@ -240,6 +259,10 @@ async function pushDirectory(dirPath, client, options) {
         failed++;
       }
     } catch (err) {
+      if (err.message === 'SKIP_ALL') {
+        log.info('Skipping remaining records');
+        break;
+      }
       log.error(`Failed: ${item.metaPath} — ${err.message}`);
       failed++;
     }
@@ -321,16 +344,36 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
   const fieldLabel = changedColumns ? `${dataExprs.length} changed field(s)` : `${dataExprs.length} field(s)`;
   log.info(`Pushing ${basename(metaPath, '.metadata.json')} (${entity}:${uid}) — ${fieldLabel}`);
 
+  // Apply stored ticket if no --ticket flag
+  await applyStoredTicketToSubmission(dataExprs, entity, uid, uid, options);
+
   const extraParams = { '_confirm': options.confirm };
   if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
 
   let body = await buildInputBody(dataExprs, extraParams);
   let result = await client.postUrlEncoded('/api/input/submit', body);
 
-  // Retry with prompted params if needed (ticket, user)
-  const retryParams = await checkSubmitErrors(result);
-  if (retryParams) {
-    Object.assign(extraParams, retryParams);
+  // Retry with prompted params if needed (ticket, user, repo mismatch)
+  const retryResult = await checkSubmitErrors(result);
+  if (retryResult) {
+    // Handle skip actions
+    if (retryResult.skipRecord) {
+      log.warn('  Skipping record');
+      return false;
+    }
+    if (retryResult.skipAll) {
+      throw new Error('SKIP_ALL');
+    }
+
+    // Append ticket expressions
+    if (retryResult.ticketExpressions?.length > 0) {
+      dataExprs.push(...retryResult.ticketExpressions);
+    }
+
+    // Merge retry params (new-style has retryParams nested, legacy is flat)
+    const params = retryResult.retryParams || retryResult;
+    Object.assign(extraParams, params);
+
     body = await buildInputBody(dataExprs, extraParams);
     result = await client.postUrlEncoded('/api/input/submit', body);
   }
@@ -347,6 +390,9 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     return false;
   }
 
+  // Clean up per-record ticket on success
+  await clearRecordTicket(uid);
+
   // Update file timestamps from server response
   try {
     const editResults = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];

package/src/lib/config.js

@@ -286,6 +286,37 @@ export async function loadEntityContentExtractions(entityKey) {
   }
 }
 
+/**
+ * Save collision resolutions to .dbo/config.json.
+ * Maps file paths to the UID of the record the user chose to keep.
+ *
+ * @param {Object} resolutions - { "Bins/app/file.css": { keepUID: "abc", keepEntity: "content" } }
+ */
+export async function saveCollisionResolutions(resolutions) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  existing.CollisionResolutions = resolutions;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load collision resolutions from .dbo/config.json.
+ *
+ * @returns {Object} - { "Bins/app/file.css": { keepUID: "abc", keepEntity: "content" } }
+ */
+export async function loadCollisionResolutions() {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    return config.CollisionResolutions || {};
+  } catch {
+    return {};
+  }
+}
+
 /**
  * Save user profile fields (FirstName, LastName, Email) into credentials.json.
  */

package/src/lib/delta.js

@@ -84,10 +84,9 @@ export async function compareFileContent(filePath, baselineValue) {
  *
  * @param {string} metaPath - Path to metadata.json file
  * @param {Object} baseline - The baseline JSON
- * @param {Object} config - CLI config (for resolving file paths)
  * @returns {Promise<string[]>} - Array of changed column names
  */
-export async function detectChangedColumns(metaPath, baseline, config) {
+export async function detectChangedColumns(metaPath, baseline) {
   // Load current metadata
   const metaRaw = await readFile(metaPath, 'utf8');
   const metadata = JSON.parse(metaRaw);
@@ -160,27 +159,24 @@ function shouldSkipColumn(columnName) {
 }
 
 /**
- * Check if a value is a @reference object.
+ * Check if a value is a @reference (string starting with @).
  *
  * @param {*} value - Value to check
  * @returns {boolean} - True if reference
  */
 function isReference(value) {
-  return value &&
-         typeof value === 'object' &&
-         !Array.isArray(value) &&
-         value['@reference'] !== undefined;
+  return typeof value === 'string' && value.startsWith('@');
 }
 
 /**
  * Resolve a @reference path to absolute file path.
  *
- * @param {Object} reference - Reference object with @reference property
+ * @param {string} reference - Reference string starting with @ (e.g., "@file.html")
  * @param {string} baseDir - Base directory containing metadata
  * @returns {string} - Absolute file path
  */
 function resolveReferencePath(reference, baseDir) {
-  const refPath = reference['@reference'];
+  const refPath = reference.substring(1); // Strip leading @
   return join(baseDir, refPath);
 }
 

package/src/lib/input-parser.js

@@ -1,6 +1,7 @@
 import { readFile } from 'fs/promises';
 import { log } from './logger.js';
 import { loadUserInfo } from './config.js';
+import { buildTicketExpression, setGlobalTicket, setRecordTicket } from './ticketing.js';
 
 /**
  * Parse DBO input syntax and build form data.
@@ -96,24 +97,41 @@ const USER_ID_PATTERNS = [
  * resolved by prompting the user for missing parameters.
  *
  * Detects:
- * - ticket_lookup_required_error → prompts for Ticket ID
+ * - ticket_error → interactive ticket recovery (4 options)
+ * - repo_mismatch → repository mismatch recovery (6 options)
+ * - ticket_lookup_required_error → prompts for Ticket ID (legacy)
  * - LoggedInUser_UID, LoggedInUserID, CurrentUserID, UserID not found
  *   → prompts for User ID or UID (session not authenticated)
  *
- * Returns an object of extra params to add on retry, or null if no
- * recoverable errors were found.
+ * Returns an object with retry information, or null if no recoverable errors found.
+ *
+ * Return shape for ticket errors:
+ *   { retryParams, ticketExpressions, skipRecord, skipAll }
+ *
+ * Return shape for legacy/user errors (backward compatible):
+ *   { _OverrideTicketID, _OverrideUserUID, _OverrideUserID, ... }
  */
 export async function checkSubmitErrors(result) {
   const messages = result.messages || result.data?.Messages || [];
   const allText = messages.filter(m => typeof m === 'string').join(' ');
 
-  const needsTicket = allText.includes('ticket_lookup_required_error');
+  // --- Ticket error detection (new interactive handling) ---
+  const hasTicketError = allText.includes('ticket_error');
+  const hasRepoMismatch = allText.includes('repo_mismatch');
+
+  if (hasTicketError) {
+    return await handleTicketError(allText);
+  }
+
+  if (hasRepoMismatch) {
+    return await handleRepoMismatch(allText);
+  }
 
-  // Detect which user identity variant is needed
+  // --- Legacy ticket and user identity handling ---
+  const needsTicket = allText.includes('ticket_lookup_required_error');
   const matchedUserPattern = USER_ID_PATTERNS.find(p => allText.includes(p));
   const needsUser = !!matchedUserPattern;
   const needsUserUid = matchedUserPattern && matchedUserPattern.includes('UID');
-  const needsUserId = matchedUserPattern && !needsUserUid;
 
   if (!needsTicket && !needsUser) return null;
 
@@ -126,7 +144,6 @@ export async function checkSubmitErrors(result) {
     log.dim('  Your session may have expired, or you may not be logged in.');
     log.dim('  You can log in with "dbo login" to avoid this prompt in the future.');
 
-    // Check for stored user info from a previous login
     const stored = await loadUserInfo();
     const storedValue = needsUserUid ? stored.userUid : (stored.userId || stored.userUid);
     const storedLabel = needsUserUid
@@ -176,11 +193,9 @@ export async function checkSubmitErrors(result) {
 
   if (answers.ticketId) retryParams['_OverrideTicketID'] = answers.ticketId.trim();
 
-  // Resolve user identity from choice or direct input
   const userValue = answers.userValue
     || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
   if (userValue) {
-    // Use the appropriate override param based on what the server asked for
     if (needsUserUid) {
       retryParams['_OverrideUserUID'] = userValue.trim();
     } else {
@@ -191,6 +206,162 @@ export async function checkSubmitErrors(result) {
   return retryParams;
 }
 
+/**
+ * Handle ticket_error: Record update requires a Ticket ID but none was provided.
+ * Prompts the user with 4 recovery options.
+ */
+async function handleTicketError(allText) {
+  const inquirer = (await import('inquirer')).default;
+
+  // Try to extract record details from error text
+  const entityMatch = allText.match(/entity:(\w+)/);
+  const rowIdMatch = allText.match(/RowID:(\d+)/);
+  const uidMatch = allText.match(/UID:([a-zA-Z0-9]+)/);
+  const entity = entityMatch?.[1];
+  const rowId = rowIdMatch?.[1];
+  const uid = uidMatch?.[1];
+
+  log.warn('This record update requires a Ticket ID.');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'ticketAction',
+      message: 'Record update requires a Ticket ID:',
+      choices: [
+        { name: 'Apply a Ticket ID to this record and resubmit', value: 'apply_one' },
+        { name: 'Apply a Ticket ID to all updates in this transaction, and update my current Ticket ID reference', value: 'apply_all' },
+        { name: 'Skip this record update', value: 'skip_one' },
+        { name: 'Skip all updates that require a Ticket ID', value: 'skip_all' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'ticketId',
+      message: 'Enter Ticket ID:',
+      when: (a) => a.ticketAction === 'apply_one' || a.ticketAction === 'apply_all',
+      validate: v => v.trim() ? true : 'Ticket ID is required',
+    },
+  ]);
+
+  if (answers.ticketAction === 'skip_one') {
+    return { skipRecord: true };
+  }
+  if (answers.ticketAction === 'skip_all') {
+    return { skipAll: true };
+  }
+
+  const ticketId = answers.ticketId.trim();
+  const ticketExpressions = [];
+
+  if (entity && rowId) {
+    ticketExpressions.push(buildTicketExpression(entity, rowId, ticketId));
+  }
+
+  // Store ticket based on scope
+  if (answers.ticketAction === 'apply_all') {
+    await setGlobalTicket(ticketId);
+    log.dim(`  Stored ticket "${ticketId}" for all future submissions`);
+  } else if (uid) {
+    await setRecordTicket(uid, rowId, entity, ticketId);
+    log.dim(`  Stored ticket "${ticketId}" for record ${uid}`);
+  }
+
+  return {
+    retryParams: { '_OverrideTicketID': ticketId },
+    ticketExpressions,
+  };
+}
+
+/**
+ * Handle repo_mismatch: The provided Ticket ID belongs to a different repository.
+ * Prompts the user with 6 recovery options.
+ */
+async function handleRepoMismatch(allText) {
+  const inquirer = (await import('inquirer')).default;
+
+  // Try to extract ticket ID from error text
+  const ticketMatch = allText.match(/Ticket(?:\s+ID)?\s+(?:of\s+)?([A-Za-z0-9_-]+)/i);
+  const ticketId = ticketMatch?.[1] || 'unknown';
+
+  // Try to extract record details
+  const entityMatch = allText.match(/entity:(\w+)/);
+  const rowIdMatch = allText.match(/RowID:(\d+)/);
+  const uidMatch = allText.match(/UID:([a-zA-Z0-9]+)/);
+  const entity = entityMatch?.[1];
+  const rowId = rowIdMatch?.[1];
+  const uid = uidMatch?.[1];
+
+  log.warn(`Ticket "${ticketId}" is for another repository.`);
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'repoAction',
+      message: `The Ticket ID of "${ticketId}" is for another Repository:`,
+      choices: [
+        { name: 'Commit anyway', value: 'commit_one' },
+        { name: 'Submit with another Ticket ID', value: 'change_one' },
+        { name: 'Skip this record', value: 'skip_one' },
+        { name: 'Commit all transactions with this ID anyway', value: 'commit_all' },
+        { name: 'Commit all transactions with another Ticket ID, and update my current Ticket ID reference', value: 'change_all' },
+        { name: 'Skip all', value: 'skip_all' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'newTicketId',
+      message: 'Enter new Ticket ID:',
+      when: (a) => a.repoAction === 'change_one' || a.repoAction === 'change_all',
+      validate: v => v.trim() ? true : 'Ticket ID is required',
+    },
+  ]);
+
+  if (answers.repoAction === 'skip_one') {
+    return { skipRecord: true };
+  }
+  if (answers.repoAction === 'skip_all') {
+    return { skipAll: true };
+  }
+
+  // "Commit anyway" options — retry with same ticket
+  if (answers.repoAction === 'commit_one') {
+    return {
+      retryParams: { '_OverrideTicketID': ticketId },
+      ticketExpressions: [],
+    };
+  }
+  if (answers.repoAction === 'commit_all') {
+    await setGlobalTicket(ticketId);
+    log.dim(`  Will use ticket "${ticketId}" for all remaining submissions`);
+    return {
+      retryParams: { '_OverrideTicketID': ticketId },
+      ticketExpressions: [],
+    };
+  }
+
+  // "Change ticket" options
+  const newTicketId = answers.newTicketId.trim();
+  const ticketExpressions = [];
+
+  if (entity && rowId) {
+    ticketExpressions.push(buildTicketExpression(entity, rowId, newTicketId));
+  }
+
+  if (answers.repoAction === 'change_all') {
+    await setGlobalTicket(newTicketId);
+    log.dim(`  Stored ticket "${newTicketId}" for all future submissions`);
+  } else if (uid) {
+    await setRecordTicket(uid, rowId, entity, newTicketId);
+    log.dim(`  Stored ticket "${newTicketId}" for record ${uid}`);
+  }
+
+  return {
+    retryParams: { '_OverrideTicketID': newTicketId },
+    ticketExpressions,
+  };
+}
+
 /**
  * Parse file arguments in the format: field=@path or just @path
  * Returns objects suitable for multipart upload.

package/src/lib/ticketing.js

@@ -0,0 +1,189 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { log } from './logger.js';
+
+const DBO_DIR = '.dbo';
+const TICKETING_FILE = 'ticketing.local.json';
+
+function dboDir() {
+  return join(process.cwd(), DBO_DIR);
+}
+
+function ticketingPath() {
+  return join(dboDir(), TICKETING_FILE);
+}
+
+const DEFAULT_TICKETING = { ticket_id: null, records: [] };
+
+/**
+ * Load ticketing.local.json. Returns default structure if missing or corrupted.
+ */
+export async function loadTicketing() {
+  try {
+    const raw = await readFile(ticketingPath(), 'utf8');
+    const data = JSON.parse(raw);
+    return {
+      ticket_id: data.ticket_id || null,
+      records: Array.isArray(data.records) ? data.records : [],
+    };
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      log.warn('Ticketing config is corrupted or unreadable — starting fresh.');
+    }
+    return { ...DEFAULT_TICKETING, records: [] };
+  }
+}
+
+/**
+ * Save ticketing.local.json.
+ */
+export async function saveTicketing(data) {
+  await mkdir(dboDir(), { recursive: true });
+  await writeFile(ticketingPath(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Get the global ticket_id, or null if not set.
+ */
+export async function getGlobalTicket() {
+  const data = await loadTicketing();
+  return data.ticket_id || null;
+}
+
+/**
+ * Get the per-record ticket for a specific UID, or null.
+ */
+export async function getRecordTicket(uid) {
+  const data = await loadTicketing();
+  const record = data.records.find(r => r.UID === uid);
+  return record ? record.ticket_id : null;
+}
+
+/**
+ * Set the global ticket_id.
+ */
+export async function setGlobalTicket(ticketId) {
+  const data = await loadTicketing();
+  data.ticket_id = ticketId;
+  await saveTicketing(data);
+}
+
+/**
+ * Store a per-record ticket entry. Deduplicates by UID.
+ */
+export async function setRecordTicket(uid, rowId, entity, ticketId) {
+  const data = await loadTicketing();
+  const idx = data.records.findIndex(r => r.UID === uid);
+  const entry = {
+    UID: uid,
+    RowID: rowId,
+    entity,
+    ticket_id: ticketId,
+    expression: buildTicketExpression(entity, rowId, ticketId),
+  };
+  if (idx >= 0) {
+    data.records[idx] = entry;
+  } else {
+    data.records.push(entry);
+  }
+  await saveTicketing(data);
+}
+
+/**
+ * Clear the global ticket_id (preserves records).
+ */
+export async function clearGlobalTicket() {
+  const data = await loadTicketing();
+  data.ticket_id = null;
+  await saveTicketing(data);
+}
+
+/**
+ * Remove a specific per-record ticket by UID.
+ */
+export async function clearRecordTicket(uid) {
+  const data = await loadTicketing();
+  const before = data.records.length;
+  data.records = data.records.filter(r => r.UID !== uid);
+  if (data.records.length !== before) {
+    await saveTicketing(data);
+  }
+}
+
+/**
+ * Clear all per-record tickets (preserves global ticket_id).
+ */
+export async function clearAllRecordTickets() {
+  const data = await loadTicketing();
+  if (data.records.length > 0) {
+    data.records = [];
+    await saveTicketing(data);
+  }
+}
+
+/**
+ * Build a ticket column expression for DBO input syntax.
+ */
+export function buildTicketExpression(entity, rowId, ticketId) {
+  return `RowID:${rowId};column:${entity}._LastUpdatedTicketID=${ticketId}`;
+}
+
+/**
+ * Check for a stored ticket before batch submission and prompt the user.
+ * Returns { useTicket, clearTicket, cancel }.
+ *
+ * @param {Object} options - Command options (checks options.ticket for flag override)
+ */
+export async function checkStoredTicket(options) {
+  // --ticket flag takes precedence; skip stored-ticket prompt
+  if (options.ticket) {
+    return { useTicket: false, clearTicket: false, cancel: false };
+  }
+
+  const data = await loadTicketing();
+  if (!data.ticket_id) {
+    return { useTicket: false, clearTicket: false, cancel: false };
+  }
+
+  const inquirer = (await import('inquirer')).default;
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: `Use stored Ticket ID "${data.ticket_id}" for this submission?`,
+    choices: [
+      { name: `Yes, use "${data.ticket_id}"`, value: 'use' },
+      { name: 'No, clear stored ticket', value: 'clear' },
+      { name: 'Cancel submission', value: 'cancel' },
+    ],
+  }]);
+
+  return {
+    useTicket: action === 'use',
+    clearTicket: action === 'clear',
+    cancel: action === 'cancel',
+  };
+}
+
+/**
+ * Apply a stored ticket to submission data expressions if no --ticket flag is set.
+ * Checks per-record ticket first, then global ticket.
+ *
+ * @param {string[]} dataExprs - The data expressions array (mutated in place)
+ * @param {string} entity - Entity name
+ * @param {string|number} rowId - Row ID or UID used in the submission
+ * @param {string} uid - Record UID for per-record lookup
+ * @param {Object} options - Command options
+ */
+export async function applyStoredTicketToSubmission(dataExprs, entity, rowId, uid, options) {
+  if (options.ticket) return; // --ticket flag takes precedence
+
+  const recordTicket = await getRecordTicket(uid);
+  const globalTicket = await getGlobalTicket();
+  const ticketToUse = recordTicket || globalTicket;
+
+  if (ticketToUse) {
+    const ticketExpr = buildTicketExpression(entity, rowId, ticketToUse);
+    dataExprs.push(ticketExpr);
+    log.dim(`  Applying ticket: ${ticketToUse}`);
+  }
+}