@uipath/insights-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/dashboard-copy-qr3a51ys.js

@@ -0,0 +1,331 @@
+import {
+  FROM_PROCESS_KEY_FLAG,
+  TO_PROCESS_KEY_FLAG
+} from "./tool-fqh66108.js";
+import {
+  RENDER_CAVEAT,
+  caseFlag,
+  defaultedFilterValuesSentence,
+  findUnknownTables,
+  isSavedDashboardId,
+  modelFieldIds,
+  modelTableIds,
+  nothingWritten,
+  postDashboardCreate,
+  prepareDefinition,
+  projectWriteOutcome,
+  readAoDashboard,
+  serializeJsonFile,
+  slotReadCommand,
+  writeDashboardGetError,
+  writeSlotOccupied
+} from "./tool-sb0hkbsq.js";
+import {
+  InsightsHttpError,
+  MAESTRO_DASHBOARD_SOURCE_TYPE,
+  OutputFormatter,
+  RESULTS,
+  catchError,
+  describePermissionError,
+  getFileSystem,
+  resolveInsightsConfig,
+  writeInsightsFailure
+} from "./tool-bm77ha1d.js";
+import"./tool-1de529jm.js";
+
+// src/utils/dashboard-copy.ts
+var COPY_VERB = "copy";
+var COPY_PAST_VERB = "copied";
+function sourceReadCommand(from, source) {
+  return source.state === "Saved" ? `uip insights dashboards get ${source.id}` : slotReadCommand(from);
+}
+function buildCopyWording(options, source) {
+  return {
+    verb: COPY_VERB,
+    pastVerb: COPY_PAST_VERB,
+    landedAdvice: "The copy succeeded and the row exists, so do not copy again: a second copy into the same slot fails as a duplicate.",
+    requestRecovery: `The definition came from the source process, so nothing here is yours to edit. Check ${FROM_PROCESS_KEY_FLAG} names the process you meant, and read it with '${slotReadCommand(options.from)}'.`,
+    definitionAdvice: "pick a destination whose slot is free, or free this one by deleting the dashboard that read reports, with 'uip insights dashboards delete <id> --yes'",
+    comparisonSource: `the source definition, which '${sourceReadCommand(options.from, source)}' reads`
+  };
+}
+var MAX_SOURCE_MESSAGE_LENGTH = 240;
+var CONTROL_CHARACTERS = /[\p{Cc}\p{Cf}]/gu;
+function echoSourceText(text) {
+  const flat = text.replace(CONTROL_CHARACTERS, " ");
+  return flat.length > MAX_SOURCE_MESSAGE_LENGTH ? `${flat.slice(0, MAX_SOURCE_MESSAGE_LENGTH)}…` : flat;
+}
+function writeCopyReadFailed(error, options, target, subject, flag, readCommand) {
+  if (!(error instanceof InsightsHttpError) || error.status !== 404) {
+    writeDashboardGetError(error, target);
+    return;
+  }
+  writeInsightsFailure({
+    errorCode: "not_found",
+    retry: "RetryWillNotFix",
+    message: `Insights could not read ${subject}: ${error.message}`,
+    instructions: `${nothingWritten(COPY_PAST_VERB)} into process ${options.to.processKey}. Check ${flag} names a Maestro process of the active tenant, and read it on its own with '${readCommand}'.`
+  }, error);
+}
+function copySides(options) {
+  return [
+    {
+      slot: options.from,
+      flag: FROM_PROCESS_KEY_FLAG,
+      subject: `the dashboard of source process ${options.from.processKey}`
+    },
+    {
+      slot: options.to,
+      flag: TO_PROCESS_KEY_FLAG,
+      subject: `the dashboard slot of destination process ${options.to.processKey}`
+    }
+  ];
+}
+async function readCopySlot(config, options, side) {
+  const [error, definition] = await readAoDashboard(config, side.slot.slotId);
+  if (error) {
+    writeCopyReadFailed(error, options, side.slot, side.subject, side.flag, slotReadCommand(side.slot));
+    return;
+  }
+  return definition;
+}
+async function readSavedSource(config, options, dashboardId) {
+  const [error, definition] = await readAoDashboard(config, dashboardId);
+  if (error) {
+    writeCopyReadFailed(error, options, {
+      kind: "id",
+      dashboardId,
+      sourceType: MAESTRO_DASHBOARD_SOURCE_TYPE
+    }, `dashboard ${dashboardId}, saved for source process ${options.from.processKey}`, FROM_PROCESS_KEY_FLAG, `uip insights dashboards get ${dashboardId}`);
+    return;
+  }
+  return definition;
+}
+var TEMPLATE_COPY_NAMES = {
+  process: "Maestro process monitoring",
+  case: "Maestro case monitoring"
+};
+function isBlank(name) {
+  return name == null || name.trim() === "";
+}
+function buildCopyInput(source, to) {
+  const nameDerived = isBlank(source.name);
+  const { version: _version, ...input } = source;
+  if (!nameDerived) {
+    return { input, nameDerived };
+  }
+  return {
+    input: { ...input, name: TEMPLATE_COPY_NAMES[to.slotKind] },
+    nameDerived
+  };
+}
+function writeDestinationOccupied(to, destination) {
+  writeSlotOccupied(to.processKey, destination.id, " and copy never overwrites", `Remove it with 'uip insights dashboards delete ${destination.id} --yes' and copy again, or pick a destination whose slot is free.`);
+}
+function createDirectlyCommand(to) {
+  return `uip insights dashboards create --process-key ${to.processKey}${caseFlag(to)} --file <path>`;
+}
+function fixSourceAdvice(source) {
+  if (!isSavedDashboardId(source.id)) {
+    return;
+  }
+  return `fix dashboard ${source.id} with 'uip insights dashboards get ${source.id} --output-file <path>', edit it, and 'uip insights dashboards update ${source.id} --file <path> --expected-version ${source.version ?? "<version>"}'`;
+}
+function writeSourceFault(fault, source, options) {
+  const { from, to } = options;
+  const fixAdvice = fixSourceAdvice(source);
+  const choices = fixAdvice === undefined ? `create the correct definition directly with '${createDirectlyCommand(to)}'` : `${fixAdvice} before copying again, or create it into the destination directly with '${createDirectlyCommand(to)}'`;
+  writeInsightsFailure({
+    errorCode: "invalid_argument",
+    retry: "RetryWillNotFix",
+    message: `The dashboard of process ${from.processKey} cannot be copied to process ${to.processKey}: ${echoSourceText(fault.message)}`,
+    instructions: `${nothingWritten(COPY_PAST_VERB)} into process ${to.processKey}. Either ${choices}.`
+  });
+}
+function writeDestinationModelEmpty(options) {
+  const { from, to } = options;
+  writeInsightsFailure({
+    errorCode: "invalid_argument",
+    retry: "RetryWillNotFix",
+    message: `The dashboard of process ${from.processKey} cannot be copied to process ${to.processKey}: the destination's deployment carries no AO data model, so it has no tables a dashboard can name and every table in the copy would fail to resolve (resolveTableReferences.ts:11-13).`,
+    instructions: `${nothingWritten(COPY_PAST_VERB)} into process ${to.processKey}. The source dashboard is not the cause, and a direct create into the destination meets the same empty model. Check '${slotReadCommand(to)}' returns tables for process ${to.processKey}, then copy again.`
+  });
+}
+async function writeCopyArtifact(options, path, request) {
+  const fs = getFileSystem();
+  const [writeError] = await catchError(fs.writeFile(fs.path.resolve(path), serializeJsonFile(request)));
+  if (writeError === undefined) {
+    return true;
+  }
+  writeInsightsFailure({
+    errorCode: describePermissionError(writeError) ? "local_permission_denied" : "invalid_argument",
+    retry: "RetryWillNotFix",
+    message: `Failed to write '${path}': ${writeError.message}`,
+    instructions: `${nothingWritten(COPY_PAST_VERB)} into process ${options.to.processKey}: the copy stops before the create when its artifact cannot be written. Pass --output-file a writable file path (the parent directories are created for you), or drop the flag and copy again.`
+  });
+  return false;
+}
+function sourceSentence(outcome) {
+  const { from } = outcome.options;
+  if (outcome.source.state === "Saved") {
+    return `Dashboard ${outcome.source.id}, saved for process ${from.processKey}, was copied.`;
+  }
+  return `The ${from.slotKind} slot of ${from.processKey} holds no saved dashboard, so what was copied is the built-in ${from.slotKind} monitoring template, with whatever custom variable field definitions that key resolved to. A key that names no Maestro process reads back the same template with none, so confirm ${FROM_PROCESS_KEY_FLAG} with '${slotReadCommand(from)}' before trusting the copy; author on top of the copy if the destination needs different variables.`;
+}
+function updateCopyCommand(outcome) {
+  return `uip insights dashboards update ${outcome.createdId} --file <path> --expected-version ${outcome.readBack.version ?? "<version>"}`;
+}
+function nameSentence(outcome) {
+  if (!outcome.source.nameDerived) {
+    return;
+  }
+  if (outcome.source.state === "Saved") {
+    return `Dashboard ${outcome.source.id} is stored with a blank name, which the create route refuses, so the copy was given a placeholder name; rename it with '${updateCopyCommand(outcome)}'.`;
+  }
+  return `The source carried no name, so the copy was named after the template it is; rename it with '${updateCopyCommand(outcome)}'.`;
+}
+function sourceOnlyFieldsSentence(outcome) {
+  const ids = outcome.source.sourceOnlyFieldIds;
+  if (ids.length === 0) {
+    return;
+  }
+  const { from, to } = outcome.options;
+  const sample = ids.slice(0, 3).map(echoSourceText).join(", ");
+  const more = ids.length > 3 ? ", and more" : "";
+  return `${ids.length} field id${ids.length === 1 ? "" : "s"} in the copy ${ids.length === 1 ? "is" : "are"} not in the destination's slot template (${sample}${more}). They come from custom variables process ${from.processKey} declares and process ${to.processKey} does not; whether a chart over such a field draws in the destination is unverified. Declare those variables on process ${to.processKey} in Maestro, or edit the charts that name them with '${updateCopyCommand(outcome)}'.`;
+}
+function slotSentence(outcome) {
+  const { to } = outcome.options;
+  if (outcome.slotState === "Served") {
+    return `The Maestro Monitoring tab of process ${to.processKey} now reads dashboard ${outcome.createdId}.`;
+  }
+  return `The destination slot could not be re-read after the copy; run '${slotReadCommand(to)}' to confirm it now serves dashboard ${outcome.createdId}.`;
+}
+function buildCopyInstructions(outcome) {
+  const parts = [sourceSentence(outcome)];
+  for (const sentence of [
+    nameSentence(outcome),
+    sourceOnlyFieldsSentence(outcome)
+  ]) {
+    if (sentence !== undefined) {
+      parts.push(sentence);
+    }
+  }
+  if (outcome.create.defaultedFilterValues > 0) {
+    parts.push(defaultedFilterValuesSentence(outcome.create.defaultedFilterValues));
+  }
+  parts.push(slotSentence(outcome), "The two dashboards are independent from here: an edit to one does not reach the other, because the copy is a separate row with its own id.");
+  if (outcome.options.outputFile !== undefined) {
+    parts.push(`The definition as sent was written to ${outcome.options.outputFile} in camelCase with no CLI envelope, before the create.`);
+  }
+  parts.push(`Read the full definition with 'uip insights dashboards get ${outcome.createdId}'. ${RENDER_CAVEAT}`);
+  return parts.join(" ");
+}
+function buildCopyData(outcome) {
+  const { options, readBack, source } = outcome;
+  const data = {
+    dashboardId: outcome.createdId,
+    fromProcessKey: options.from.processKey,
+    toProcessKey: options.to.processKey,
+    slotId: options.to.slotId,
+    sourceState: source.state,
+    sourceDashboardId: source.id,
+    nameDerived: source.nameDerived,
+    sourceOnlyFieldIds: source.sourceOnlyFieldIds,
+    ...projectWriteOutcome(readBack),
+    filterValuesDefaulted: outcome.create.defaultedFilterValues,
+    copyState: "Succeeded",
+    verificationState: "ReadBackSucceeded",
+    slotState: outcome.slotState
+  };
+  if (options.outputFile !== undefined) {
+    data.outputFile = options.outputFile;
+  }
+  return data;
+}
+async function executeDashboardCopy(options) {
+  const config = await resolveInsightsConfig();
+  if (config === null) {
+    return;
+  }
+  const [from, to] = copySides(options);
+  const sourceSlot = await readCopySlot(config, options, from);
+  if (sourceSlot === undefined) {
+    return;
+  }
+  const destinationTemplate = await readCopySlot(config, options, to);
+  if (destinationTemplate === undefined) {
+    return;
+  }
+  if (isSavedDashboardId(destinationTemplate.id)) {
+    writeDestinationOccupied(options.to, destinationTemplate);
+    return;
+  }
+  const state = isSavedDashboardId(sourceSlot.id) ? "Saved" : "Template";
+  const sourceDocument = state === "Saved" ? await readSavedSource(config, options, sourceSlot.id) : sourceSlot;
+  if (sourceDocument === undefined) {
+    return;
+  }
+  const prepared = prepareCopy({ document: sourceDocument, state }, destinationTemplate, options);
+  if (prepared === undefined) {
+    return;
+  }
+  if (options.outputFile !== undefined && !await writeCopyArtifact(options, options.outputFile, prepared.create.request)) {
+    return;
+  }
+  await sendCopy(config, options, prepared);
+}
+function findSourceOnlyFieldIds(sourceDocument, destinationTemplate) {
+  const destinationFields = modelFieldIds(destinationTemplate);
+  return [...modelFieldIds(sourceDocument)].filter((id) => !destinationFields.has(id));
+}
+function prepareCopy(source, destinationTemplate, options) {
+  const modelTables = modelTableIds(destinationTemplate);
+  if (modelTables.size === 0) {
+    writeDestinationModelEmpty(options);
+    return;
+  }
+  const { input, nameDerived } = buildCopyInput(source.document, options.to);
+  const result = prepareDefinition(input, options.to.slotId);
+  if (result.kind === "invalid") {
+    writeSourceFault(result.fault, source.document, options);
+    return;
+  }
+  const tableFault = findUnknownTables(result.prepared.request, modelTables);
+  if (tableFault !== null) {
+    writeSourceFault(tableFault, source.document, options);
+    return;
+  }
+  return {
+    create: result.prepared,
+    source: {
+      state: source.state,
+      id: source.document.id,
+      nameDerived,
+      sourceOnlyFieldIds: findSourceOnlyFieldIds(source.document, destinationTemplate)
+    }
+  };
+}
+async function sendCopy(config, options, prepared) {
+  const created = await postDashboardCreate(config, prepared.create.request, options.to, buildCopyWording(options, prepared.source));
+  if (created === undefined) {
+    return;
+  }
+  const outcome = {
+    ...created,
+    options,
+    source: prepared.source,
+    create: prepared.create
+  };
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "InsightsDashboardCopy",
+    Data: buildCopyData(outcome),
+    Instructions: buildCopyInstructions(outcome)
+  });
+}
+export {
+  executeDashboardCopy
+};
+
+//# debugId=59EDCED18B854BE264756E2164756E21