@dboio/cli 0.8.0 → 0.9.2

package/src/lib/delta.js

@@ -1,4 +1,4 @@
-import { readFile } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import { join, dirname } from 'path';
 import { log } from './logger.js';
 
@@ -132,6 +132,19 @@ export async function detectChangedColumns(metaPath, baseline) {
     }
   }
 
+  // Check _mediaFile for binary file changes (media entities)
+  if (metadata._mediaFile && isReference(metadata._mediaFile)) {
+    const mediaPath = resolveReferencePath(metadata._mediaFile, metaDir);
+    try {
+      const mediaStat = await stat(mediaPath);
+      const metaStat = await stat(metaPath);
+      // Media file modified more recently than metadata = local change
+      if (mediaStat.mtimeMs > metaStat.mtimeMs + 2000) {
+        changedColumns.push('_mediaFile');
+      }
+    } catch { /* missing file, skip */ }
+  }
+
   return changedColumns;
 }
 

package/src/lib/diff.js

@@ -45,10 +45,12 @@ export async function findMetadataFiles(dir, ig) {
       if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
       results.push(...await findMetadataFiles(fullPath, ig));
     } else if (entry.name.endsWith('.metadata.json')) {
-      results.push(fullPath);
+      const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+      if (!ig.ignores(relPath)) results.push(fullPath);
     } else if (entry.name.startsWith('_output~') && entry.name.endsWith('.json') && !entry.name.includes('.CustomSQL.')) {
       // Output hierarchy files: _output~<name>~<uid>.json and nested entity files
-      results.push(fullPath);
+      const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+      if (!ig.ignores(relPath)) results.push(fullPath);
     }
   }
 

package/src/lib/filenames.js

@@ -0,0 +1,151 @@
+/**
+ * Filename convention helpers for the UID tilde convention.
+ * All entity files use <basename>~<uid>.<ext> as the local filename.
+ */
+
+import { rename, writeFile } from 'fs/promises';
+import { join, dirname, basename, extname } from 'path';
+
+/**
+ * Build a UID-bearing filename following the tilde convention.
+ * If name === uid, omit the tilde suffix (avoids <uid>~<uid>).
+ *
+ * @param {string} name  - Sanitized base name (no extension)
+ * @param {string} uid   - Server-assigned UID
+ * @param {string} [ext] - File extension WITHOUT leading dot (e.g. 'css', 'png', '')
+ * @returns {string}     - e.g. "colors~abc123.css" or "abc123.css" or "colors~abc123"
+ */
+export function buildUidFilename(name, uid, ext = '') {
+  const base = (name === uid) ? uid : `${name}~${uid}`;
+  return ext ? `${base}.${ext}` : base;
+}
+
+/**
+ * Strip the ~<uid> portion from a local filename.
+ * Used when the local file is "logo~def456.png" but the upload should send "logo.png".
+ *
+ * If the uid is not found in the filename, returns localName unchanged.
+ *
+ * @param {string} localName  - e.g. "logo~def456.png"
+ * @param {string} uid        - e.g. "def456"
+ * @returns {string}          - e.g. "logo.png"
+ */
+export function stripUidFromFilename(localName, uid) {
+  if (!uid || !localName) return localName;
+  const marker = `~${uid}`;
+  const idx = localName.indexOf(marker);
+  if (idx === -1) return localName;
+  return localName.slice(0, idx) + localName.slice(idx + marker.length);
+}
+
+/**
+ * Check whether a filename already contains ~<uid>.
+ */
+export function hasUidInFilename(filename, uid) {
+  return typeof filename === 'string' && typeof uid === 'string'
+    && filename.includes(`~${uid}`);
+}
+
+/**
+ * Detect whether a metadata filename uses the OLD dot-separated convention:
+ *   <name>.<uid>.metadata.json
+ * where uid is a sequence of ≥10 lowercase alphanumeric characters.
+ *
+ * Returns { name, uid } or null.
+ */
+export function detectLegacyDotUid(filename) {
+  const match = filename.match(/^(.+)\.([a-z0-9]{10,})\.metadata\.json$/);
+  return match ? { name: match[1], uid: match[2] } : null;
+}
+
+/**
+ * Rename a file pair (content + metadata) to the ~uid convention after server assigns a UID.
+ * Updates @reference values inside the metadata file.
+ * Restores file timestamps from _LastUpdated.
+ *
+ * @param {Object} meta        - Current metadata object
+ * @param {string} metaPath    - Absolute path to the .metadata.json file
+ * @param {string} uid         - Newly assigned UID from server
+ * @param {string} lastUpdated - Server _LastUpdated value
+ * @param {string} serverTz    - Timezone for timestamp conversion
+ * @returns {Promise<{ newMetaPath: string, newFilePath: string|null }>}
+ */
+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"
+
+  if (hasUidInFilename(metaBase, uid)) {
+    return { newMetaPath: metaPath, newFilePath: null }; // already renamed
+  }
+
+  // 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) {
+    // Media: "logo.png" → "logo~uid.png"
+    const nameWithoutExt = metaBase.slice(0, -metaBaseExt.length);
+    newMetaBase = `${buildUidFilename(nameWithoutExt, uid)}${metaBaseExt}`;
+  } else {
+    // Content/entity-dir: "colors" → "colors~uid"
+    newMetaBase = buildUidFilename(metaBase, uid);
+  }
+
+  const newMetaPath = join(metaDir, `${newMetaBase}.metadata.json`);
+
+  // Update metadata in memory
+  meta.UID = uid;
+  const updatedMeta = { ...meta };
+
+  // Rename content files referenced in _contentColumns and _mediaFile
+  const contentCols = [...(meta._contentColumns || [])];
+  if (meta._mediaFile) contentCols.push('_mediaFile');
+
+  let newFilePath = null;
+
+  for (const col of contentCols) {
+    const ref = meta[col];
+    if (!ref || !String(ref).startsWith('@')) continue;
+
+    const oldRefFile = String(ref).substring(1);
+    const oldFilePath = join(metaDir, oldRefFile);
+
+    // Compute new filename: insert uid
+    const oldExt = extname(oldRefFile); // ".css", ".png"
+    const oldBase = basename(oldRefFile, oldExt); // "colors" or "logo"
+    const newRefBase = buildUidFilename(oldBase, uid);
+    const newRefFile = oldExt ? `${newRefBase}${oldExt}` : newRefBase;
+    const newRefPath = join(metaDir, newRefFile);
+
+    try {
+      await rename(oldFilePath, newRefPath);
+      updatedMeta[col] = `@${newRefFile}`;
+      if (!newFilePath) newFilePath = newRefPath;
+    } catch {
+      // File may already be renamed or may not exist
+    }
+  }
+
+  // Write updated metadata to new path
+  await writeFile(newMetaPath, JSON.stringify(updatedMeta, null, 2) + '\n');
+
+  // Remove old metadata file if it's different from newMetaPath
+  if (metaPath !== newMetaPath) {
+    try { await rename(metaPath, newMetaPath); } catch { /* already written above */ }
+  }
+
+  // Restore timestamps
+  if (serverTz && lastUpdated) {
+    const { setFileTimestamps } = await import('./timestamps.js');
+    for (const col of contentCols) {
+      const ref = updatedMeta[col];
+      if (ref && String(ref).startsWith('@')) {
+        const fp = join(metaDir, String(ref).substring(1));
+        try { await setFileTimestamps(fp, lastUpdated, lastUpdated, serverTz); } catch {}
+      }
+    }
+    try { await setFileTimestamps(newMetaPath, lastUpdated, lastUpdated, serverTz); } catch {}
+  }
+
+  return { newMetaPath, newFilePath, updatedMeta };
+}

package/src/lib/formatter.js

@@ -16,19 +16,30 @@ export function formatResponse(result, options = {}) {
   }
 
   if (result.successful) {
-    log.success(`Request successful ${chalk.dim(result.url || '')}`);
+    log.success('Request successful');
+    // Show the payload as compact highlighted JSON so the user sees what changed
+    if (result.payload) {
+      printJsonCompact(result.payload);
+    }
   } else {
-    log.error(`Request failed ${chalk.dim(result.url || '')}`);
-  }
-
-  if (result.messages && result.messages.length > 0) {
-    for (const msg of result.messages) {
-      log.label('Message', msg);
+    log.error('Request failed');
+    if (result.messages && result.messages.length > 0) {
+      for (const msg of result.messages) {
+        log.label('Message', truncateParamValues(String(msg)));
+      }
+    }
+    // On failure: show compact response summary; full JSON only with --verbose
+    if (result.data) {
+      if (options.verbose) {
+        log.plain('');
+        log.dim('─── Response JSON ───');
+        printJson(result.data);
+      } else {
+        log.plain('');
+        log.dim('─── Response (use -v for full JSON) ───');
+        printJsonCompact(result.data);
+      }
     }
-  }
-
-  if (result.payload) {
-    formatPayload(result.payload, options);
   }
 }
 
@@ -301,6 +312,77 @@ function printJson(data) {
   log.plain(colored);
 }
 
+/**
+ * Print JSON with syntax highlighting, truncating long string values.
+ * Strings over 120 chars are collapsed to a short preview + byte count.
+ */
+function printJsonCompact(data) {
+  const json = JSON.stringify(data, (key, value) => {
+    if (typeof value === 'string' && value.length > 120) {
+      const preview = value.substring(0, 60).replace(/\n/g, '\\n');
+      const kb = (value.length / 1024).toFixed(1);
+      return `${preview}… (${kb} KB)`;
+    }
+    return value;
+  }, 2);
+  if (!json) { log.plain('null'); return; }
+
+  const colored = json.replace(
+    /("(?:[^"\\]|\\.)*")\s*:/g,
+    (match, k) => chalk.cyan(k) + ':'
+  ).replace(
+    /:\s*("(?:[^"\\]|\\.)*")/g,
+    (match, val) => ': ' + chalk.green(val)
+  ).replace(
+    /:\s*(\d+\.?\d*)/g,
+    (match, num) => ': ' + chalk.yellow(num)
+  ).replace(
+    /:\s*(true|false|null)/g,
+    (match, val) => ': ' + chalk.magenta(val)
+  );
+
+  log.plain(colored);
+}
+
+/**
+ * Truncate long parameter values in server error messages.
+ * SQL debug output contains lines like "  @Content = <entire HTML file>" —
+ * collapse those so the terminal isn't flooded.
+ *
+ * Strategy: split on lines, find "  @Param = value" lines where the value
+ * portion (everything after " = ") spans many characters, and collapse.
+ */
+function truncateParamValues(text) {
+  const lines = text.split('\n');
+  const result = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const paramMatch = lines[i].match(/^(\s*@\w+\s*=\s*)(.*)/);
+    if (paramMatch) {
+      const prefix = paramMatch[1]; // "  @Content = "
+      // Collect continuation lines (lines that don't start a new @param or section marker)
+      let value = paramMatch[2];
+      while (i + 1 < lines.length && !lines[i + 1].match(/^\s*@\w+\s*=/) && !lines[i + 1].match(/^\[/)) {
+        i++;
+        value += '\n' + lines[i];
+      }
+      if (value.length > 120) {
+        const preview = value.substring(0, 60).replace(/\n/g, ' ').trim();
+        const kb = (value.length / 1024).toFixed(1);
+        result.push(`${prefix}${preview}... (${kb} KB)`);
+      } else {
+        result.push(`${prefix}${value}`);
+      }
+    } else {
+      result.push(lines[i]);
+    }
+    i++;
+  }
+
+  return result.join('\n');
+}
+
 export function formatError(err) {
   if (err.message) {
     log.error(err.message);

package/src/lib/ignore.js

@@ -19,7 +19,9 @@ app.json
 .app.json
 dbo.deploy.json
 
-# Editor / IDE
+# Editor / IDE / OS
+.DS_Store
+Thumbs.db
 .idea/
 .vscode/
 *.codekit3
@@ -39,6 +41,10 @@ node_modules/
 package.json
 package-lock.json
 
+# Local development (not pushed to DBO server)
+src/
+tests/
+
 # Documentation (repo scaffolding)
 SETUP.md
 README.md
@@ -58,7 +64,7 @@ export function getDefaultFileContent() {
 /**
  * Extract just the active pattern lines from DEFAULT_FILE_CONTENT.
  */
-function getDefaultPatternLines() {
+export function getDefaultPatternLines() {
   return DEFAULT_FILE_CONTENT
     .split('\n')
     .filter(l => l && !l.startsWith('#'));

package/src/lib/input-parser.js

@@ -1,9 +1,23 @@
 import { readFile } from 'fs/promises';
 import { log } from './logger.js';
 import { loadUserInfo, loadTicketSuggestionOutput } from './config.js';
-import { buildTicketExpression, setGlobalTicket, setRecordTicket, getGlobalTicket, getRecordTicket } from './ticketing.js';
+import { buildTicketExpression, setGlobalTicket, setRecordTicket, getGlobalTicket, getRecordTicket, setTicketingRequired } from './ticketing.js';
 import { DboClient } from './client.js';
 
+// Session-level cache: once the user resolves a UserID prompt, reuse it for all
+// subsequent records in the same CLI invocation (one process = one push batch).
+let _sessionUserOverride = null;
+
+/** Get cached UserID override (set after first interactive prompt). */
+export function getSessionUserOverride() {
+  return _sessionUserOverride;
+}
+
+/** Reset session caches (for tests). */
+export function resetSessionCache() {
+  _sessionUserOverride = null;
+}
+
 /**
  * Parse DBO input syntax and build form data.
  *
@@ -160,9 +174,16 @@ export async function checkSubmitErrors(result, context = {}) {
     return Object.keys(retryParams).length > 0 ? retryParams : null;
   }
 
+  // Session cache: reuse UserID from a previous prompt in this batch
+  const userResolved = needsUser && _sessionUserOverride;
+  if (userResolved) {
+    retryParams['_OverrideUserID'] = _sessionUserOverride;
+    log.dim(`  Using cached user ID: ${_sessionUserOverride}`);
+  }
+
   const prompts = [];
 
-  if (needsUser) {
+  if (needsUser && !userResolved) {
     log.warn(`This operation requires an authenticated user (${matchedUserPattern}).`);
     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.');
@@ -215,7 +236,9 @@ export async function checkSubmitErrors(result, context = {}) {
   const userValue = answers.userValue
     || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
   if (userValue) {
-    retryParams['_OverrideUserID'] = userValue.trim();
+    const resolved = userValue.trim();
+    retryParams['_OverrideUserID'] = resolved;
+    _sessionUserOverride = resolved; // cache for remaining records in this batch
   }
 
   return retryParams;
@@ -226,6 +249,9 @@ export async function checkSubmitErrors(result, context = {}) {
  * Prompts the user with 4 recovery options.
  */
 async function handleTicketError(allText, context = {}) {
+  // Mark this app as requiring ticketing (detected on first ticket_error)
+  await setTicketingRequired();
+
   // Try to extract record details from error text
   const entityMatch = allText.match(/entity:(\w+)/);
   const rowIdMatch = allText.match(/RowID:(\d+)/);
@@ -312,8 +338,8 @@ async function handleTicketError(allText, context = {}) {
       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: 'Apply a Ticket ID to this record only', value: 'apply_one' },
         { name: 'Skip this record update', value: 'skip_one' },
         { name: 'Skip all updates that require a Ticket ID', value: 'skip_all' },
       ],

package/src/lib/metadata-templates.js

@@ -0,0 +1,264 @@
+import { readFile, writeFile } from 'fs/promises';
+import { relative, basename, extname } from 'path';
+import { EXTENSION_DESCRIPTORS_DIR, ENTITY_DIR_NAMES } from './structure.js';
+import inquirer from 'inquirer';
+
+const METADATA_TEMPLATES_FILE = '.dbo/metadata_templates.json';
+
+const STATIC_DIRECTIVE_MAP = {
+  docs: { entity: 'extension', descriptor: 'documentation' },
+};
+
+/**
+ * Convert a name to snake_case.
+ */
+export function toSnakeCase(name) {
+  return name
+    .toLowerCase()
+    .replace(/[\s-]+/g, '_')
+    .replace(/[^a-z0-9_]/g, '');
+}
+
+/**
+ * Resolve entity/descriptor directive from a file path.
+ * Returns { entity, descriptor } or null.
+ */
+export function resolveDirective(filePath) {
+  const rel = relative(process.cwd(), filePath).replace(/\\/g, '/');
+  const parts = rel.split('/');
+  const topDir = parts[0];
+
+  // docs/ prefix → static mapping
+  if (topDir === 'docs') {
+    return { ...STATIC_DIRECTIVE_MAP.docs };
+  }
+
+  // extension/<descriptor>/ — need at least 3 parts (extension/descriptor/file)
+  if (topDir === 'extension') {
+    if (parts.length < 3) return null;
+    const secondDir = parts[1];
+    if (secondDir.startsWith('.')) return null;
+    return { entity: 'extension', descriptor: secondDir };
+  }
+
+  // Other entity-dir types
+  if (ENTITY_DIR_NAMES.has(topDir)) {
+    return { entity: topDir, descriptor: null };
+  }
+
+  return null;
+}
+
+/**
+ * Load metadata templates from .dbo/metadata_templates.json.
+ */
+export async function loadMetadataTemplates() {
+  try {
+    const raw = await readFile(METADATA_TEMPLATES_FILE, 'utf8');
+    try {
+      return JSON.parse(raw);
+    } catch {
+      console.warn('Warning: .dbo/metadata_templates.json is malformed JSON — falling back to generic wizard');
+      return null;
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') return {};
+    return {};
+  }
+}
+
+/**
+ * Save metadata templates to .dbo/metadata_templates.json.
+ */
+export async function saveMetadataTemplates(templates) {
+  await writeFile(METADATA_TEMPLATES_FILE, JSON.stringify(templates, null, 2) + '\n');
+}
+
+/**
+ * Get template cols for a given entity and optional descriptor.
+ * Returns string[] or null.
+ */
+export function getTemplateCols(templates, entity, descriptor) {
+  if (!templates || !templates[entity]) return null;
+  const entry = templates[entity];
+
+  if (descriptor) {
+    // entry must be an object (not array)
+    if (Array.isArray(entry)) return null;
+    return entry[descriptor] ?? null;
+  }
+
+  // no descriptor — entry must be an array
+  if (!Array.isArray(entry)) return null;
+  return entry;
+}
+
+/**
+ * Set template cols for a given entity and optional descriptor.
+ * Mutates templates in place.
+ */
+export function setTemplateCols(templates, entity, descriptor, cols) {
+  if (descriptor) {
+    if (!templates[entity] || Array.isArray(templates[entity])) {
+      templates[entity] = {};
+    }
+    templates[entity][descriptor] = cols;
+  } else {
+    templates[entity] = cols;
+  }
+}
+
+/**
+ * Build cols from a record's keys, excluding _ prefixed and array values.
+ */
+function buildColsFromRecord(record) {
+  return Object.keys(record).filter(key => {
+    if (key.startsWith('_')) return false;
+    if (Array.isArray(record[key])) return false;
+    return true;
+  });
+}
+
+/**
+ * Build baseline minimum viable cols for an entity type.
+ */
+function buildBaselineCols(entity, descriptor) {
+  const cols = ['AppID', 'Name'];
+  if (entity === 'extension') {
+    cols.push('ShortName');
+    if (descriptor) cols.push(`Descriptor=${descriptor}`);
+    cols.push('Active');
+  }
+  return cols;
+}
+
+/**
+ * Resolve template cols via three-level lookup:
+ * 1. metadata_templates.json
+ * 2. appJson sample record
+ * 3. baseline defaults
+ */
+export async function resolveTemplateCols(entity, descriptor, appConfig, appJson) {
+  const templates = await loadMetadataTemplates();
+  if (templates === null) return null;
+
+  // Level 1: existing template
+  const existing = getTemplateCols(templates, entity, descriptor);
+  if (existing) return { cols: existing, templates, isNew: false };
+
+  // Level 2: derive from appJson
+  if (appJson) {
+    let records = null;
+
+    if (entity === 'extension' && descriptor) {
+      // appJson[entity] might be an object keyed by descriptor
+      const entityData = appJson[entity];
+      if (entityData) {
+        if (Array.isArray(entityData)) {
+          records = entityData;
+        } else if (typeof entityData === 'object' && entityData[descriptor]) {
+          const descData = entityData[descriptor];
+          if (Array.isArray(descData)) records = descData;
+        }
+      }
+    } else {
+      const entityData = appJson[entity];
+      if (Array.isArray(entityData)) records = entityData;
+    }
+
+    if (records && records.length > 0) {
+      const cols = buildColsFromRecord(records[0]);
+      setTemplateCols(templates, entity, descriptor, cols);
+      await saveMetadataTemplates(templates);
+      return { cols, templates, isNew: true };
+    }
+  }
+
+  // Level 3: baseline defaults
+  const cols = buildBaselineCols(entity, descriptor);
+  setTemplateCols(templates, entity, descriptor, cols);
+  await saveMetadataTemplates(templates);
+  return { cols, templates, isNew: true };
+}
+
+/**
+ * Assemble metadata object from cols and file info.
+ */
+export function assembleMetadata(cols, filePath, entity, descriptor, appConfig) {
+  const rel = relative(process.cwd(), filePath).replace(/\\/g, '/');
+  const base = basename(filePath, extname(filePath));
+  const fileName = basename(filePath);
+  const isDocsFile = rel.startsWith('docs/');
+  const meta = { _entity: entity };
+  const contentColumns = [];
+
+  for (const col of cols) {
+    if (col.includes('=')) {
+      const eqIdx = col.indexOf('=');
+      const key = col.substring(0, eqIdx);
+      const val = col.substring(eqIdx + 1);
+
+      if (val === '@reference') {
+        const refPath = isDocsFile ? '@/' + rel : '@' + fileName;
+        meta[key] = refPath;
+        contentColumns.push(key);
+      } else {
+        meta[key] = val;
+      }
+    } else if (col === 'AppID') {
+      meta.AppID = appConfig?.AppID ?? '';
+    } else if (col === 'Name') {
+      meta.Name = base;
+    } else if (col === 'ShortName') {
+      meta.ShortName = toSnakeCase(base);
+    } else {
+      meta[col] = '';
+    }
+  }
+
+  let refColMissing = false;
+  if (contentColumns.length === 0) {
+    refColMissing = true;
+  } else {
+    meta._contentColumns = contentColumns;
+  }
+
+  return { meta, contentColumns, refColMissing };
+}
+
+/**
+ * Prompt user to select a reference column from available string cols.
+ */
+export async function promptReferenceColumn(cols, entity, descriptor) {
+  const stringCols = cols.filter(c => !c.includes('=') && c !== 'AppID' && c !== 'Name' && c !== 'ShortName');
+  if (stringCols.length === 0) return null;
+
+  const { selected } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selected',
+    message: `Select the content/reference column for ${entity}${descriptor ? '/' + descriptor : ''}:`,
+    choices: stringCols,
+  }]);
+
+  return selected;
+}
+
+/**
+ * Build a template cols array from a clone record.
+ */
+export function buildTemplateFromCloneRecord(record, contentColsExtracted = []) {
+  const cols = [];
+  for (const key of Object.keys(record)) {
+    if (key.startsWith('_')) continue;
+    if (Array.isArray(record[key])) continue;
+
+    if (contentColsExtracted.includes(key)) {
+      cols.push(key + '=@reference');
+    } else if (key === 'Descriptor' && record[key]) {
+      cols.push('Descriptor=' + record[key]);
+    } else {
+      cols.push(key);
+    }
+  }
+  return cols;
+}