@icedq/cli 0.1.3 → 0.2.1

package/src/commands/generate-mapping.js

@@ -0,0 +1,217 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig } from '../core/config.js';
+import { KeycloakClientCredentialsAuth } from '../core/auth.js';
+import { IcedqApiClient } from '../core/client.js';
+import { Reporter } from '../core/reporter.js';
+import { ApiError, CliError } from '../core/errors.js';
+import { log, setLevel } from '../core/logger.js';
+
+const PAGE_SIZE = 1000;
+
+export async function runGenerateMapping(rawOpts) {
+  if (rawOpts.verbose) setLevel('debug');
+  if (rawOpts.quiet) setLevel('error');
+
+  if (!rawOpts.bundle) throw new CliError('--bundle is required');
+  if (!rawOpts.outputFile) throw new CliError('--output-file is required');
+
+  const cfg = loadConfig(rawOpts);
+  const auth = new KeycloakClientCredentialsAuth({
+    keycloakUrl: cfg.keycloakUrl,
+    clientId: cfg.clientId,
+    clientSecret: cfg.clientSecret,
+    verifySsl: cfg.verifySsl
+  });
+  const client = new IcedqApiClient({
+    baseUrl: cfg.icedqUrl,
+    orgId: cfg.orgId,
+    accountId: cfg.accountId,
+    workspaceId: cfg.workspaceId,
+    auth,
+    verifySsl: cfg.verifySsl
+  });
+
+  const bundlePath = path.resolve(rawOpts.bundle);
+  let bundleBuffer;
+  try {
+    bundleBuffer = await readFile(bundlePath);
+  } catch (err) {
+    throw new CliError(`could not read bundle at ${bundlePath}: ${err.message}`);
+  }
+
+  // Step 1: get expected mappings from bundle
+  log.info('Uploading bundle to get expected mappings');
+  const expected = await client.postMultipart('/api/v1/internal/imports/mapping', {
+    file: {
+      buffer: bundleBuffer,
+      filename: path.basename(bundlePath),
+      contentType: 'application/zip'
+    }
+  });
+
+  const srcConnections = expected.connections || [];
+  const srcParameters = expected.parameters || [];
+  const srcCustomFields = expected.customFields || [];
+
+  log.info('Expected mappings', {
+    connections: srcConnections.length,
+    parameters: srcParameters.length,
+    customFields: srcCustomFields.length
+  });
+
+  // Step 2: resolve connections from target environment
+  const connections = await resolveConnections(client, srcConnections);
+
+  // Step 3: resolve parameters from target environment
+  const parameters = await resolveParameters(client, srcParameters);
+
+  // Step 4: resolve custom fields from target environment
+  const customFields = await resolveCustomFields(client, srcCustomFields);
+
+  const mappingDoc = {
+    useFqn: true,
+    mapping: { connections, parameters, customFields }
+  };
+
+  const outputFile = path.resolve(rawOpts.outputFile);
+  await mkdir(path.dirname(outputFile), { recursive: true });
+  await writeFile(outputFile, JSON.stringify(mappingDoc, null, 2), 'utf8');
+  log.info('Mapping file written', { outputFile });
+
+  const result = {
+    command: 'generate-mapping',
+    outputFile,
+    connections: connections.length,
+    parameters: parameters.length,
+    customFields: customFields.length
+  };
+  new Reporter(rawOpts.output || 'text').emit(result);
+}
+
+async function resolveConnections(client, srcConnections) {
+  if (srcConnections.length === 0) return [];
+
+  // Group source connections by connectorId
+  const byConnectorId = new Map();
+  for (const conn of srcConnections) {
+    if (!byConnectorId.has(conn.connectorId)) byConnectorId.set(conn.connectorId, []);
+    byConnectorId.get(conn.connectorId).push(conn);
+  }
+
+  const mappings = [];
+
+  for (const [connectorId, srcConns] of byConnectorId) {
+    log.info('Searching connections in target', { connectorId });
+
+    // Fetch all pages for this connectorId
+    const targetItems = await fetchAllPages(client, '/api/v1/connections/search', {
+      filter: [{ attribute: 'connectorId', operator: 'In', datatype: 'string', value: connectorId }]
+    }, `connections with connectorId=${connectorId}`);
+
+    for (const src of srcConns) {
+      const match = targetItems.find(
+        (t) => t.name.toLowerCase() === src.name.toLowerCase()
+      );
+      if (!match) {
+        throw new CliError(
+          `Connection "${src.name}" (connectorId: ${connectorId}) was not found in the target environment. ` +
+          `Ensure a connection with this name exists in the target workspace before generating the mapping.`
+        );
+      }
+      mappings.push({ existingId: src.id, newId: match.id, action: 'override' });
+      log.info('Mapped connection', { name: src.name, existingId: src.id, newId: match.id });
+    }
+  }
+
+  return mappings;
+}
+
+async function resolveParameters(client, srcParameters) {
+  if (srcParameters.length === 0) return [];
+
+  log.info('Searching parameters in target');
+
+  let targetItems = [];
+  try {
+    targetItems = await fetchAllPages(client, '/api/v1/parameters/search', {}, 'parameters');
+  } catch (err) {
+    if (err instanceof ApiError && err.code === 'ResultsNotFound') {
+      log.warn('No parameters found in target environment — mapping without newId');
+      return srcParameters.map((p) => ({ existingId: p.id, action: 'upsert' }));
+    }
+    throw err;
+  }
+
+  return srcParameters.map((src) => {
+    const match = targetItems.find(
+      (t) => t.name.toLowerCase() === src.name.toLowerCase()
+    );
+    if (!match) {
+      log.warn('Parameter not matched in target, mapping without newId', { name: src.name });
+      return { existingId: src.id, action: 'upsert' };
+    }
+    log.info('Mapped parameter', { name: src.name, existingId: src.id, newId: match.id });
+    return { existingId: src.id, newId: match.id, action: 'upsert' };
+  });
+}
+
+async function resolveCustomFields(client, srcCustomFields) {
+  if (srcCustomFields.length === 0) return [];
+
+  log.info('Fetching screens for custom field mapping');
+  const screens = await client.post('/api/v1/screens/default/search', ['rule', 'check']);
+
+  // Flatten all fields from all sections of all screens into a name→id map
+  const fieldMap = new Map();
+  for (const screen of Array.isArray(screens) ? screens : []) {
+    const sections = screen?.info?.sections || [];
+    for (const section of sections) {
+      for (const field of section.fields || []) {
+        if (field.name && field.id) {
+          fieldMap.set(field.name.toLowerCase(), field.id);
+        }
+      }
+    }
+  }
+
+  const mappings = [];
+  for (const fieldName of srcCustomFields) {
+    const targetId = fieldMap.get(fieldName.toLowerCase());
+    if (!targetId) {
+      log.warn('Custom field not found in target screens, skipping', { fieldName });
+      continue;
+    }
+    mappings.push({ existingId: fieldName, newId: targetId, action: 'override' });
+    log.info('Mapped custom field', { fieldName, newId: targetId });
+  }
+
+  return mappings;
+}
+
+// Fetches all pages from a paginated POST search endpoint.
+// Throws ApiError with code='ResultsNotFound' when the endpoint reports nothing found.
+async function fetchAllPages(client, endpoint, body, label) {
+  const items = [];
+  let pageNo = 1;
+  let totalPages = 1;
+
+  do {
+    const url = `${endpoint}?pageNo=${pageNo}&pageSize=${PAGE_SIZE}&sort=updatedTimestamp:desc`;
+    const resp = await client.post(url, body);
+
+    // API may return 200 with {code, message} instead of a 4xx
+    if (resp && resp.code === 'ResultsNotFound') {
+      throw new ApiError(`${label}: ${resp.message || 'ResultsNotFound'}`, {
+        status: 200,
+        code: 'ResultsNotFound'
+      });
+    }
+
+    items.push(...(resp?.items || []));
+    totalPages = resp?.pageable?.pages ?? 1;
+    pageNo++;
+  } while (pageNo <= totalPages);
+
+  return items;
+}

package/src/commands/import.js

@@ -1,174 +1,174 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { loadConfig } from '../core/config.js';
-import { KeycloakClientCredentialsAuth } from '../core/auth.js';
-import { IcedqApiClient } from '../core/client.js';
-import { pollTask } from '../core/poller.js';
-import { Reporter } from '../core/reporter.js';
-import { parseImportLog } from '../lib/log-parser.js';
-import { isSuccess } from '../lib/status-enum.js';
-import { ApiError, BundleError, CliError, TaskFailedError } from '../core/errors.js';
-import { log, setLevel } from '../core/logger.js';
-
-const VALID_KINDS = new Set(['rules', 'workflows']);
-
-export async function runImport(rawOpts) {
-  if (rawOpts.verbose) setLevel('debug');
-  if (rawOpts.quiet) setLevel('error');
-
-  if (!rawOpts.bundle) throw new CliError('--bundle is required');
-  if (!rawOpts.kind || !VALID_KINDS.has(rawOpts.kind)) {
-    throw new CliError(`--kind must be one of: rules, workflows`);
-  }
-  if (!rawOpts.mappingFile) {
-    throw new CliError(
-      '--mapping-file is required in v0.1. Auto-mapping (`generate-mapping`) ships in v0.2.'
-    );
-  }
-
-  const cfg = loadConfig(rawOpts);
-  const auth = new KeycloakClientCredentialsAuth({
-    keycloakUrl: cfg.keycloakUrl,
-    clientId: cfg.clientId,
-    clientSecret: cfg.clientSecret,
-    verifySsl: cfg.verifySsl
-  });
-  const client = new IcedqApiClient({
-    baseUrl: cfg.icedqUrl,
-    orgId: cfg.orgId,
-    accountId: cfg.accountId,
-    workspaceId: cfg.workspaceId,
-    auth,
-    verifySsl: cfg.verifySsl
-  });
-
-  const bundlePath = path.resolve(rawOpts.bundle);
-  const mappingPath = path.resolve(rawOpts.mappingFile);
-
-  let bundleBuffer;
-  try {
-    bundleBuffer = await readFile(bundlePath);
-  } catch (err) {
-    throw new BundleError(`could not read bundle at ${bundlePath}: ${err.message}`);
-  }
-
-  let mappingDoc;
-  try {
-    const text = await readFile(mappingPath, 'utf8');
-    mappingDoc = JSON.parse(text);
-  } catch (err) {
-    throw new CliError(`could not parse --mapping-file at ${mappingPath}: ${err.message}`);
-  }
-
-  if (mappingDoc.useFqn === undefined) {
-    mappingDoc.useFqn = !!rawOpts.useFqn;
-  }
-
-  const submitParts = {
-    file: {
-      buffer: bundleBuffer,
-      filename: path.basename(bundlePath),
-      contentType: 'application/zip'
-    },
-    mapping: { json: mappingDoc }
-  };
-
-  const importPath = `/api/v1/imports/${rawOpts.kind}`;
-  log.info('Submitting import', { kind: rawOpts.kind, bundle: bundlePath, mapping: mappingPath });
-
-  let submitResp;
-  try {
-    submitResp = await client.postMultipart(importPath, submitParts);
-  } catch (err) {
-    if (err instanceof ApiError && err.isConstraintViolation()) {
-      const result = {
-        command: 'import',
-        status: 'ConstraintViolation',
-        hardErrors: err.messages.map(
-          (m) => `${m.fieldName ? m.fieldName + ': ' : ''}${m.violation || m.message || ''}`
-        )
-      };
-      new Reporter(rawOpts.output || 'text').emit(result);
-      throw err;
-    }
-    if (err instanceof ApiError && err.status === 409 && rawOpts.terminateOnConflict) {
-      log.warn('Active import job conflicts; locating and terminating');
-      await terminateActiveImport(client);
-      submitResp = await client.postMultipart(importPath, submitParts);
-    } else {
-      throw err;
-    }
-  }
-
-  const taskId = submitResp.taskInstanceId;
-  if (!taskId) throw new CliError(`Import submit did not return taskInstanceId: ${JSON.stringify(submitResp)}`);
-  process.stderr.write(`task-id: ${taskId}\n`);
-
-  const start = Date.now();
-  const { status, elapsedMs, attempts } = await pollTask(client, 'imports', taskId, {
-    timeoutSec: cfg.timeoutSec,
-    onTick: ({ status: s, attempt }) => log.debug('tick', { status: s, attempt })
-  });
-
-  let logText = '';
-  try {
-    logText = await client.get(`/api/v1/imports/${taskId}/log`);
-    if (typeof logText !== 'string') logText = JSON.stringify(logText);
-  } catch (err) {
-    log.warn('Could not retrieve import log', { error: err.message });
-  }
-
-  if (rawOpts.retainLog && logText) {
-    const logPath = path.resolve(rawOpts.retainLog);
-    try {
-      await writeFile(logPath, logText, 'utf8');
-      log.info('Import log retained', { logPath });
-    } catch (err) {
-      log.warn('Could not write retained log', { logPath, error: err.message });
-    }
-  }
-
-  const parsed = parseImportLog(logText);
-  const result = {
-    command: 'import',
-    taskId,
-    status,
-    attempts,
-    durationMs: elapsedMs,
-    skippedCount: parsed.skippedCount,
-    skippedRules: parsed.skippedRules,
-    hardErrors: parsed.hardErrors,
-    elapsedSinceSubmitMs: Date.now() - start
-  };
-  new Reporter(rawOpts.output || 'text').emit(result);
-
-  if (!isSuccess(status)) {
-    throw new TaskFailedError(taskId, 'import', status);
-  }
-  if (rawOpts.strict && parsed.skippedCount > 0) {
-    const e = new CliError(
-      `--strict: import completed but ${parsed.skippedCount} rule(s) skipped. See log for details.`
-    );
-    e.exitCode = 1;
-    throw e;
-  }
-}
-
-async function terminateActiveImport(client) {
-  const search = await client.post('/api/v1/taskruns/search', {
-    filter: [
-      { attribute: 'type', operator: 'In', value: 'import-rules' },
-      { attribute: 'type', operator: 'In', value: 'import-workflows' }
-    ]
-  });
-  const active = (search?.items || search?.taskRuns || []).find((r) =>
-    ['Submitted', 'Running'].includes(r.taskStatus || r.status)
-  );
-  if (!active) {
-    log.warn('No active import found to terminate');
-    return;
-  }
-  const id = active.id || active.taskInstanceId;
-  log.info('Terminating active import', { taskId: id });
-  await client.post(`/api/v1/imports/${id}:terminate`, {});
-}
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig } from '../core/config.js';
+import { KeycloakClientCredentialsAuth } from '../core/auth.js';
+import { IcedqApiClient } from '../core/client.js';
+import { pollTask } from '../core/poller.js';
+import { Reporter } from '../core/reporter.js';
+import { parseImportLog } from '../lib/log-parser.js';
+import { isSuccess } from '../lib/status-enum.js';
+import { ApiError, BundleError, CliError, TaskFailedError } from '../core/errors.js';
+import { log, setLevel } from '../core/logger.js';
+
+const VALID_KINDS = new Set(['rules', 'workflows']);
+
+export async function runImport(rawOpts) {
+  if (rawOpts.verbose) setLevel('debug');
+  if (rawOpts.quiet) setLevel('error');
+
+  if (!rawOpts.bundle) throw new CliError('--bundle is required');
+  if (!rawOpts.kind || !VALID_KINDS.has(rawOpts.kind)) {
+    throw new CliError(`--kind must be one of: rules, workflows`);
+  }
+  if (!rawOpts.mappingFile) {
+    throw new CliError(
+      '--mapping-file is required in v0.1. Auto-mapping (`generate-mapping`) ships in v0.2.'
+    );
+  }
+
+  const cfg = loadConfig(rawOpts);
+  const auth = new KeycloakClientCredentialsAuth({
+    keycloakUrl: cfg.keycloakUrl,
+    clientId: cfg.clientId,
+    clientSecret: cfg.clientSecret,
+    verifySsl: cfg.verifySsl
+  });
+  const client = new IcedqApiClient({
+    baseUrl: cfg.icedqUrl,
+    orgId: cfg.orgId,
+    accountId: cfg.accountId,
+    workspaceId: cfg.workspaceId,
+    auth,
+    verifySsl: cfg.verifySsl
+  });
+
+  const bundlePath = path.resolve(rawOpts.bundle);
+  const mappingPath = path.resolve(rawOpts.mappingFile);
+
+  let bundleBuffer;
+  try {
+    bundleBuffer = await readFile(bundlePath);
+  } catch (err) {
+    throw new BundleError(`could not read bundle at ${bundlePath}: ${err.message}`);
+  }
+
+  let mappingDoc;
+  try {
+    const text = await readFile(mappingPath, 'utf8');
+    mappingDoc = JSON.parse(text);
+  } catch (err) {
+    throw new CliError(`could not parse --mapping-file at ${mappingPath}: ${err.message}`);
+  }
+
+  if (mappingDoc.useFqn === undefined) {
+    mappingDoc.useFqn = !!rawOpts.useFqn;
+  }
+
+  const submitParts = {
+    file: {
+      buffer: bundleBuffer,
+      filename: path.basename(bundlePath),
+      contentType: 'application/zip'
+    },
+    mapping: { json: mappingDoc }
+  };
+
+  const importPath = `/api/v1/imports/${rawOpts.kind}`;
+  log.info('Submitting import', { kind: rawOpts.kind, bundle: bundlePath, mapping: mappingPath });
+
+  let submitResp;
+  try {
+    submitResp = await client.postMultipart(importPath, submitParts);
+  } catch (err) {
+    if (err instanceof ApiError && err.isConstraintViolation()) {
+      const result = {
+        command: 'import',
+        status: 'ConstraintViolation',
+        hardErrors: err.messages.map(
+          (m) => `${m.fieldName ? m.fieldName + ': ' : ''}${m.violation || m.message || ''}`
+        )
+      };
+      new Reporter(rawOpts.output || 'text').emit(result);
+      throw err;
+    }
+    if (err instanceof ApiError && err.status === 409 && rawOpts.terminateOnConflict) {
+      log.warn('Active import job conflicts; locating and terminating');
+      await terminateActiveImport(client);
+      submitResp = await client.postMultipart(importPath, submitParts);
+    } else {
+      throw err;
+    }
+  }
+
+  const taskId = submitResp.taskInstanceId;
+  if (!taskId) throw new CliError(`Import submit did not return taskInstanceId: ${JSON.stringify(submitResp)}`);
+  process.stderr.write(`task-id: ${taskId}\n`);
+
+  const start = Date.now();
+  const { status, elapsedMs, attempts } = await pollTask(client, 'imports', taskId, {
+    timeoutSec: cfg.timeoutSec,
+    onTick: ({ status: s, attempt }) => log.debug('tick', { status: s, attempt })
+  });
+
+  let logText = '';
+  try {
+    logText = await client.get(`/api/v1/imports/${taskId}/log`);
+    if (typeof logText !== 'string') logText = JSON.stringify(logText);
+  } catch (err) {
+    log.warn('Could not retrieve import log', { error: err.message });
+  }
+
+  if (rawOpts.retainLog && logText) {
+    const logPath = path.resolve(rawOpts.retainLog);
+    try {
+      await writeFile(logPath, logText, 'utf8');
+      log.info('Import log retained', { logPath });
+    } catch (err) {
+      log.warn('Could not write retained log', { logPath, error: err.message });
+    }
+  }
+
+  const parsed = parseImportLog(logText);
+  const result = {
+    command: 'import',
+    taskId,
+    status,
+    attempts,
+    durationMs: elapsedMs,
+    skippedCount: parsed.skippedCount,
+    skippedRules: parsed.skippedRules,
+    hardErrors: parsed.hardErrors,
+    elapsedSinceSubmitMs: Date.now() - start
+  };
+  new Reporter(rawOpts.output || 'text').emit(result);
+
+  if (!isSuccess(status)) {
+    throw new TaskFailedError(taskId, 'import', status);
+  }
+  if (rawOpts.strict && parsed.skippedCount > 0) {
+    const e = new CliError(
+      `--strict: import completed but ${parsed.skippedCount} rule(s) skipped. See log for details.`
+    );
+    e.exitCode = 1;
+    throw e;
+  }
+}
+
+async function terminateActiveImport(client) {
+  const search = await client.post('/api/v1/taskruns/search', {
+    filter: [
+      { attribute: 'type', operator: 'In', value: 'import-rules' },
+      { attribute: 'type', operator: 'In', value: 'import-workflows' }
+    ]
+  });
+  const active = (search?.items || search?.taskRuns || []).find((r) =>
+    ['Submitted', 'Running'].includes(r.taskStatus || r.status)
+  );
+  if (!active) {
+    log.warn('No active import found to terminate');
+    return;
+  }
+  const id = active.id || active.taskInstanceId;
+  log.info('Terminating active import', { taskId: id });
+  await client.post(`/api/v1/imports/${id}:terminate`, {});
+}